0.12.0

cdx now exposes a session-scoped home view, compact task summaries, exact task names, contextual help and TOON output. JSON remains available for scripts and streaming monitors. The skill focuses on delegation and verification, with monitoring and recovery details disclosed separately.

• Fast -v, -V, and --version probes load only a small launcher and version module.
• list --full, status --full, and list --fields expose additional details on demand.
• Task-name typos suggest candidates without redirecting actions.
• Prompt and backend validation precede interruption or task creation.

Migration from 0.11: successful reads exit 0 regardless of worker state. Read state to distinguish working, awaiting_reply, done, failed, stalled or killed. CLI failures exit 1 and usage errors exit 2; errors are structured on stdout. Default list/status schemas are smaller and default output is TOON instead of free text.

Existing skill installations require updating the complete skill directory, including the new Python modules. Session hook installation is outside this release.

Validation: 71 offline tests passed locally and CI passed on Ubuntu and macOS. Four paid provider smoke tests were intentionally skipped. 202 data cases round-tripped through the official TOON 4.1.1 decoder.

0.11.0

Add user-directed Astra and Fable 5.1 aliases. Both translate medium/high/max to low/medium/high, with routing centralized in code and compact skill instructions. Existing tasks retain stored execution settings.

Validation: 21 CI-suite tests passed locally, including alias resolution and spawn/resume effort mapping.

0.10.0

Parser-Fix: alle dokumentierten Aufrufformen parsen auf jedem unterstützten Python (3.10+). argparse älterer Interpreter (gesehen auf 3.12.4) verwarf Optionen zwischen zwei Positionals; normalize_global_args hoistet jetzt alle Optionen vor die Positionals. Breaking: Options-Abkürzungen (--stall für --stall-after) werden abgelehnt. doctor meldet Python-Version samt Parse-Probe. Details im CHANGELOG.

v0.9.0 (2026-08-14)

• Pin grok to a concrete model instead of riding the provider's rolling default. codex has always resolved sol/terra to a pinned id; grok was the one backend where cdx sent no -m at all and let the CLI pick, so a provider-side default flip could change what runs between two spawns of the same fleet, and result reported model: null — the task never recorded what it actually ran on. --effort/--model overrides are unaffected: an explicit --model still wins.
• Raise grok's effort ceiling from high to xhigh, so --effort max means the same everywhere. The old cap dated from grok's --reasoning-effort accepting any string unvalidated; it now validates against low|medium|high|xhigh and rejects the rest with an error event. Verified against codex-cli 0.147.0, claude 2.1.232 and grok 1.0.3: all three CLIs keep the flags, event shapes and resume paths cdx depends on, and both codex and claude have since gained a max tier above xhigh — deliberately left outside cdx's surface, because it costs a lot for little gain.

v0.8.0 (2026-08-03)

