3 Commits

• [hooks] userpromptsubmit - hook before user's prompt is executed (#14626)

  - this allows blocking the user's prompts from executing, and also
  prevents them from entering history
  - handles the edge case where you can both prevent the user's prompt AND
  add n amount of additionalContexts
  - refactors some old code into common.rs where hooks overlap
  functionality
  - refactors additionalContext being previously added to user messages,
  instead we use developer messages for them
  - handles queued messages correctly
  
  Sample hook for testing - if you write "[block-user-submit]" this hook
  will stop the thread:
  
  example run
  ```
  › sup
  
  
  • Running UserPromptSubmit hook: reading the observatory notes
  
  UserPromptSubmit hook (completed)
    warning: wizard-tower UserPromptSubmit demo inspected: sup
    hook context: Wizard Tower UserPromptSubmit demo fired. For this reply only, include the exact
  phrase 'observatory lanterns lit' exactly once near the end.
  
  • Just riding the cosmic wave and ready to help, my friend. What are we building today? observatory
    lanterns lit
  
  
  › and [block-user-submit]
  
  
  • Running UserPromptSubmit hook: reading the observatory notes
  
  UserPromptSubmit hook (stopped)
    warning: wizard-tower UserPromptSubmit demo blocked the prompt on purpose.
    stop: Wizard Tower demo block: remove [block-user-submit] to continue.
  ```
  
  .codex/config.toml
  ```
  [features]
  codex_hooks = true
  ```
  
  .codex/hooks.json
  ```
  {
    "hooks": {
      "UserPromptSubmit": [
        {
          "hooks": [
            {
              "type": "command",
              "command": "/usr/bin/python3 .codex/hooks/user_prompt_submit_demo.py",
              "timeoutSec": 10,
              "statusMessage": "reading the observatory notes"
            }
          ]
        }
      ]
    }
  }
  ```
  
  .codex/hooks/user_prompt_submit_demo.py
  ```
  #!/usr/bin/env python3
  
  import json
  import sys
  from pathlib import Path
  
  
  def prompt_from_payload(payload: dict) -> str:
      prompt = payload.get("prompt")
      if isinstance(prompt, str) and prompt.strip():
          return prompt.strip()
  
      event = payload.get("event")
      if isinstance(event, dict):
          user_prompt = event.get("user_prompt")
          if isinstance(user_prompt, str):
              return user_prompt.strip()
  
      return ""
  
  
  def main() -> int:
      payload = json.load(sys.stdin)
      prompt = prompt_from_payload(payload)
      cwd = Path(payload.get("cwd", ".")).name or "wizard-tower"
  
      if "[block-user-submit]" in prompt:
          print(
              json.dumps(
                  {
                      "systemMessage": (
                          f"{cwd} UserPromptSubmit demo blocked the prompt on purpose."
                      ),
                      "decision": "block",
                      "reason": (
                          "Wizard Tower demo block: remove [block-user-submit] to continue."
                      ),
                  }
              )
          )
          return 0
  
      prompt_preview = prompt or "(empty prompt)"
      if len(prompt_preview) > 80:
          prompt_preview = f"{prompt_preview[:77]}..."
  
      print(
          json.dumps(
              {
                  "systemMessage": (
                      f"{cwd} UserPromptSubmit demo inspected: {prompt_preview}"
                  ),
                  "hookSpecificOutput": {
                      "hookEventName": "UserPromptSubmit",
                      "additionalContext": (
                          "Wizard Tower UserPromptSubmit demo fired. "
                          "For this reply only, include the exact phrase "
                          "'observatory lanterns lit' exactly once near the end."
                      ),
                  },
              }
          )
      )
      return 0
  
  
  if __name__ == "__main__":
      raise SystemExit(main())
  ```

  Andrei Eternal · 2026-03-17 22:09:22 -07:00
  6fef421654
