v1.50.0

• Add the claude:opus-4.8 selection, valid for every role and every command's Claude path: each
  pair agent gains a twin definition (stereo:<role>-opus-4-8) whose frontmatter pins
  claude-opus-4-8 over the same body and tools, because the Agent tool's model parameter accepts
  only the four aliases and claude:opus resolves to the harness's current Opus generation
• Make claude:opus-4.8 the built-in implementer for /stereo:implement and /stereo:quick and
  the tournament's Claude contestant; claude:inherit and the base agents are unchanged
• Correct the routing skill's account of model inheritance to the harness's current resolution
  order: the agent definition decides before CLAUDE_CODE_SUBAGENT_MODEL

v1.49.0

• Route the Codex implementer seats to codex:astra: the tournament's Codex contestant fallback
  and the command-heavy implementer switch in /stereo:implement and /stereo:quick now name
  Astra, so a Codex-routed implementer resumes the plan-review thread it approved
• Accept ultra as a reasoning effort across the model registry, every command's effort flags,
  the CLI usage text, and the runtime skill; it is the tier above max on the models that
  advertise it, and the pair-role defaults stay max

v1.48.0

• Add codex:astra (GPT-6 Astra, gpt-6-astra) to the Codex model aliases with the max
  pair-role effort default, and make it the built-in plan reviewer and implementation reviewer
  for /stereo:plan, /stereo:implement, and /stereo:quick, replacing codex:sol in both
  review gates; the same-model reviewer substitution and the CLI-level plan-review default follow
• Document that claude:fable resolves to the harness's current Fable generation (Fable 5.1) and
  claude:opus to Opus 5, and that a specific generation cannot be pinned per role
• Require Codex CLI 0.153.1 or later for the default review gates, with a workspace-default
  fallback for older CLIs

v1.47.0

• Record reviewer attribution on auto-stored Codex plan reviews: every successfully parsed
  round now stores a reviewedBy label in the same codex:<model> form the explicit
  plan-store --reviewed-by flag uses, so the implement and tournament preflights can name the
  approving reviewer, outside-thread implementer preambles keep their attribution, and a
  re-review replaces a stale label instead of silently dropping it

v1.46.0

• Let the planner refuse honestly: when a task exceeds the size contract, the draft step returns
  a single SPLIT REQUIRED: <reason> line that /stereo:plan and /stereo:quick recognize
  before heading validation — a compliant refusal is relayed as a split proposal instead of
  being retried into an oversized plan
• Cut repeated review-round cost: resumed Codex plan-review rounds send a compact round message
  on the warm thread instead of re-paying the full review brief every round, the
  implementation-review brief fences its untrusted blocks once instead of three times, and the
  stop-gate brief is deduplicated with every verdict shorthand matching the parser's
  ALLOW:/BLOCK: format, closing a fail-closed trap on compliant verdicts
• Finish the metadata-only output work: plan-state --mark-implemented --json returns metadata
  like plan-store, the reads that only need review metadata (the plan overwrite guard, Quick's
  existing-plan warning, the --clear confirmation) use plan-state --metadata, and foreground
  --json payloads drop the overflow counters alongside their capture arrays
• Harden the remaining runtime edges: the POSIX shutdown escalation follows an undeliverable
  process-group kill with SIGKILL and repeated close() calls can no longer wedge, the CLI
  resets its JSON-output decision per invocation, and plan-review honors --workspace for
  durable state and broker keying
• Correct instruction drift: review templates name every schema-required finding field and never
  place instructions inside distrust-fenced blocks, tournament's usage recording matches the
  --report payload shape, status presentation matches the one-line recent-jobs format, and the
  CI workflow keys its Codex CLI cache and installs from a single version value

v1.45.0

• Slim every machine-facing output down to the answer: result --json and foreground --json
  payloads carry one copy of the final message instead of three or four, plan-store and
  plan-state --mark-implemented return metadata instead of echoing the stored plan back, a new
  plan-state --metadata mode lets /stereo:plan-state open without shipping the plan body,
  JSON output is compact, long foreground runs sample their progress echoes, and status reports
  print static job metadata once with finished jobs collapsed to one line each
• Make every companion invocation faster: workspace resolution is cached per process (a status
  wait now spawns one git subprocess where it spawned hundreds), subcommand handlers load
  lazily, and a live workspace broker vouches for Codex availability so trivial commands skip
  the probe spawns
• Harden the runtime edges: a write racing app-server death no longer crashes the worker,
  shutdown escalates when Codex ignores SIGTERM, a broker-busy rejection after thread start
  falls back to a private app-server so concurrent sessions never hard-fail, the
  connection-closed error is reported consistently on the broker transport, value flags reject a
  following flag token instead of silently swallowing it, cancel reports a failed worker kill,
  and implement-state/tournament-state updates re-validate what --record enforced
• Trim duplicated instruction text across the rescue stack and pair commands, and speed the
  development loop: the Windows CI lane sheds duplicate OS-independent steps, superseded PR runs
  cancel, the pinned Codex CLI install is cached, and the test suite drops from roughly 58 to 44
  seconds

v1.44.0