• wait --timeout defaults to 540s, not 600s. Claude Code caps a single Bash call at 600s, so the previous default raced its own tool call and would have been killed just before returning — measured against real harness ceilings after Codex reported a 30s initial yield and a 300s continuation-poll cap in its own shell interface (confirmed independently in an interactive Codex session and in a headless codex exec worker). Both facts are now in SKILL.md: an empty return with the session still alive is not a result, keep polling the same session, and never start a second wait.
• Cut the event payloads down to the delta. Every event carried backend, repo, model, effort, owner — all chosen by the caller at spawn and keyed by the task name it is already holding — and wait re-sent the entire fleet on every return. Roughly half of every row, and ~80% of a wait return, was context the reader already had. Events now carry task, state, age_s, plus last_activity only where it is the thing that makes the event judgeable (dropped on done, where it is a constant, and next to an escalated question, where the question says more). armed is a name→state map, heartbeat and a wait timeout are one string per task (api-tests working 14m quiet 5m) instead of full rows, and wait returns the fleet only on idle, where "nothing is running" is the cue to go collect. Measured on a three-task fleet: change 59→22 tokens, armed 197→40, heartbeat 235→31, wait return 341→50. Full detail stays one status/list call away.
• Derive the owner from CLAUDE_CODE_SESSION_ID as well, so the export CDX_OWNER=… that had to be repeated in every Bash call disappears on both supported harnesses — with it goes the failure mode where forgetting it once silently splits a session's fleet in two. SKILL.md's setup block drops to three lines and its owner paragraph from five sentences to two.
• Make the stall watchdog report instead of kill. It was the one timeout in the system that actually aborted a worker: 5 minutes without byte growth meant SIGINT/SIGKILL, state stalled, and a send "continue" to get going again. It cannot distinguish a hung worker from one sitting inside an eight-minute test run, so it killed real work — and its original justification, that a hang would otherwise sit unnoticed forever, is exactly what watch/wait now solve better. --stall-after (still 300s) now raises a stall_suspect flag on the still-working, still-untouched task; watch/wait emit a stall_suspect event immediately (and a recovered one if output returns), list sorts flagged tasks above quietly-progressing ones, and status reports quiet_for_s. The hard kill moves to its own --hard-kill-after (default 3600, 0 disables it), which still produces the stalled state and stays resumable exactly as before. A flag is deliberately not a new state, so the send/clean/kill guards keep working unchanged.
• The supervisor patches meta mid-turn instead of writing back its in-memory copy (patch_meta re-reads, merges, then writes non-creatingly). It holds meta for the length of a turn while the CLI writes to the same file, so its old blind write could silently undo a concurrent kill or send — a narrow race before, but the watchdog now writes mid-turn on every flag change.
• The supervisor's stall sampling interval adapts to the threshold (min(30s, threshold)), so a short threshold is no longer detected up to a full 30s interval late. Production thresholds are unaffected.
• Add cdx wait: the pull twin of watch for harnesses that cannot turn a background process's stdout into a new turn. One finite, owner-scoped, blocking call that returns on the first fleet change, on its --timeout (default 600), or immediately when nothing is running — reason says which. It always exits 0, never touches a worker, and carries the whole fleet plus the events that ended the wait, so the caller acts on the payload and calls it again with no follow-up list. watch assumed a push path that only some harnesses have (Codex, for one, cannot restart a finished turn from stdout), and documenting it as the general workflow was wrong.
• Derive the task owner from a harness session id (CODEX_THREAD_ID, namespaced as codex:<id>) when CDX_OWNER is not set, before falling back to the cwd. The cwd fallback is the one that silently splits a fleet between two chats in one checkout, and it was reachable by forgetting a single export in a single Bash call.
• Add cdx watch: a long-lived, owner-scoped event stream that replaces the wait-and-re-arm dance as the way an orchestrator learns what its tasks are doing. It emits one line per task leaving working (with an escalated QUESTION: inlined), a heartbeat line every 10 minutes while anything is still working, and a line for its own poll failures — silence from it only ever means "nothing happened", never "the watcher died". It is armed once per session (Claude Code: Monitor with persistent: true; any other harness runs it as a background process and reads the same stdout) and never re-armed: the orchestrator is woken by the line, not by the process exiting. The heartbeat stops while nothing is working, so an idle session stays quiet, and it carries every uncollected result, so a lost change event still resurfaces within ten minutes.
• Split liveness from collection. 0.7.0 gave result --wait a 600s bound so a lost completion notification couldn't strand the session, but that made a planned check-in look like a failure: it raised exit 6 with error: on stderr and — despite --json — nothing on stdout, next to a state table where "timeout" means stalled → send "continue". Orchestrators read it as "the subagent aborted, resume it". Session liveness is now watch's job alone, so result --wait goes back to a plain upper bound (--timeout default 600 → 3600) and its expiry returns exit 10, "still working", with a real JSON payload (reason: timeout, waited_s) and the task untouched. Exit code 6 is no longer emitted by anything.
• result on a working task without --wait also emits its JSON payload now (reason: no_wait) instead of printing nothing to stdout and a bare line to stderr, closing the same --json contract hole.
• Stamp killed before signalling the process in cdx kill, not after. derive_state treats killed as sticky, so the old order left a window where a concurrent reader saw a dead process against still-working meta and derived — or persisted — a spurious failed. Harmless while readers only ran on demand; watch polls on a timer and lands in that window regularly.
• --json output flushes per line, so a consumer reading watch through a pipe gets each event immediately instead of when an 8K block fills.
• list (and watch) skip a task directory whose meta.json has already been removed, instead of deriving a phantom state from empty meta and reporting a cleaned task as a fresh failure.

v0.7.0 — owner-scoped list, bounded result --wait

0.7.0 (2026-08-03)

• Make list owner-scoped like clean: by default it shows only the current session's tasks, so a check-in in one chat no longer pulls a parallel chat's fleet into context on every look. Foreign tasks surface as a skipped_foreign count; list --any-owner is the deliberate machine-wide view and list -C <repo> additionally shows that repo's tasks across owners (same escape hatches as clean). Breaking: list --json now emits {"tasks": [...], "skipped_foreign": N} instead of a bare array, so the scoping is visible in-band.
• Make CDX_OWNER doctrine instead of a footnote: the SKILL.md setup block now mints a stable per-chat slug unconditionally. The cwd fallback isolates separate worktrees but silently collides when two chats sit in the same checkout — in that case clean --terminal in one chat could reap the other chat's uncollected results, and list mixed both fleets.
• Bound the collect wait: result --wait drops its default --timeout from 3600 to 600 seconds, and SKILL.md step 4 makes the background result --wait + exit-6-as-check-in the doctrine for long tasks. A lost completion notification previously meant up to an hour of silent staleness; now the wait resolves within 10 minutes no matter what, and exit 6 explicitly routes into list + re-arm instead of reading as a failure. Escalated questions still return immediately; the timeout only affects the still-working case.