• [hooks] stop continuation & stop_hook_active mechanics (#14532)

  Stop hooks now receive `stop_hook_active` and enable stop hooks to loop
  forever if they'd like to. In the initial hooks PR, we implemented a
  simpler mechanic that the stop-blocking could only happen once in a row
  
  - support stop hook adding a continuation prompt to add a further task
  - if multiple stop-blocks happen that have continuation prompts, they
  are concatenated
  
  example run:
  ```
  › hey :)
  
  
  • Running SessionStart hook: lighting the observatory
  
  SessionStart hook (completed)
    warning: Hi, I'm a session start hook for wizard-tower (startup).
    hook context: Startup context: A wimboltine stonpet is an exotic cuisine from hyperspace
  
  • Aloha :) Happy to jam with you. What are we building today?
  
  • Running Stop hook: updating the guards
  
  Stop hook (blocked)
    warning: Wizard Tower Stop hook continuing conversation
    feedback: cook the stonpet
  
  • Aloha, here’s the hyperspace move for cooking a wimboltine stonpet:
  
    1. Sear the stonpet in a hot pan with moon-oil until the edges shimmer.
    2. Add star-lime, black salt, and a little fermented nebula paste.
    3. Lower the heat and let it braise for 8 cosmic minutes with a splash of comet broth.
    4. Finish with sky herbs and serve over warm asteroid rice.
  
    The vibe: crispy outside, tender center, deep interdimensional savor.
  
  • Running Stop hook: updating the guards
  
  Stop hook (completed)
    warning: Wizard Tower Stop hook saw a second pass and stayed calm to avoid a loop.
  ```
  
  .codex/config.toml
  ```
  [features]
  codex_hooks = true
  ```
  
  .codex/hooks.json
  ```
  {
    "hooks": {
      "SessionStart": [
        {
          "matcher": "startup|resume",
          "hooks": [
            {
              "type": "command",
              "command": "/usr/bin/python3 .codex/hooks/session_start_demo.py",
              "timeoutSec": 10,
              "statusMessage": "lighting the observatory"
            }
          ]
        }
      ],
      "Stop": [
        {
          "hooks": [
            {
              "type": "command",
              "command": "/usr/bin/python3 .codex/hooks/stop_demo_block.py",
              "timeoutSec": 10,
              "statusMessage": "updating the guards"
            }
          ]
        }
      ]
    }
  }
  ```
  
  .codex/hooks/session_start_demo.py
  ```
  #!/usr/bin/env python3
  
  import json
  import sys
  from pathlib import Path
  
  
  def main() -> int:
      payload = json.load(sys.stdin)
      cwd = Path(payload.get("cwd", ".")).name or "wizard-tower"
      source = payload.get("source", "startup")
      source_label = "resume" if source == "resume" else "startup"
      source_prefix = (
          "Resume context:"
          if source == "resume"
          else "Startup context:"
      )
  
      output = {
          "systemMessage": (
              f"Hi, I'm a session start hook for {cwd} ({source_label})."
          ),
          "hookSpecificOutput": {
              "hookEventName": "SessionStart",
              "additionalContext": (
                  f"{source_prefix} A wimboltine stonpet is an exotic cuisine from hyperspace"
              ),
          },
      }
      print(json.dumps(output))
      return 0
  
  
  if __name__ == "__main__":
      raise SystemExit(main())
  ```
  
  .codex/hooks/stop_demo_block.py
  ```
  #!/usr/bin/env python3
  
  import json
  import sys
  
  
  def main() -> int:
      payload = json.load(sys.stdin)
      stop_hook_active = payload.get("stop_hook_active", False)
      last_assistant_message = payload.get("last_assistant_message") or ""
      char_count = len(last_assistant_message.strip())
  
      if stop_hook_active:
          system_message = (
              "Wizard Tower Stop hook saw a second pass and stayed calm to avoid a loop."
          )
          print(json.dumps({"systemMessage": system_message}))
      else:
          system_message = (
              f"Wizard Tower Stop hook continuing conversation"
          )
          print(json.dumps({"systemMessage": system_message, "decision": "block", "reason": "cook the stonpet"}))
  
      return 0
  
  
  if __name__ == "__main__":
      raise SystemExit(main())
  ```

  Andrei Eternal · 2026-03-13 15:51:19 -07:00
  9a44a7e499
• start of hooks engine (#13276)

  (Experimental)
  
  This PR adds a first MVP for hooks, with SessionStart and Stop
  
  The core design is:
  
  - hooks live in a dedicated engine under codex-rs/hooks
  - each hook type has its own event-specific file
  - hook execution is synchronous and blocks normal turn progression while
  running
  - matching hooks run in parallel, then their results are aggregated into
  a normalized HookRunSummary
  
  On the AppServer side, hooks are exposed as operational metadata rather
  than transcript-native items:
  
  - new live notifications: hook/started, hook/completed
  - persisted/replayed hook results live on Turn.hookRuns
  - we intentionally did not add hook-specific ThreadItem variants
  
  Hooks messages are not persisted, they remain ephemeral. The context
  changes they add are (they get appended to the user's prompt)

  Andrei Eternal · 2026-03-10 04:11:31 +00:00
  244b2d53f4