• Give the Claude implementer a shell scoped to building and testing, with tool parity across
  ecosystems: it builds the repository, runs the unit tests and static checks that exercise its
  changes, and fixes the failures its changes introduced inside its own turn — failures it cannot
  attribute to its edits are reported as suspected pre-existing instead of fixed — and its report
  carries a new Verification section listing every command with its exit status. Later fix
  turns continue the same agent with just the numbered findings instead of a full re-brief
• Stage orchestrator verification and make it route-dependent: build and unit results an
  implementer produced on the host are trusted without a redundant re-run (only the cheap static
  checks repeat before review), sandbox results stay advisory and get the complete fast battery,
  and a repository-declared heavy stage (integration, end-to-end, real runs) executes strictly
  after an accepted implementation review, never re-running unit tests
• Attribute red gates instead of blindly fixing them: a risk-matched baseline snapshot (static
  checks always, the unit suite only over a dirty baseline, taken inside the worktree for
  isolated runs) classifies each failure; a bounded gate-fix pre-loop repairs newly-introduced
  reds before review, pre-existing and unattributable reds route to reviewer diagnosis, and
  fix-turn accounting is durable across resumed sessions, including orphan-job detection and
  explicit lifecycle states for every isolated hand-back outcome
• Provision isolated worktrees symlink-first so their gates run natively, with main-toolchain
  fallback recipes and per-gate provenance (native, main toolchain, or not run) when provisioning
  is impossible
• Extend tournament contestants with the same shell-capable, worktree-targeted conduct and
  provisioning, label their self-reported checks distinctly from orchestrator gates, and review
  contestants concurrently under a Codex-routed reviewer
• Add common runner families (npx, pnpm, yarn, dotnet, cargo, go, make, python3, pytest, mvn,
  gradle) to the implementation commands' allowed tools, and trim Quick's inline scope gate to a
  size check so the routed planner no longer duplicates its exploration

v1.43.0

• Compare two stored plan slots: plan-state --compare <slotA> <slotB> (surfaced through
  /stereo:plan-state) renders both slots' review metadata side by side plus a unified line diff
  of the stored plan texts from a new dependency-free capped LCS — per-side preflights (2000
  effective lines, one million UTF-16 code units) run before any allocation-scale work, an empty
  side normalizes to zero lines, and the hunk format is pinned byte-exactly by tests. The JSON
  payload is metadata-only; each full plan stays reachable per slot via --json --slot or
  --open
• Complete the alternating-vendor defaults at the build seats: claude:opus implements in the
  contained file-edit agent and codex:sol gates the diff, so every handoff crosses ecosystems —
  Claude plans and builds, Codex challenges the plan and gates the diff
• Make the implementer resolution honest under any model mix: stored-plan and plan-review payload
  models never resolve the implementer (explicit flag > workspace default > built-in), a Codex
  implementer resumes the stored review thread only when it is the model that produced it, a
  same-model implementer/reviewer pairing from the built-in default substitutes the other
  ecosystem's review gate (explicit or workspace-configured self-review is honored but called
  out), and --fresh is reported as inert for a Claude-routed implementer

v1.42.0

• Flip the built-in role defaults to alternate vendors at every handoff: claude:fable drafts
  the plan, codex:sol reviews it, codex:sol implements on the stored review thread, and
  claude:fable gates the diff — for /stereo:plan, /stereo:implement, and /stereo:quick
  alike (quick's scope gate stays inline)
• The default plan review now stores each parsed round durably with a resumable plan-review
  thread, so implementation resumes the approval context instead of starting fresh; one flag
  (--plan-reviewer claude:fable) restores the faster all-Claude plan loop
• Update every consequence claim to the new mechanics — budget split, thread resumption, escape
  hatches, the strategy rationale, the marketing site's step cards, schematic, configurator, and
  model matrix — and drop effort annotations on defaults wherever the effort is just the model's
  pair default

v1.41.0

• Bring /stereo:quick to flag parity with the phase commands: --slot <name> targets a named
  durable plan slot with <slotArg> threaded onto all five slot-scoped companion invocations —
  including Quick's two plan-review launches, which store each parsed round durably and would
  otherwise overwrite the default slot under a Codex plan reviewer while the warning named the
  selected slot — with the existing-plan notice retargeted to the selected slot and deliberately
  kept warn-only
• Make both pause points configurable: --max-plan-rounds <n> (default 2, rejected above Quick's
  fixed absolute safeguard of 6) and --max-fix-rounds <n> (default 2), with cap-relative pause
  and keep-iterating wording in the command and README
• Add --isolated: implementation, implementation review, and fixes run in a throwaway detached
  worktree via the same machinery as /stereo:implement --isolated, minus durable state — Quick
  keeps no implementation record, so the worktree path is printed at creation and
  /stereo:doctor's stranded-worktree listing is the crash mitigation; the plan draft and plan
  review always run against the main tree, and the implemented marker is set only after an
  applied or empty patch
• Pin the new wiring structurally: the four flags in the argument hint, the <slotArg> idiom,
  both plan-review launch lines, and all four <isolationArgs> launch lines