wade-cli 1.2.4__tar.gz → 1.2.6__tar.gz

{wade_cli-1.2.4 → wade_cli-1.2.6}/AGENTS.md

@@ -93,8 +93,10 @@ No circular dependencies. Models are pure data. Services orchestrate. **Never im
 AI tool adapters are not part of this repo — they live in the external [`crossby`](https://github.com/ivanviragine/crossby) package (`pyproject.toml`). See `docs/dev/architecture.md` for what moved there.
 
 Native planning prefers Crossby's ordinary interactive launch with native Plan
-mode and supported approval flags. Tools without terminal Plan support (Codex)
-retain the public collected-session/preflight API. WADE owns explicit file/stdin
+mode and supported approval flags. For deferred startup (currently Codex), WADE
+handles Crossby's typed ready/submitted events and sends the task exactly once;
+Crossby owns `/plan` and terminal mechanics. The public collected-session API
+remains the fallback for adapters without terminal Plan support. WADE owns explicit file/stdin
 handoff, review receipts bound to current content and frozen skills, validation,
 knowledge handoff, and task persistence; native flags/protocols stay upstream.
 Update the tracked `uv.lock` and Crossby contract tripwire with dependency

{wade_cli-1.2.4 → wade_cli-1.2.6}/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://conventionalcommits.org/).
 
+## [v1.2.6] — 2026-09-23
+
+### Chores
+
+- adopt Crossby 0.36 model catalogs and defaults (#517) (cc9ae47)
+
+## [v1.2.5] — 2026-09-16
+
+### Bug Fixes
+
+- launch Codex native UI with deferred prompt delivery (#514) (8424a77)
+
 ## [v1.2.4] — 2026-09-16
 
 ### Bug Fixes

{wade_cli-1.2.4 → wade_cli-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: wade-cli
-Version: 1.2.4
+Version: 1.2.6
 Summary: WADE — Workflow for AI-Driven Engineering
 Project-URL: Homepage, https://github.com/ivanviragine/wade
 Project-URL: Repository, https://github.com/ivanviragine/wade
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Version Control :: Git
 Requires-Python: >=3.11
-Requires-Dist: crossby<0.33.0,>=0.32.1
+Requires-Dist: crossby<0.37.0,>=0.36.0
 Requires-Dist: httpx<1.0,>=0.27
 Requires-Dist: pydantic-settings>=2.0
 Requires-Dist: pydantic>=2.0
@@ -280,11 +280,12 @@ Most workflow commands accept `--ai <tool>`, `--model <model>`, `--effort <level
 
 ## Planning & base branches
 
-`wade plan` launches **Claude, Cursor, Copilot, OpenCode, and Antigravity CLI**
+`wade plan` launches **Claude, Cursor, Copilot, OpenCode, Antigravity CLI, and Codex**
 in their own interactive terminal, with **native Plan mode active before the
 first task turn**. You keep the tool's UI, questions, and conversation. Crossby
-validates native support and translates approval flags; WADE does not type
-`/plan`, switch to an editing session, or replace the tool's questions.
+validates native support and translates approval flags. For Codex, Crossby
+submits `/plan` first and WADE sends the task on its ready event. Native questions
+and subsequent interaction stay in the tool.
 
 Use `--permission-mode` (or `--yolo`) for the native approval policy:
 
@@ -295,6 +296,7 @@ Use `--permission-mode` (or `--yolo`) for the native approval policy:
 | Copilot | `default`, `accept-edits`, `yolo` |
 | OpenCode | `default`, `yolo` |
 | Antigravity CLI | `default`, `yolo` |
+| Codex CLI | `default`, `accept-edits`, `auto`, `yolo` |
 
 Unsupported combinations fail before creating a planning worktree. These are
 native approval settings, not permission to implement the plan. The later
@@ -319,20 +321,23 @@ including an explicit empty list when appropriate. The parent revalidates the
 completed handoff after exit, then creates tasks and draft PRs. Failed or missing
 handoffs retain output and create no tasks.
 
-**Codex keeps the collected-session path** for now: Crossby collects its native
-plan artifact and questions, then WADE runs review and validation in the parent.
-Its `--yolo` affects parent confirmations only; `auto` and `accept-edits` remain
-unsupported. Codex's native session provenance is retained separately from the
-plan; no transcript or token totals are invented from plan text.
-
-Interactive terminals use the ordinary sandbox default (off); the Codex collector
-keeps its safe default (on). Explicit `--sandbox`, `--network-access` /
+**Codex requires CLI 0.154.x and a POSIX terminal (macOS/Linux).** Crossby's
+current startup adapter waits for the rendered Plan indicator before WADE sends
+the initial task; unknown versions or an unrecognized startup screen fail
+without retrying the task. This temporary terminal adapter can be replaced by a
+native launch flag when Codex provides one. WADE requires the task-submitted
+event before collecting the explicit reviewed handoff. Codex can submit plan
+Markdown through `--from-stdin`; no native file destination is assumed.
+
+All native terminals now use the ordinary sandbox default (off), including Codex;
+use `--sandbox` or `ai.plan.sandbox: true` to retain confinement. The retained
+collector fallback has its own safe default (on). Explicit `--sandbox`, `--network-access` /
 `--no-network-access`, and `--trusted-dir` require support from the selected tool.
 No network flag adds no network grant and does not promise isolation.
 `--approval-policy on-request|untrusted|never` and `--timeout` are collector
 settings; interactive terminals use `--permission-mode` and have no time limit.
-Set `ai.plan.mode` to `interactive` or leave it unset for native terminals; leave
-it unset for Codex. GUI launchers remain unsupported for planning.
+Set `ai.plan.mode` to `interactive` or leave it unset for native terminals.
+GUI launchers remain unsupported for planning.
 
 Authentication, model availability, and successful handoff are runtime checks.
 Native terminal output is retained for recovery; usage is reported only when

{wade_cli-1.2.4 → wade_cli-1.2.6}/README.md

@@ -244,11 +244,12 @@ Most workflow commands accept `--ai <tool>`, `--model <model>`, `--effort <level
 
 ## Planning & base branches
 
-`wade plan` launches **Claude, Cursor, Copilot, OpenCode, and Antigravity CLI**
+`wade plan` launches **Claude, Cursor, Copilot, OpenCode, Antigravity CLI, and Codex**
 in their own interactive terminal, with **native Plan mode active before the
 first task turn**. You keep the tool's UI, questions, and conversation. Crossby
-validates native support and translates approval flags; WADE does not type
-`/plan`, switch to an editing session, or replace the tool's questions.
+validates native support and translates approval flags. For Codex, Crossby
+submits `/plan` first and WADE sends the task on its ready event. Native questions
+and subsequent interaction stay in the tool.
 
 Use `--permission-mode` (or `--yolo`) for the native approval policy:
 
@@ -259,6 +260,7 @@ Use `--permission-mode` (or `--yolo`) for the native approval policy:
 | Copilot | `default`, `accept-edits`, `yolo` |
 | OpenCode | `default`, `yolo` |
 | Antigravity CLI | `default`, `yolo` |
+| Codex CLI | `default`, `accept-edits`, `auto`, `yolo` |
 
 Unsupported combinations fail before creating a planning worktree. These are
 native approval settings, not permission to implement the plan. The later
@@ -283,20 +285,23 @@ including an explicit empty list when appropriate. The parent revalidates the
 completed handoff after exit, then creates tasks and draft PRs. Failed or missing
 handoffs retain output and create no tasks.
 
-**Codex keeps the collected-session path** for now: Crossby collects its native
-plan artifact and questions, then WADE runs review and validation in the parent.
-Its `--yolo` affects parent confirmations only; `auto` and `accept-edits` remain
-unsupported. Codex's native session provenance is retained separately from the
-plan; no transcript or token totals are invented from plan text.
-
-Interactive terminals use the ordinary sandbox default (off); the Codex collector
-keeps its safe default (on). Explicit `--sandbox`, `--network-access` /
+**Codex requires CLI 0.154.x and a POSIX terminal (macOS/Linux).** Crossby's
+current startup adapter waits for the rendered Plan indicator before WADE sends
+the initial task; unknown versions or an unrecognized startup screen fail
+without retrying the task. This temporary terminal adapter can be replaced by a
+native launch flag when Codex provides one. WADE requires the task-submitted
+event before collecting the explicit reviewed handoff. Codex can submit plan
+Markdown through `--from-stdin`; no native file destination is assumed.
+
+All native terminals now use the ordinary sandbox default (off), including Codex;
+use `--sandbox` or `ai.plan.sandbox: true` to retain confinement. The retained
+collector fallback has its own safe default (on). Explicit `--sandbox`, `--network-access` /
 `--no-network-access`, and `--trusted-dir` require support from the selected tool.
 No network flag adds no network grant and does not promise isolation.
 `--approval-policy on-request|untrusted|never` and `--timeout` are collector
 settings; interactive terminals use `--permission-mode` and have no time limit.
-Set `ai.plan.mode` to `interactive` or leave it unset for native terminals; leave
-it unset for Codex. GUI launchers remain unsupported for planning.
+Set `ai.plan.mode` to `interactive` or leave it unset for native terminals.
+GUI launchers remain unsupported for planning.
 
 Authentication, model availability, and successful handoff are runtime checks.
 Native terminal output is retained for recovery; usage is reported only when

{wade_cli-1.2.4 → wade_cli-1.2.6}/docs/dev/architecture.md

@@ -197,9 +197,13 @@ Adding support for a new AI tool means contributing an adapter to crossby, not t
 `plan_service.plan()` resolves the final confirmed selection before worktree or
 provider mutations. An adapter advertising `supports_plan_mode` uses ordinary
 `launch(plan_mode=True)` after `validate_plan_mode_request()`. Crossby owns
-native flags, version gates, and approval compatibility. WADE forwards the
+native flags, version gates, and approval compatibility. For adapters declaring
+`supports_ready_event`, WADE uses the public `on_event` callback: `PLAN_READY`
+submits the task through `session.send_message()` exactly once and
+`MESSAGE_SUBMITTED` confirms delivery before handoff collection. Crossby owns
+Codex's `/plan` activation and PTY; WADE never reads screen text. WADE forwards the
 requested autonomy tier without downgrading unsupported Plan combinations.
-Claude, Cursor, Copilot, OpenCode, and Antigravity CLI currently use this path.
+Claude, Cursor, Copilot, OpenCode, Antigravity CLI, and Codex use this path.
 Questions and the full terminal UI remain native. Explicit unsupported sandbox,
 network, trusted-directory, timeout, or transport settings fail before launch.
 The default sandbox is off, as for ordinary interactive launches.
@@ -223,7 +227,7 @@ Nonzero exits and absent/stale handoffs retain output without creating tasks.
 Native terminal output can supply adapter-parsed usage; the WADE handoff ID is
 never presented as a native CLI session ID.
 
-Tools without terminal Plan support, currently Codex, retain the public
+Tools without terminal Plan support retain the public
 `PlanSessionRequest` → `preflight_plan_session()` → `run_plan_session()` flow.
 `native_plan_service` consumes Crossby's complete-session metadata, required
 `PlanCommandPolicy` (`wade *` plus configured patterns), and supported path policy.
@@ -1086,7 +1090,7 @@ models:                      # values below are crossby's claude defaults, not w
     easy: claude-haiku-4.5
     medium: claude-sonnet-5
     complex: claude-sonnet-5
-    very_complex: claude-opus-5
+    very_complex: claude-opus-5.5
 provider:
   name: github
 hooks:
@@ -1273,9 +1277,9 @@ exactly as before #448. See knowledge `cc91cd11` for the generalized principle.
 
 The tier values `wade init` writes are **not wade constants** — `init_service/config_io.py::_resolve_models()` seeds them from `crossby.config.defaults.get_defaults(tool)`, so **bumping the crossby pin changes what newly initialized projects get**. The example above shows crossby's `claude` defaults at the currently pinned version; run `get_defaults()` for the authoritative set rather than trusting a doc snapshot, and re-check this block on every crossby bump. A bump does **not** rewrite tiers an existing `.wade.yml` already sets: `wade update` re-resolves the defaults and calls `_patch_config` without `force`, which backfills only *absent* tiers. So a fresh `wade init` picks up the new defaults wholesale, while an existing project changes only where it left a tier unset.
 
-**Per-command AI tool and model overrides**: The `ai` section supports `plan`, `deps`, `implement`, `review_plan`, `review_implementation`, `review_batch`, and `review_pr_comments` sub-sections (`AI_COMMAND_NAMES` in `models/config.py`), with optional `tool`, `model`, `mode`, `effort`, `enabled`, `yolo`, `permission_mode`, `sandbox`, and `timeout` keys as applicable. `sandbox` (global `ai.sandbox` or per-command) is the cross-tool AI-runtime sandbox profile resolved by `resolve_sandbox()`: CLI `--sandbox`/`--no-sandbox` > per-command > global > **`False` (unrestricted)** for ordinary launches. Native terminal planning uses that same default; Codex collection keeps its safe posture. Both preserve explicit sandbox requirements. Network access is unconditionally on for ordinary non-plan launches; planning exposes an independent default-off request — see the "AI runtime sandbox profile" section above. `timeout` bounds a headless subprocess (seconds). When **unset**, the review/deps services compute the budget with `effective_timeout` (`delegation_service.py`, #366): it scales from **payload bytes + reasoning effort** — `scaled_timeout` starts at a **600s floor** (`TIMEOUT_FLOOR`, covers CLI cold-start + a small high-effort run), adds ~0.0075 s/byte of prompt, multiplies high/xhigh/max effort by 1.5–1.75×, and clamps to a **1500s ceiling** (`TIMEOUT_CEILING`). A headless timeout is **not** discarded: `run` (`utils/process.py`) decodes and reattaches the partial stdout (bytes even under `text=True`), `_delegate_headless` returns it as `feedback` with `DelegationResult.timed_out=True`, and wade **retries once** at a longer budget (`extended_timeout`, 1.5×) — bounding the *sum* of both legs to `TOTAL_TIMEOUT_CAP` (`TIMEOUT_CEILING + TIMEOUT_CEILING * TIMEOUT_RETRY_MULTIPLIER`, ~3750s / 62.5 min) so the worst case is predictable while the retry always gets the full multiplier, never a shorter budget than the attempt that just timed out (#366 review). The pre-launch advisory — now also printed by `deps_service.analyze_deps` before a headless run, not just the review commands (#366 review) — announces that worst-case total. A crash (`CommandError` / non-zero exit) is never retried and never flagged `timed_out`. Setting `ai.<cmd>.timeout` **explicitly** is a deliberate override: it is honored verbatim and **bypasses scaling and the retry math** — the escape hatch for orchestrators with a hard tool-timeout (set it below the harness limit). The fallback chain (tool/model) is: CLI `--ai`/`--model` flag -> command-specific config -> global `default_tool`. This is implemented in `ProjectConfig.get_ai_tool(command)` and `ProjectConfig.get_model(command)`. When `mode` is omitted, `review_plan` and `review_implementation` default to `prompt`, while `review_batch` defaults to `interactive`. `review_pr_comments` (#389) governs the **auto-launched review session** (post-`done` "Wait for reviews" → comments land → `review_service.start`): it resolves that session's tool, model, effort, and autonomy tier under its own key rather than inheriting `ai.implement.*`. The inherited implementation-session `tool` / `model` / `permission_mode` are honored only when the user set them *explicitly* (`--ai` / `--model` / `--permission-mode` / `--yolo`); the implementation flow forwards its already-*resolved* concrete values (never `None`), which would otherwise short-circuit the resolvers and shadow `ai.review_pr_comments` — so a merely config/default-derived value is dropped and the review config (then global `ai.*`) governs.
+**Per-command AI tool and model overrides**: The `ai` section supports `plan`, `deps`, `implement`, `review_plan`, `review_implementation`, `review_batch`, and `review_pr_comments` sub-sections (`AI_COMMAND_NAMES` in `models/config.py`), with optional `tool`, `model`, `mode`, `effort`, `enabled`, `yolo`, `permission_mode`, `sandbox`, and `timeout` keys as applicable. `sandbox` (global `ai.sandbox` or per-command) is the cross-tool AI-runtime sandbox profile resolved by `resolve_sandbox()`: CLI `--sandbox`/`--no-sandbox` > per-command > global > **`False` (unrestricted)** for ordinary launches. Native terminal planning uses that same default; the collector fallback keeps its safe posture. Both preserve explicit sandbox requirements. Network access is unconditionally on for ordinary non-plan launches; planning exposes an independent default-off request — see the "AI runtime sandbox profile" section above. `timeout` bounds a headless subprocess (seconds). When **unset**, the review/deps services compute the budget with `effective_timeout` (`delegation_service.py`, #366): it scales from **payload bytes + reasoning effort** — `scaled_timeout` starts at a **600s floor** (`TIMEOUT_FLOOR`, covers CLI cold-start + a small high-effort run), adds ~0.0075 s/byte of prompt, multiplies high/xhigh/max effort by 1.5–1.75×, and clamps to a **1500s ceiling** (`TIMEOUT_CEILING`). A headless timeout is **not** discarded: `run` (`utils/process.py`) decodes and reattaches the partial stdout (bytes even under `text=True`), `_delegate_headless` returns it as `feedback` with `DelegationResult.timed_out=True`, and wade **retries once** at a longer budget (`extended_timeout`, 1.5×) — bounding the *sum* of both legs to `TOTAL_TIMEOUT_CAP` (`TIMEOUT_CEILING + TIMEOUT_CEILING * TIMEOUT_RETRY_MULTIPLIER`, ~3750s / 62.5 min) so the worst case is predictable while the retry always gets the full multiplier, never a shorter budget than the attempt that just timed out (#366 review). The pre-launch advisory — now also printed by `deps_service.analyze_deps` before a headless run, not just the review commands (#366 review) — announces that worst-case total. A crash (`CommandError` / non-zero exit) is never retried and never flagged `timed_out`. Setting `ai.<cmd>.timeout` **explicitly** is a deliberate override: it is honored verbatim and **bypasses scaling and the retry math** — the escape hatch for orchestrators with a hard tool-timeout (set it below the harness limit). The fallback chain (tool/model) is: CLI `--ai`/`--model` flag -> command-specific config -> global `default_tool`. This is implemented in `ProjectConfig.get_ai_tool(command)` and `ProjectConfig.get_model(command)`. When `mode` is omitted, `review_plan` and `review_implementation` default to `prompt`, while `review_batch` defaults to `interactive`. `review_pr_comments` (#389) governs the **auto-launched review session** (post-`done` "Wait for reviews" → comments land → `review_service.start`): it resolves that session's tool, model, effort, and autonomy tier under its own key rather than inheriting `ai.implement.*`. The inherited implementation-session `tool` / `model` / `permission_mode` are honored only when the user set them *explicitly* (`--ai` / `--model` / `--permission-mode` / `--yolo`); the implementation flow forwards its already-*resolved* concrete values (never `None`), which would otherwise short-circuit the resolvers and shadow `ai.review_pr_comments` — so a merely config/default-derived value is dropped and the review config (then global `ai.*`) governs.
 
-**Permission (autonomy) mode vs. delegation `mode` — two orthogonal axes**: The `mode` key (`DelegationMode`: `prompt`/`interactive`/`headless`, `models/delegation.py`) governs *how* a tool is dispatched. `permission_mode` (`PermissionMode`: `default`/`accept-edits`/`auto`/`yolo`, `models/permission.py`) governs *how much* the tool may do without prompting — the autonomy axis crossby exposes via the `yolo`/`auto`/`accept_edits` launch booleans. Do **not** conflate them: they live in separate modules on purpose. Resolution (`resolve_permission_mode()` in `ai_resolution.py`) follows CLI `--permission-mode` > `--yolo` alias > command config > global config > `default`; `permission_mode` wins over the legacy `yolo` alias at any level, and `get_yolo()`/`resolve_yolo()` are thin shims that derive from the resolved mode so the alias has a single source of truth. WADE forwards only the *requested* tier and does **not** gate on per-tool capability — crossby owns capability-aware downgrades and warnings (`_autonomy_launch_args`), so `auto` on a tool without native auto support can downgrade to `accept-edits` instead of WADE silently disabling it. The headless delegation path always forces `default` (no autonomy grant) regardless of config, since `deps`/`review_plan`/`review_implementation`/`review_batch` are read/analytical; `review_pr_comments` is the exception — it launches an *interactive* session and honors its configured `ai.review_pr_comments.permission_mode`. Native terminal planning forwards the requested tier through Crossby's Plan-mode validator and ordinary launch; unsupported combinations fail instead of downgrading. Codex retains `run_plan_session`, with parent-only `default`/`yolo` and separate native approval policy. Ordinary invalid autonomy configuration warns and falls back to `default`. Every ordinary launch command (`implement`, `implement-batch`, `review pr-comments`, `review plan`/`implementation`/`batch`, `task deps`, and the delegation paths) exposes `--yolo`/`--permission-mode` and resolves + forwards the tier; `confirm_ai_selection()` (`ai_resolution.py`) **always displays** the resolved tool/model/effort/permission mode with a per-tier descriptor (`permission.describe_permission_mode`) before its skip guard, so the mode surfaces on every path (TTY, non-TTY, headless, all-flags-explicit) and what is shown always equals what is applied. For the read-only headless paths (`deps`/`review_*` in headless mode), the service computes the *effective* mode as `default` and uses that single value for both display and the `DelegationRequest`, mirroring the `delegation_service` headless force-default rule. In addition, a completed non-zero headless exit preserves trimmed stdout and appends a clearly labeled stderr tail (the final 20 non-empty lines, capped at 4,000 characters, with truncation labeled); only failures with neither stream retain the generic no-output fallback.
+**Permission (autonomy) mode vs. delegation `mode` — two orthogonal axes**: The `mode` key (`DelegationMode`: `prompt`/`interactive`/`headless`, `models/delegation.py`) governs *how* a tool is dispatched. `permission_mode` (`PermissionMode`: `default`/`accept-edits`/`auto`/`yolo`, `models/permission.py`) governs *how much* the tool may do without prompting — the autonomy axis crossby exposes via the `yolo`/`auto`/`accept_edits` launch booleans. Do **not** conflate them: they live in separate modules on purpose. Resolution (`resolve_permission_mode()` in `ai_resolution.py`) follows CLI `--permission-mode` > `--yolo` alias > command config > global config > `default`; `permission_mode` wins over the legacy `yolo` alias at any level, and `get_yolo()`/`resolve_yolo()` are thin shims that derive from the resolved mode so the alias has a single source of truth. WADE forwards only the *requested* tier and does **not** gate on per-tool capability — crossby owns capability-aware downgrades and warnings (`_autonomy_launch_args`), so `auto` on a tool without native auto support can downgrade to `accept-edits` instead of WADE silently disabling it. The headless delegation path always forces `default` (no autonomy grant) regardless of config, since `deps`/`review_plan`/`review_implementation`/`review_batch` are read/analytical; `review_pr_comments` is the exception — it launches an *interactive* session and honors its configured `ai.review_pr_comments.permission_mode`. Native terminal planning forwards the requested tier through Crossby's Plan-mode validator and ordinary launch; unsupported combinations fail instead of downgrading. Codex uses native terminal startup events and supports all four approval tiers. The retained collector fallback uses parent-only `default`/`yolo` and a separate native approval policy. Ordinary invalid autonomy configuration warns and falls back to `default`. Every ordinary launch command (`implement`, `implement-batch`, `review pr-comments`, `review plan`/`implementation`/`batch`, `task deps`, and the delegation paths) exposes `--yolo`/`--permission-mode` and resolves + forwards the tier; `confirm_ai_selection()` (`ai_resolution.py`) **always displays** the resolved tool/model/effort/permission mode with a per-tier descriptor (`permission.describe_permission_mode`) before its skip guard, so the mode surfaces on every path (TTY, non-TTY, headless, all-flags-explicit) and what is shown always equals what is applied. For the read-only headless paths (`deps`/`review_*` in headless mode), the service computes the *effective* mode as `default` and uses that single value for both display and the `DelegationRequest`, mirroring the `delegation_service` headless force-default rule. In addition, a completed non-zero headless exit preserves trimmed stdout and appends a clearly labeled stderr tail (the final 20 non-empty lines, capped at 4,000 characters, with truncation labeled); only failures with neither stream retain the generic no-output fallback.
 
 **Worktree hooks**: The `hooks` section lets projects run setup automatically when a worktree is created. `post_worktree_create` points to a script that runs in the new worktree (e.g., installing dependencies). `copy_to_worktree` lists files to copy from the project root into the worktree before the hook runs (e.g., `.env`). Hook failures are non-fatal — a warning is logged and the session continues.
 

{wade_cli-1.2.4 → wade_cli-1.2.6}/docs/dev/native-cli-plan-verification.md

@@ -2,7 +2,9 @@
 
 Verified on 2026-09-16 with the published Crossby 0.32.1 wheel. Upstream approval
 support shipped in [Crossby PR #181](https://github.com/ivanviragine/crossby/pull/181).
-Codex remains on its existing collected-session path.
+Codex terminal support subsequently shipped in Crossby 0.33.0 via
+[PR #183](https://github.com/ivanviragine/crossby/pull/183); its WADE verification
+is described below.
 
 ## Live WADE handoff
 
@@ -19,6 +21,7 @@ or PRs. Every successful run retained the original greeting source unchanged.
 | Cursor 2026.09.10-fd3934a | Passed | Native plan file, import, self-review/ack, completion in fallback workspace |
 | OpenCode 1.18.29 | Passed | Native Plan session, explicit handoff, self-review/ack, completion in fallback workspace |
 | Antigravity CLI 1.2.3 | Passed | Native artifact file, import, self-review/ack, completion; fallback and real detached worktree with bootstrap/guards |
+| Codex CLI 0.154.0 | Reviewed handoff verified | Published Crossby 0.33.0; ready-event prompt delivery; sandboxed detached worktree; native questions; stdin import, self-review/ack, completion |
 | Copilot | Authenticated run omitted | Explicit user request after earlier credential failure; published adapter and WADE launch contracts remain tested |
 
 Claude's native `plansDirectory` setting selects `.wade/plans/native/`. Cursor
@@ -46,7 +49,7 @@ used ordinary approvals, not unrestricted YOLO.
   later focused regressions cover native policy rejection and incomplete-output
   preservation as well.
 - Explicit host deterministic E2E lane: 109 passed, including the real completion
-  command invoked by a fake native CLI and the unchanged Codex app-server lane.
+  command invoked by a fake native CLI and the explicit collector-compatibility lane.
 - Fresh review fixed stale receipts after failed reviews, unsafe managed review
   sources, missing knowledge handoff at completion, native artifact containment,
   selected-tool bootstrap, and preservation before the first successful import.
@@ -54,3 +57,31 @@ used ordinary approvals, not unrestricted YOLO.
 Use `--worktree` on the probe for real bootstrap/guards. Keep CLI authentication
 local and distinguish native startup, completed authenticated handoff, and
 provider persistence; the live probe intentionally does not exercise the last.
+
+
+## Codex deferred startup and stdin handoff
+
+The Codex probe uses `--sandbox --worktree --model gpt-5.6-sol` and ordinary
+native approvals. Crossby alone submits `/plan`; WADE receives `PLAN_READY`,
+sends the rendered workflow prompt once, and requires `MESSAGE_SUBMITTED` before
+accepting the handoff. User questions appear in the native Codex UI.
+
+Codex ran readiness, inspected `greeting.py`, obtained native confirmation,
+and piped its plan to `wade plan-session done --from-stdin`. WADE wrote `PLAN.md`
+and rejected completion until review. Codex then ran `wade review plan`, read
+and performed the frozen review method, acknowledged it with
+`--ack-self-review`, and completed `done` while remaining in native Plan mode.
+The parent returned `PASS: received 1 completed, reviewed plan(s)` after normal
+Codex exit. Native session `01a0a7fa-90e6-7450-9a87-c0f12145da32` recorded Plan
+mode throughout and one task message (Codex trims its final newline). The
+completed receipt and exact plan content are checked again by the parent.
+No issues or PRs are created by this probe; the greeting remains unchanged.
+
+Published Crossby 0.33.0 wheel contracts: 374 passed, including the terminal PTY
+suite, approval combinations, and collector regressions. WADE startup tests
+reject absent, duplicate, mismatched, and out-of-order events. The older fake
+app-server E2E lane now explicitly selects its collector capability, so it does
+not claim to represent production Codex's new terminal path.
+
+WADE adoption checklist: 4,408 tests passed, with lint, formatting, and strict
+types passing. The live probe returned one completed reviewed plan after exit.

{wade_cli-1.2.4 → wade_cli-1.2.6}/docs/dev/testing.md

@@ -121,7 +121,9 @@ credentials, or binaries are missing.
 Use real public Crossby request/result models in consumer tests, not mocks that
 invent fields. `tests/e2e/test_plan_contract.py` uses a deterministic fake Codex
 app-server with the **published collector** and real WADE CLI/provider handoff;
-this is protocol-contract evidence, not genuine model inference.
+the fixture explicitly selects its collector capability now that production
+Codex prefers the terminal. This is protocol-contract evidence, not genuine
+model inference.
 
 For dependency adoption, also run the release's own focused native suites from
 a disposable checkout of its release tag. Install the published wheel in an
@@ -159,8 +161,11 @@ versions, completed live runs, and their limits.
 
 `test_interactive_plan_service.py` exercises explicit import, review receipts,
 self-review acknowledgement, revisions, safe file handling, and completion.
-`test_plan_service.py` runs the published adapter builders for all five native
+`test_plan_service.py` runs the published adapter builders for the five flag-based native
 terminals and asserts the Plan selector reaches the real launch boundary.
+`test_plan_startup_events.py` verifies Codex deferred prompt delivery and rejects
+missing, duplicate, mismatched, or out-of-order startup events. Crossby's nested
+PTY suite covers the terminal mechanics against the published wheel.
 The E2E plan contract also launches a fake OpenCode executable that invokes the
 real `wade plan-session done` command and persists through the fake provider.
 
@@ -171,6 +176,7 @@ uv run python scripts/probe_native_plan_handoff.py --tool claude
 uv run python scripts/probe_native_plan_handoff.py --tool cursor --model auto
 uv run python scripts/probe_native_plan_handoff.py --tool opencode
 uv run python scripts/probe_native_plan_handoff.py --tool antigravity-cli
+uv run python scripts/probe_native_plan_handoff.py --tool codex --sandbox --worktree --model gpt-5.6-sol
 ```
 
 The probe uses ordinary native approvals, real workflow/review commands, and no

{wade_cli-1.2.4 → wade_cli-1.2.6}/docs/dev/workflows-and-skills.md

@@ -73,7 +73,7 @@ WADE's canonical copies with `review plan`, and finishes the validated handoff
 before exit. Review receipts bind to exact content, the frozen bundle, and the
 current run. Prompt review requires actual self-review and `--ack-self-review`.
 Revisions require current receipts. The command loads the REVIEW method; WORK
-does not activate it directly. Tools without terminal Plan support (Codex) retain
+does not activate it directly. Tools without terminal Plan support retain
 native artifact collection and parent review, including explicit prompt-review
 acknowledgement. Both paths leave task persistence and implementation decisions
 to the parent. The legacy file-presence Stop hook remains uninstalled.
@@ -327,7 +327,7 @@ plans, including salvage paths. Managed native terminal sessions additionally
 require a completed `plan-session done` handoff and current content/binding review
 receipts. `review plan --ack-self-review` confirms a performed prompt-mode review;
 it cannot acknowledge changed content. Standalone plan review retains its ordinary
-behavior, and Codex collection retains parent-side review.
+behavior; the collector fallback retains parent-side review.
 
 ## Extension rules
 

{wade_cli-1.2.4 → wade_cli-1.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wade-cli"
-version = "1.2.4"
+version = "1.2.6"
 description = "WADE — Workflow for AI-Driven Engineering"
 readme = "README.md"
 license = "MIT"
@@ -24,7 +24,7 @@ classifiers = [
     "Topic :: Software Development :: Version Control :: Git",
 ]
 dependencies = [
-    "crossby>=0.32.1,<0.33.0",
+    "crossby>=0.36.0,<0.37.0",
     "typer>=0.12,<0.26",
     "pydantic>=2.0",
     "pydantic-settings>=2.0",

{wade_cli-1.2.4 → wade_cli-1.2.6}/scripts/probe_native_plan_handoff.py

@@ -30,9 +30,10 @@ def main() -> int:
     parser.add_argument(
         "--tool",
         required=True,
-        choices=["claude", "cursor", "opencode", "antigravity-cli", "copilot"],
+        choices=["claude", "cursor", "opencode", "antigravity-cli", "copilot", "codex"],
     )
     parser.add_argument("--model")
+    parser.add_argument("--sandbox", action="store_true", help="Enable the native runtime sandbox")
     parser.add_argument(
         "--worktree", action="store_true", help="Also exercise actual worktree bootstrap and hooks"
     )
@@ -76,7 +77,7 @@ def main() -> int:
             selected_ai_tool=args.tool,
             session_phase=SessionPhase.PLAN,
             session_kind=SessionKind.PLAN,
-            sandbox=False,
+            sandbox=args.sandbox,
         )
     else:
         compose_session(root, root, config, kind=SessionKind.PLAN, task_id=None)
@@ -93,7 +94,7 @@ def main() -> int:
                 prompt="Plan handoff probe",
                 working_dir=root,
                 model=args.model,
-                sandbox=False,
+                sandbox=args.sandbox,
             ),
             permission_mode=PermissionMode.DEFAULT,
             config=config,

{wade_cli-1.2.4 → wade_cli-1.2.6}/src/wade/__init__.py

@@ -1,3 +1,3 @@
 """WADE (Workflow for AI-Driven Engineering) — AI-agent-driven git workflow management CLI."""
 
-__version__ = "1.2.4"
+__version__ = "1.2.6"

{wade_cli-1.2.4 → wade_cli-1.2.6}/src/wade/services/plan_service.py

@@ -19,6 +19,9 @@ from pathlib import Path
 import structlog
 from crossby.ai_tools import (
     AbstractAITool,
+    InteractiveLaunchEvent,
+    InteractiveLaunchEventKind,
+    InteractiveSession,
     PlanSessionError,
     preflight_plan_session,
     terminal_interaction_handler,
@@ -399,11 +402,30 @@ def run_interactive_planning_session(
         request.working_dir, ("plans", "native"), ".wade-owned", ""
     ):
         raise ValueError("Cannot safely create the native plan directory")
+    deferred_input = adapter.capabilities().plan_mode.supports_ready_event
+    ready = False
+    submitted = False
+
+    def on_event(event: InteractiveLaunchEvent, session: InteractiveSession) -> None:
+        nonlocal ready, submitted
+        if event.tool_id != adapter.TOOL_ID:
+            raise ValueError("Planning startup event belongs to another AI tool")
+        if event.kind is InteractiveLaunchEventKind.PLAN_READY:
+            if ready:
+                raise ValueError("Planning CLI reported Plan readiness more than once")
+            ready = True
+            session.send_message(prompt)
+        elif event.kind is InteractiveLaunchEventKind.MESSAGE_SUBMITTED:
+            if not ready or submitted:
+                raise ValueError("Planning CLI reported task submission out of order")
+            submitted = True
+
     exit_code = adapter.launch(
         request.working_dir,
         model=request.model,
         effort=request.effort,
-        prompt=prompt,
+        prompt=None if deferred_input else prompt,
+        on_event=on_event if deferred_input else None,
         plan_mode=True,
         plan_output_dir=native_dir,
         transcript_path=transcript,
@@ -415,6 +437,8 @@ def run_interactive_planning_session(
     )
     if exit_code != 0:
         raise ValueError(f"Native planning CLI exited with code {exit_code}; output was retained")
+    if deferred_input and not submitted:
+        raise ValueError("Native Plan task submission was not confirmed; output was retained")
     bundle = interactive_plan.collect(request.working_dir)
     usage = adapter.parse_transcript(transcript) if transcript.is_file() else None
     return bundle, usage

{wade_cli-1.2.4 → wade_cli-1.2.6}/templates/workflows/plan.md

@@ -16,7 +16,7 @@ Review methodology (loaded only by the bounded review step):
 
 An interactive terminal session has `.wade/plans/interactive-session.json`.
 It keeps questions, review feedback, and revisions inside the native CLI.
-A session without that file uses native collection and parent review (Codex).
+A session without that file uses native collection and parent review.
 
 ## Required steps
 

{wade_cli-1.2.4 → wade_cli-1.2.6}/tests/e2e/test_plan_contract.py

@@ -79,6 +79,24 @@ for line in sys.stdin:
         encoding="utf-8",
     )
     codex_script.chmod(0o755)
+    # Keep the collector lane explicit now that production Codex prefers its TUI.
+    # Only capability selection is overridden; real CLI, collector, and provider run.
+    collector_wade = mock_bin / "wade"
+    collector_wade.write_text(
+        """#!/usr/bin/env python3
+from crossby.ai_tools.codex import CodexAdapter
+from crossby.models.ai import PlanModeActivation
+from wade.cli.main import cli_main
+original = CodexAdapter.capabilities
+def collected_capabilities(self):
+    caps = original(self)
+    return caps.model_copy(update={"plan_mode": caps.plan_mode.model_copy(
+        update={"activation": PlanModeActivation.UNSUPPORTED})})
+CodexAdapter.capabilities = collected_capabilities
+cli_main()
+"""
+    )
+    collector_wade.chmod(0o755)
 
 
 def _disable_plan_review(repo: Path) -> None:

{wade_cli-1.2.4 → wade_cli-1.2.6}/tests/unit/test_services/test_plan_service.py

@@ -368,7 +368,20 @@ def collected_harness(
         Task(id=str(number), title="feat: native test plan") for number in range(1, 10)
     ]
     provider.read_task.return_value = Task(id="330", title="feat: existing", body="Original body")
+    # Exercise the retained collector path independently of Codex's new TUI capability.
+    from crossby.ai_tools.codex import CodexAdapter
+    from crossby.models.ai import PlanModeActivation
+
+    collected_caps = CodexAdapter().capabilities()
+    collected_caps = collected_caps.model_copy(
+        update={
+            "plan_mode": collected_caps.plan_mode.model_copy(
+                update={"activation": PlanModeActivation.UNSUPPORTED}
+            )
+        }
+    )
     with (
+        patch.object(CodexAdapter, "capabilities", return_value=collected_caps),
         patch("wade.services.plan_service.load_config", return_value=config),
         patch("wade.services.review_delegation_service.load_config", return_value=config),
         patch("wade.services.plan_service.get_provider", return_value=provider),

wade_cli-1.2.6/tests/unit/test_services/test_plan_startup_events.py

@@ -0,0 +1,82 @@
+"""WADE owns task delivery through Crossby's public terminal startup events."""
+
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from crossby.ai_tools import InteractiveLaunchEvent, InteractiveLaunchEventKind, InteractiveSession
+from crossby.models.ai import AIToolID, PlanSessionRequest
+
+from wade.models.config import AICommandConfig, AIConfig, ProjectConfig
+from wade.models.permission import PermissionMode
+from wade.models.workflow import SessionKind
+from wade.services import interactive_plan_service as handoff
+from wade.services.plan_service import run_interactive_planning_session
+from wade.services.session_composition_service import compose_session
+
+
+@pytest.mark.parametrize(
+    "events",
+    [
+        ["plan_ready", "message_submitted"],
+        [],
+        ["plan_ready"],
+        ["message_submitted"],
+        ["plan_ready", "plan_ready"],
+        ["plan_ready", "message_submitted", "message_submitted"],
+        ["wrong_tool"],
+    ],
+)
+def test_codex_deferred_delivery_and_completion_gate(tmp_path: Path, events: list[str]) -> None:
+    config = ProjectConfig(ai=AIConfig(review_plan=AICommandConfig(enabled=False)))
+    compose_session(tmp_path, tmp_path, config, kind=SessionKind.PLAN, task_id=None)
+    port = MagicMock(spec=InteractiveSession)
+
+    def native_run(command, working_dir, **kwargs):
+        assert working_dir == tmp_path
+        assert command[0] == "codex"
+        assert "app-server" not in command
+        assert "/plan" not in command
+        assert kwargs["prompt"] is None
+        assert callable(kwargs["on_event"])
+        for kind in events:
+            kwargs["on_event"](
+                InteractiveLaunchEvent(
+                    kind=InteractiveLaunchEventKind.PLAN_READY
+                    if kind == "wrong_tool"
+                    else InteractiveLaunchEventKind(kind),
+                    tool_id=AIToolID.CLAUDE if kind == "wrong_tool" else AIToolID.CODEX,
+                ),
+                port,
+            )
+        handoff.import_artifact(tmp_path, "# fix: native Codex plan\n\n## Complexity\neasy\n")
+        handoff.complete(tmp_path)
+        return 0
+
+    with (
+        patch("crossby.utils.versioning.detect_binary_version", return_value=(0, 154, 0)),
+        patch("crossby.ai_tools.codex_terminal.run_terminal_plan", side_effect=native_run),
+    ):
+        arguments = dict(
+            request=PlanSessionRequest(prompt="preflight", working_dir=tmp_path),
+            permission_mode=PermissionMode.DEFAULT,
+            config=config,
+            issue_context="# Task\nPlan the greeting change.",
+            session_bundle=str(tmp_path / ".wade/session"),
+            source_root=str(tmp_path),
+        )
+        if events == ["plan_ready", "message_submitted"]:
+            bundle, _ = run_interactive_planning_session(
+                "codex", str(tmp_path / ".wade/plans"), **arguments
+            )
+            assert len(bundle.plans) == 1
+            port.send_message.assert_called_once()
+            prompt = port.send_message.call_args.args[0]
+            assert prompt == (tmp_path / ".wade/plans/prompt.txt").read_text()
+            assert "WORKFLOW.md" in prompt and not prompt.startswith("/plan")
+        else:
+            with pytest.raises(ValueError):
+                run_interactive_planning_session(
+                    "codex", str(tmp_path / ".wade/plans"), **arguments
+                )
+            assert port.send_message.call_count <= 1

{wade_cli-1.2.4 → wade_cli-1.2.6}/tests/unit/test_skills/test_crossby_contract.py

@@ -30,7 +30,7 @@ def _skill(root: Path, relative: str, name: str) -> Path:
 
 
 def test_crossby_version_and_skill_root_mapping_contract() -> None:
-    assert version("crossby") == "0.32.1"
+    assert version("crossby") == "0.36.0"
     assert SKILLS_DIR == {
         AIToolID.CLAUDE: ".claude/skills",
         AIToolID.CURSOR: ".cursor/skills",
@@ -115,3 +115,19 @@ def test_crossby_list_skills_is_sorted_and_requires_skill_markdown(
     (tmp_path / ".claude/skills/not-a-skill").mkdir()
 
     assert list_skills(tmp_path / ".claude/skills") == ["alpha", "zeta"]
+
+
+def test_interactive_plan_startup_events_contract() -> None:
+    from crossby.ai_tools import InteractiveLaunchEvent, InteractiveLaunchEventKind
+    from crossby.models.ai import PlanModeActivation
+
+    caps = AbstractAITool.get("codex").capabilities()
+    assert caps.supports_plan_mode
+    assert caps.plan_mode.activation is PlanModeActivation.TERMINAL_INPUT
+    assert caps.plan_mode.supports_ready_event
+    assert caps.plan_mode.collector_verified_version == "0.153.4"
+    assert set(InteractiveLaunchEvent.model_fields) == {"kind", "tool_id"}
+    assert {kind.value for kind in InteractiveLaunchEventKind} == {
+        "plan_ready",
+        "message_submitted",
+    }