To update an installed copy: ask your agent to update the cxcc-subagent skill (it follows references/update.md), or git pull in a source checkout.

v0.6.2 (2026-07-18)

0.6.2 (2026-07-18)

• End duplicated proof runs in the delegation loop: collection (step 4) now credits the worker's attached proof output instead of re-running the proof command — the diff read stays mandatory, and a targeted re-run happens only on a named suspicion trigger (output missing or vague, inconsistent with the diff, a failed spot-check). Previously worker and orchestrator each ran the same proof, doubling test time per task; on multi-task plans this stacked to hours.
• Scope the proof itself: the work-order contract (step 1) now asks for a proof scoped to the worker's touched area, and the general role's fallback ("the project's standard checks") is replaced by checks scoped to what the worker touched — the one full-suite run is the caller's own final gate after all tasks merge, never a per-worker proof.
• Close the false-green residue with a subsumption note: at collection, record whether the credited proof is covered by that final gate; non-subsumed proofs (manual checks, benchmarks, external-integration tests) are re-run exactly once there.

v0.6.1 (2026-07-15)

0.6.1 (2026-07-15)

• Add clean -C/--repo <path>: a targeted reap of a repo's terminal tasks regardless of the cwd they were spawned from. The owner fallback is the spawning cwd, so a task spawned with -C /repo from another directory is owned by that directory and a later clean from /repo would treat it as foreign and leave it behind. clean -C /repo reaps it (still terminal-only, still leaves running tasks alone) without the blunt clean --any-owner. The skipped-foreign hint now points at both -C and --any-owner.

v0.6.0 (2026-07-14)

0.6.0 (2026-07-14)

• Make clean owner-scoped so parallel sessions stop clobbering each other. The task registry (~/.codex-agents/tasks) is shared by every session on the machine, and clean --terminal/--all used to sweep it globally, deleting a sibling session's finished-but-uncollected results (and, with --all, its still-running tasks). This is backend-agnostic: codex, claude, and grok tasks all shared the one registry and the one sweep.
• Each task now records an owner at spawn (CDX_OWNER if set, else the resolved cwd, so separate worktrees isolate with zero config). clean --terminal/--all only remove tasks owned by the current session; owner is surfaced in status/list, and the JSON reports a skipped_foreign count.
• Add clean --any-owner to restore the global sweep as a deliberate opt-in (also the only way to reap pre-owner legacy tasks). kill/clean --task were already correctly single-target and are unchanged.
• clean now refuses to remove a still-running (or still-starting) task: clean --task on one errors with "kill it first", and --terminal/--all skip it (reported as skipped_running). Interrupting-then-deleting a live task raced the detached supervisor, which could resurrect the directory as a partial failed entry or orphan the backend, so clean only ever reaps terminal tasks now, the same rule send follows. Kill a task first (cdx kill) if you want it gone.
• Harden the detached supervisor against resurrecting a cleaned task: it finalizes state through a new non-creating write, so if clean removed the directory in the meantime the write fails cleanly instead of re-creating a stale task. Read paths (status/list/result) that opportunistically persist derived state no longer resurrect a cleaned task either. clean re-checks each task is still terminal immediately before removing it, retries the removal when the supervisor's one-shot finalize write races the rmtree (so the directory is never left half-removed), reports that rare still-finalizing case as skipped_finalizing with "re-run clean" guidance rather than mislabeling it as a running task, and surfaces a genuine rmtree failure (permissions, I/O) instead of swallowing it.
• SKILL.md: replace the blanket "clean --terminal once results are harvested" housekeeping advice with the owner-scoping contract and the CDX_OWNER override.

v0.5.0 (2026-07-11)

0.5.0 (2026-07-11)

• Rework the two-axis review: the "Standards" axis becomes Correctness & Quality (roles/review-correctness.md), which hunts behavioral bugs first, then repo conventions and the Fowler smell baseline. Both axes adopt P0–P3 severity (with anti-inflation calibration keyed to "would this block the merge?"), a mandatory residual-risk close, and judgment-first framing so the smell baseline stays a floor, not a nitpick checklist.
• Simplify the FINDINGS: line on both review axes to a plain completion sentinel (FINDINGS: <n> / none): it proves a detached run finished, it is not a count to parse — the orchestrator's adjudication reads the findings themselves.
• Lower the review effort default from max to high.
• SKILL.md accuracy pass, found by the new reviewer and verified against cdx.py: document the kill <task> verb; note that exit 12 (stalled) comes only from status/peek while result collapses stalled into 13; scope model-alias pinning to codex (claude/grok forward the alias to the provider CLI); flag that a grok task stalled or interrupted on its first turn has no resumable session; correct "reaps true hangs" to the inactivity timeout it actually is.