@mmerterden/multi-agent-pipeline 20.24.0 → 20.25.1

package/pipeline/commands/multi-agent/setup/SKILL.md

@@ -429,14 +429,16 @@ To set up multi-agent on a new machine:
 
 All tokens are optional in the sense that every service can be answered with Skip  -  but the ASKING is not optional: the Step 3 sequential loop still walks every missing service one by one (token → author → host). Phase 0 re-asks at runtime only for tokens the user skipped here.
 
-### Step 8  -  Enforcement hooks (optional, Claude Code)
+### Step 8  -  Enforcement hooks (optional)
 
-Offer to merge `$HOME/.claude/templates/claude-hooks.json`: three `PreToolUse` gates that block on a non-zero exit (secret scan, agent-guard, read-size) plus four hooks that block nothing (`PreCompact`, `SessionEnd`, `SessionStart`, `PostToolUse`). What each does: `$HOME/.claude/multi-agent-refs/picker-contract.md`.
+On Claude Code, offer to merge `$HOME/.claude/templates/claude-hooks.json`: three blocking `PreToolUse` gates (secret scan, agent-guard, read-size) plus four non-blocking hooks (`PreCompact`, `SessionEnd`, `SessionStart`, `PostToolUse`). What each does: `$HOME/.claude/multi-agent-refs/picker-contract.md`.
 
 - Ask (picker): "Install the pipeline's hooks into `~/.claude/settings.json`?" Default Yes.
-- On Yes, deep-merge EVERY event in the template's `hooks` object, not `PreToolUse` alone - merging one event silently drops the capture hooks, and a run killed before Phase 5 then loses its findings exactly as it did before they existed. Preserve existing hooks; never duplicate a matcher already calling the same script.
-- Say what the merge does NOT cover: only the three gates need no run-specific arguments, so only they are hookable; the rest are phase-enforced.
-- Say what it does not turn on: the read-size gate is inert until `prefs.global.bulkRead.mode` is set. Recommend `observe` first. Why, and the Phase 3 exemption: `$HOME/.claude/multi-agent-refs/picker-contract.md`.
+- On Yes, deep-merge EVERY event in the template's `hooks` object (merging `PreToolUse` alone drops the capture hooks); keep existing hooks, never duplicate a matcher calling the same script.
+- Say only the three gates are hookable (no run-specific arguments); the rest are phase-enforced.
+- Say the read-size gate stays inert until `prefs.global.bulkRead.mode` is set; recommend `observe` first (why, and the Phase 3 exemption: `picker-contract.md`).
+
+Codex: offer only the syntax gate, then run `node "$HOME/.codex/scripts/host-hooks.mjs" install --host codex`. Copilot CLI: offer no hook (it discards `postToolUse` output as of 1.0.45).
 
 ### Step 9  -  Default stack plugin enablement
 

package/pipeline/commands/multi-agent/testflight-validation/SKILL.md

@@ -11,10 +11,9 @@ allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdat
 
 # /multi-agent:testflight-validation  -  iOS alias for store-ready
 
-This command is an alias. The implementation it used to carry was merged into
+This command is an alias. The implementation lives in
 `/multi-agent:store-ready`, which runs the same three gates on iOS and adds the
-Android side, so there is one flow to maintain instead of two that had already
-started to drift.
+Android side, so there is one flow to maintain instead of two that drift.
 
 The name is kept because it is the one people reach for when the target is
 TestFlight, and removing a command is a breaking change to the slash-command

package/pipeline/contract/fixtures/runs-failed.json

@@ -85,7 +85,7 @@
         "out": 1020,
         "cached": 2700
       },
-      "estUsd": 0.0449,
+      "estUsd": 0.0353,
       "unlockedWrites": 0,
       "runType": "development",
       "title": null,

package/pipeline/contract/fixtures/runs-old-schema.json

@@ -63,7 +63,7 @@
         "out": 680,
         "cached": 1800
       },
-      "estUsd": 0.0299,
+      "estUsd": 0.0236,
       "unlockedWrites": 0
     }
   ]

package/pipeline/contract/fixtures/runs-pr-opened-redacted.json

@@ -106,7 +106,7 @@
         "out": 2040,
         "cached": 5400
       },
-      "estUsd": 0.0897,
+      "estUsd": 0.0707,
       "unlockedWrites": 0,
       "runType": "development",
       "title": null,

package/pipeline/contract/fixtures/runs-pr-opened.json

@@ -111,7 +111,7 @@
         "out": 2040,
         "cached": 5400
       },
-      "estUsd": 0.0897,
+      "estUsd": 0.0707,
       "unlockedWrites": 0,
       "runType": "development",
       "title": null,

package/pipeline/contract/fixtures/runs-running.json

@@ -96,7 +96,7 @@
         "out": 680,
         "cached": 1800
       },
-      "estUsd": 0.0299,
+      "estUsd": 0.0236,
       "unlockedWrites": 0,
       "runType": "autopilot",
       "title": "Fix the crash on the login screen",

package/pipeline/lib/credential-inventory.sh

@@ -3,11 +3,11 @@
 #
 # WHY THIS EXISTS
 #
-# A run asked the user to paste a Crashlytics stack trace by hand while a Firebase
-# service-account JSON sat in the Keychain, mapped as `firebase`, fully valid. Nothing
-# was broken - the pipeline simply never asked itself "do I already hold a credential
-# that answers this?" before asking the user. From the user's side that is worse than a
-# failure: they had supplied the key precisely so this would not happen.
+# A run that asks the user to paste a Crashlytics stack trace by hand while a valid
+# Firebase service-account JSON sits in the Keychain, mapped as `firebase`, has failed
+# even though nothing is broken. From the user's side that is worse than a failure: they
+# supplied the key precisely so this would not happen. So the pipeline asks itself "do I
+# already hold a credential that answers this?" before it asks the user.
 #
 # One command, so there is no excuse for asking blind. Run it before any question that
 # requests data an external system holds, and let the answer shape the question:

package/pipeline/lib/fetch-crashlytics.sh

@@ -214,15 +214,13 @@ if [ -z "$SA_JSON_RAW" ]; then
 fi
 
 # The credential store returns the JSON as stored - encoding is its internal
-# business, not this script's. The base64 attempt that used to live here was
-# guesswork that never fired: what actually broke the fetcher was the store
-# returning bare hex for any multi-line value, which is neither base64-of-JSON
-# nor JSON, so both branches failed and the failure surfaced three layers later
-# as a token-exchange error.
+# business, not this script's, so nothing here guesses at a decoding. A guess
+# that misfires (bare hex read as base64, say) fails three layers later as a
+# token-exchange error instead of here.
 #
-# With no decode step there is nothing to stage on disk, so the temp file and its
-# cleanup traps went with it: the service-account JSON now only ever exists in a
-# shell variable, which is one fewer place a GCP private key can be left behind.
+# With no decode step there is nothing to stage on disk, so there is no temp file
+# and no cleanup trap: the service-account JSON only ever exists in a shell
+# variable, which is one fewer place a GCP private key can be left behind.
 SA_JSON="$SA_JSON_RAW"
 
 # Verify project_id from SA JSON matches the URL  -  protects against pasting a

package/pipeline/lib/model-rung.sh

@@ -69,7 +69,7 @@ host_note() {
       echo "Claude Code: the fable rung is Fable 5. This switch is live here."
       ;;
     copilot)
-      echo "Copilot CLI: Fable 5 is not offered; its personas never sat on this rung."
+      echo "Copilot CLI: Fable is not offered; its personas never sat on this rung."
       echo "This setting is recorded but changes nothing on this host."
       ;;
     codex)

package/pipeline/lib/plan-todos.sh

@@ -13,6 +13,7 @@
 # Subcommands:
 #   init      <task-id> [title]            Initialize with empty todos[] (Phase 2 usually pipes the JSON instead)
 #   set       <task-id> <plan-json>        Replace the whole plan from a JSON blob on stdin or arg
+#                                          (exit 2 when a dep names no todo id exactly)
 #   start     <task-id> <todo-id>          Mark in_progress, set startedAt; refuses if deps unsatisfied
 #                                          or the todo awaits re-plan confirmation
 #   complete  <task-id> <todo-id> [notes] [--no-tests <reason>]
@@ -84,10 +85,9 @@ resolve_state() {
   local task_id="$1"
   local found=""
   # multi-repo-pipeline.sh writes agent-state.json under a per-project
-  # directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/) - not the
-  # ~/.claude/projects/*/state/ path this used to glob, which no writer in
-  # the pipeline ever populates.
-  # This globbed ONLY the nested layout; flat-layout runs resolved to nothing.
+  # directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/), other
+  # writers write it flat; no writer uses ~/.claude/projects/*/state/.
+  # ma_resolve_run_file checks both layouts.
   found="$(ma_resolve_run_file "$task_id" agent-state.json 2>/dev/null || true)"
   if [ -z "$found" ]; then
     echo "plan-todos: agent-state.json not found for task=$task_id" >&2
@@ -155,6 +155,23 @@ do_set() {
     echo "plan-todos: every todo must be an object with string .id and .task fields" >&2
     exit 2
   fi
+  # Every dependency must name a todo exactly. Ids are compared as written, so
+  # `t1` against a todo `T1` would leave the dependent blocked for good; the
+  # error names the id that differs only by case.
+  local bad_deps
+  bad_deps=$(jq -r '
+    [.todos[].id] as $ids
+    | [.todos[] | .id as $owner | (.deps // [])[]
+        | select((type != "string") or (. as $d | $ids | index($d) | not))
+        | . as $d
+        | ($ids | map(select(($d | type) == "string" and ascii_downcase == ($d | ascii_downcase)))) as $near
+        | "\($owner) depends on \($d | tojson), which is no todo id"
+          + (if ($near | length) > 0 then " (did you mean \($near | map(tojson) | join(", "))?)" else "" end)]
+    | .[]' <<<"$plan_blob" 2>/dev/null)
+  if [ -n "$bad_deps" ]; then
+    printf 'plan-todos: %s\n' "$bad_deps" >&2
+    exit 2
+  fi
   local state_path; state_path=$(resolve_state "$task_id")
   local now; now=$(iso_now)
   local new

package/pipeline/lib/post-pr-review.sh

@@ -107,12 +107,10 @@ if [ -z "$TASK_ID" ]; then
 fi
 
 # Resolve agent-state.json. multi-repo-pipeline.sh writes it under a
-# per-project directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/)
-# - not the ~/.claude/projects/*/state/ path this used to glob, which no
-# writer in the pipeline ever populates.
-# This globbed ONLY the nested layout. phase-tracker.sh and most Phase 0 paths
-# write flat, so on a real machine the majority of runs resolved to nothing and
-# this script reported "no agent-state.json" for a run whose state existed.
+# per-project directory ($HOME/.claude/logs/multi-agent/{project}/{taskId}/),
+# while phase-tracker.sh and most Phase 0 paths write it flat; no writer uses
+# ~/.claude/projects/*/state/. ma_resolve_run_file checks both layouts, so a
+# run whose state exists is always found.
 AGENT_STATE="$(ma_resolve_run_file "$TASK_ID" agent-state.json 2>/dev/null || true)"
 
 if [ -z "$AGENT_STATE" ]; then

package/pipeline/lib/route-state.sh

@@ -77,7 +77,7 @@ free_savings() {
   since=$(( $(date +%s) - 7 * 86400 ))
   jq -rs --argjson since "$since" --slurpfile ct "$COST_TABLE" '
       map(select((.ts | sub("\\.[0-9]+Z$"; "Z") | fromdateiso8601? // 0) >= $since))
-    | ($ct[0].prices.haiku // {inPerMtok: 1, outPerMtok: 5}) as $h
+    | ($ct[0].prices.haiku // {inPerMtok: 0.5, outPerMtok: 2.5}) as $h
     | {
         n: length,
         ok: (map(select(.ok and (.cached | not))) | length),

package/pipeline/lib/shadow-git.sh

@@ -227,11 +227,10 @@ do_prune() {
     printf 'shadow-git: pruned shadow repo for %s\n' "$task_id" >&2
   else
     [ ! -d "$sd/.git" ] && { err "no shadow for $task_id"; exit 1; }
-    # Retention never touches a real work-tree: this used to run
-    # `reset --hard` with --work-tree=$(pwd), silently rewriting whatever
-    # directory prune happened to be invoked from, and it kept the OLDEST
-    # commit inside the window while discarding every newer one - backwards
-    # for a "keep the last N days" policy. Every git call below is
+    # Retention never touches a real work-tree: a `reset --hard` with
+    # --work-tree=$(pwd) would silently rewrite whatever directory prune is
+    # invoked from. It keeps every commit inside the window and drops the
+    # older ones, as a "keep the last N days" policy requires. Every git call below is
     # git-dir-only plumbing (log/rev-parse/commit-tree/update-ref/gc - no
     # checkout, no reset, no clean); the one --work-tree `sg` still wants
     # points at $sd itself, which prune already owns.

package/pipeline/multi-agent-refs/cross-cli-contract.md

@@ -262,8 +262,8 @@ that quietly no-ops is worse than one that says it cannot act.
 
 | Host | What `model on|off` does | Why |
 |---|---|---|
-| Claude Code | live switch: flips `modelFallback.fableEnabled` and realigns `costBudget.pricingModel` | the only host where the `fable` rung is Fable 5 |
-| Copilot CLI | writes the preference, changes no dispatch | Fable 5 is not offered there; its personas never sat on this rung |
+| Claude Code | live switch: flips `modelFallback.fableEnabled` and realigns `costBudget.pricingModel` | the only host where the `fable` rung is Fable 5.1 |
+| Copilot CLI | writes the preference, changes no dispatch | Fable is not offered there; its personas never sat on this rung |
 | Codex CLI | writes the preference, changes no dispatch, **deliberately** | the `fable` rung on Codex means `gpt-5.6 @ xhigh` - a different model on a different account. A knob named after an Anthropic model must not silently retune a Codex run |
 
 `model-rung.sh` prints which of the three it is on every invocation. The rule it
@@ -440,9 +440,8 @@ what keeps a secret off argv and what writes the audit entry.
   something that is not a timestamp.
 - `sed -E`, never `-r`; `sed -i ''` when editing in place.
 
-Clipboard callers may use `pbpaste` / `pbcopy` directly; the three-way
-`command -v` guard they used to carry was for hosts this package no longer
-installs on.
+Clipboard callers may use `pbpaste` / `pbcopy` directly; a `command -v` guard
+for other clipboard tools would serve hosts this package does not install on.
 
 ---
 

package/pipeline/multi-agent-refs/features/cost-analysis.md

@@ -46,6 +46,10 @@ discovered later:
 - A host with no such transcripts (Copilot, Codex) reports `UNMEASURED`, never
   zero. Zero would read as "you spent nothing" when it means "I could not see".
 
+A record is priced by its exact wire ID: a rung's `modelId`, a Copilot CLI
+`copilotModelId` at its own model's rate from the table's `models` map, or a
+previous-generation ID in the table's `legacy` map at that ID's own rate. A
+dated snapshot (`<id>-<date>`) prices as the longest known ID it extends.
 Records whose model is not in `cost-table.json` are COUNTED as unpriced and left
 out of the total. Folding them in at zero would make an unknown model look free,
 which is the direction that hurts.

package/pipeline/multi-agent-refs/features/model-fallback.md

@@ -11,17 +11,17 @@
 - [Codex CLI](#codex-cli)
 <!-- /toc -->
 
-> Contract last revised in **v10.6.0** (Fable 5 restored as top tier). The version tag here tracks the last substantive change to this contract, not the pipeline release.
+> Contract last revised in **v20.25.0** (current Claude generation; Copilot CLI model ids per rung). The version tag here tracks the last substantive change to this contract, not the pipeline release.
 
 Personas route to the top available intelligence tier they declare in
 `preferredModel`. That tier can be quota-limited or temporarily unavailable.
 This contract defines when and how the orchestrator falls back, deterministically,
 without ever editing persona files at runtime.
 
-> **Fable 5 available again (2026-07).** `claude-fable-5` is the top tier once
-> more. Architect (`ios/android/backend-architect`), Reviewer-1 (`code-reviewer`),
+> **Fable is the top tier.** The `fable` rung resolves to `claude-fable-5-1`.
+> Architect (`ios/android/backend-architect`), Reviewer-1 (`code-reviewer`),
 > and triage personas declare `preferredModel: fable` - the deepest-reasoning
-> roles. **If Fable 5 is unavailable, the first fallback is opus (`claude-opus-5`).**
+> roles. **If Fable is unavailable, the first fallback is opus (`claude-opus-5-5`).**
 > Security and other `preferredModel: opus` personas keep opus as their top tier.
 > The `premiumTierUntil` date gate stays in the contract as a generic mechanism
 > for any plan-window-limited premium tier.
@@ -35,7 +35,7 @@ fable -> opus -> sonnet -> haiku
 The orchestrator walks **one step down per trigger** from whichever tier a
 persona prefers: a `fable` persona degrades `fable -> opus` first, then
 `opus -> sonnet`, then `sonnet -> haiku`; an `opus` persona starts at
-`opus -> sonnet`. So a Fable 5 outage transparently promotes Opus 5 into the
+`opus -> sonnet`. So a Fable outage transparently promotes Opus into the
 architect/reviewer roles with no file edits.
 
 ### Rung names are the contract; model IDs are not
@@ -46,11 +46,16 @@ model ID each rung resolves to lives in exactly two places: `scripts/cost-table.
 `phases/phase-3-review.md`. A generation move edits those; it never renames a rung and
 never touches a persona file.
 
-Current resolution: `fable` -> `claude-fable-5`, `opus` -> `claude-opus-5`,
-`sonnet` -> `claude-sonnet-5`, `haiku` -> `claude-haiku-4-5`.
+Current resolution: `fable` -> `claude-fable-5-1`, `opus` -> `claude-opus-5-5`,
+`sonnet` -> `claude-sonnet-5-5`, `haiku` -> `claude-haiku-5-5`. These are the Claude Code
+wire IDs. Copilot CLI dispatches only the models `copilot help config` lists, with dotted
+names, so its column in the reviewer table names those (`claude-opus-4.7`,
+`claude-sonnet-4.6`), recorded per rung as `copilotModelId` in the cost table (haiku:
+`claude-haiku-4.5`). The fable rung has none and is not offered on Copilot CLI; a persona
+that prefers it dispatches the opus rung there.
 
-**Rate limits do not follow the rung.** Claude Opus 5 draws on a pool separate from
-the combined Opus 4.x pool, so a generation move does not inherit the previous
+**Rate limits do not follow the rung.** A new generation can draw on a rate-limit pool
+separate from the previous one, so a generation move does not inherit the previous
 generation's headroom. Budget-ceiling downgrades below are unaffected - they read the
 cost ledger, not the provider's quota - but a 429 on the opus rung after a generation
 move is a limits question, not a fallback-contract question.
@@ -119,8 +124,8 @@ Scope is Claude Code only, and the reason differs per host:
 
 | Host | Effect of `fableEnabled: false` | Why |
 |---|---|---|
-| Claude Code | Every `preferredModel: fable` persona (`ios/android/backend-architect`, `code-reviewer`, triage) starts on `opus` | This is the only host where the rung means Fable 5 |
-| Copilot CLI | none | Fable 5 is not offered there; its personas never sat on this rung |
+| Claude Code | Every `preferredModel: fable` persona (`ios/android/backend-architect`, `code-reviewer`, triage) starts on `opus` | This is the only host where the rung means Fable 5.1 |
+| Copilot CLI | none | Fable is not offered there; its personas never sat on this rung |
 | Codex CLI | none, deliberately | The `fable` rung there means `gpt-5.6 @ xhigh`, a different model on a different account. Switching it off from a knob named after an Anthropic model would surprise a Codex user, so it does not |
 
 **Phase 4 loses a reviewer, and says so.** Reviewer 1 lands on `opus`, which
@@ -250,7 +255,7 @@ better internals.
 - No edits to `pipeline/agents/*.md` at runtime; frontmatter is install-time
   configuration only.
 - Copilot CLI reviewer set is out of scope: Copilot CLI pins its own three
-  reviewer models (GPT-5.4 + Opus + Sonnet - Fable 5 is not offered there) and
+  reviewer models (GPT-5.4 + Opus + Sonnet - Fable is not offered there) and
   does not use this persona ladder. Only Claude Code dispatches Reviewer-1 on
   Fable.
 

package/pipeline/multi-agent-refs/phases/phase-0-init.md

@@ -652,7 +652,7 @@ Log: `Phase 0 Step 7.7: testDepth = {unit|unit+ui|unit+mcp} (source {user|autopi
 
 5. Phase 1 Analysis reads `state.clarification.userAnswers` (when present) as additional context  -  fold answers into the Explore prompt so downstream phases inherit the resolution.
 
-**Reference:** `$HOME/.claude/agents/task-clarifier.md`  -  scoring rubric, question-quality rules and the ~$0.0025-per-call cost note.
+**Reference:** `$HOME/.claude/agents/task-clarifier.md`  -  scoring rubric, question-quality rules and the ~$0.0004-per-call cost note.
 
 #### Telemetry
 

package/pipeline/multi-agent-refs/phases/phase-3-review.md

@@ -237,10 +237,10 @@ Launch Agent instances **in parallel** using the shared `code-reviewer` subagent
 
 | Reviewer   | subagent_type   | Claude Code | Copilot CLI | Codex CLI | Focus | Skills Referenced |
 | ---------- | --------------- | --- | --- | --- | --- | --- |
-| Reviewer 1 | `code-reviewer` | `claude-fable-5` | `claude-opus-5` | `gpt-5.6` @ `xhigh` | Deep security + architecture | `api-security-best-practices`, `architecture` |
-| Reviewer 2 | `code-reviewer` | `claude-opus-5` | `gpt-5.4` | `gpt-5.4` @ `high` | Edge cases, different perspective | cross-model diversity |
-| Reviewer 3 | `code-reviewer` | `claude-sonnet-5` | `claude-sonnet-5` | `gpt-5.6` @ `medium` | Quality + correctness + naming | `ai-backend-toolkit:clean-code`, stack-specific skill |
-| Triage     | triage persona  | `claude-fable-5` | `claude-opus-5` | `gpt-5.6` @ `max` | Filter false positives + out-of-scope | - |
+| Reviewer 1 | `code-reviewer` | `claude-fable-5-1` | `claude-opus-4.7` | `gpt-5.6` @ `xhigh` | Deep security + architecture | `api-security-best-practices`, `architecture` |
+| Reviewer 2 | `code-reviewer` | `claude-opus-5-5` | `gpt-5.4` | `gpt-5.4` @ `high` | Edge cases, different perspective | cross-model diversity |
+| Reviewer 3 | `code-reviewer` | `claude-sonnet-5-5` | `claude-sonnet-4.6` | `gpt-5.6` @ `medium` | Quality + correctness + naming | `ai-backend-toolkit:clean-code`, stack-specific skill |
+| Triage     | triage persona  | `claude-fable-5-1` | `claude-opus-4.7` | `gpt-5.6` @ `max` | Filter false positives + out-of-scope | - |
 
 Reviewer count per host: **Claude Code 3, Copilot CLI 3, Codex CLI 3**  -  **2** on Claude Code with the fable rung off, per `$HOME/.claude/multi-agent-refs/features/model-fallback.md`.
 
@@ -265,7 +265,7 @@ borderline finding. Where the diversity budget goes instead:
 
 Each reviewer inherits the `code-reviewer` agent's focus areas (Security, Architecture, Quality, Performance) and output contract. The orchestrator overrides only the model and the stack-specific skill per-reviewer  -  no prompt duplication.
 
-**Model override wiring:** `code-reviewer.md` declares `preferredModel: fable`, so Reviewer 1 uses the persona default (Fable 5). Reviewer 2 (`claude-opus-5` on Claude Code, `gpt-5.4` elsewhere) and Reviewer 3 (`claude-sonnet-5`) set `PHASE_MODEL_OVERRIDE=<model>` before dispatch  -  the orchestrator exports `CLAUDE_CODE_SUBAGENT_MODEL` on Claude Code, or passes `--model` on Copilot CLI. Full precedence rule: `skills/shared/core/multi-agent/SKILL.md#agent-dispatch--per-persona-model-routing`. Fable dispatches are subject to the fallback contract (`$HOME/.claude/multi-agent-refs/features/model-fallback.md`): dispatch-error retry walks `fable -> opus -> sonnet` and budget-ceiling downgrade.
+**Model override wiring:** `code-reviewer.md` declares `preferredModel: fable`, so Reviewer 1 uses the persona default (Fable 5.1). Reviewer 2 (`claude-opus-5-5` on Claude Code, `gpt-5.4` elsewhere) and Reviewer 3 (sonnet rung, per host above) set `PHASE_MODEL_OVERRIDE=<model>` before dispatch  -  the orchestrator exports `CLAUDE_CODE_SUBAGENT_MODEL` on Claude Code, or passes `--model` on Copilot CLI. Full precedence rule: `skills/shared/core/multi-agent/SKILL.md#agent-dispatch--per-persona-model-routing`. Fable dispatches are subject to the fallback contract (`$HOME/.claude/multi-agent-refs/features/model-fallback.md`): dispatch-error retry walks `fable -> opus -> sonnet` and budget-ceiling downgrade.
 
 **Stack-specific skills loaded per reviewer** (from Phase 1 `detectedStack`). All three columns are used on every host; Reviewer 2 reads them as Opus on Claude Code and as GPT-5.4 elsewhere.
 

package/pipeline/multi-agent-refs/picker-contract.md

@@ -190,6 +190,6 @@ park it writes `agent-state.json` beside its tracker with `taskId`,
 
 ## Deterministic gates note
 
-Claude Code's `PreToolUse` exit-2 hooks are the HARD blocking gates. Three ship, none needing run-specific arguments so they are naturally hookable: (1) `pre-commit-check.sh` scans the staged diff on every `git commit` and blocks on a detected secret; (2) `agent-guard.sh` runs on `git commit` + `git push` and blocks AI/assistant attribution in a commit message and force-push to a protected branch (main/master/develop); (3) `check-read-size.sh` runs on `Read` and on the shell commands that read a file whole, and routes an oversized read to a cheap worker (`bulk-read.sh`) instead of the caller's own rung. The first two inspect what a run WRITES; the third inspects what it pays to READ, and it is inert until `bulkRead.mode` is set to `observe` or `enforce`, so merging the block changes nothing until the user opts in. Its `observe` mode blocks nothing and only logs, which is how the baseline is measured before anything is routed. All three are self-contained and never execute the inspected command. On an internal error they let the call through in an attended session; `agent-guard.sh` blocks instead under `MULTI_AGENT_UNATTENDED=1`, where nobody is watching to notice a gap. Three capture hooks ship in the same block and block nothing: `SessionEnd` runs `capture-flush.sh --if-stale` (writing a killed run's findings into the per-repo stores, so they do not depend on the run reaching Phase 5) plus `note-session.sh` (the mechanical shape of a non-pipeline session: tools used, commands that failed, calls the user refused - never an argument, never any output), `PreCompact` runs `capture-flush.sh` without `--if-stale` (a compaction summarizes a long phase mid-flight, so it is the moment unflushed findings are at risk; the staleness test exists only so a session exit does not re-flush a finished run, and both store writes are idempotent), and `SessionStart` runs `capture-resume.sh`, at most two lines about an unfinished run and a stale observation queue. None of them calls a model; all exit 0 on every path. One `PostToolUse` hook ships in the same block and blocks nothing either: `edit-syntax-gate.sh` on `Edit|Write|MultiEdit` parses the file the edit just wrote (`swiftc -parse`, `node --check`, `py_compile` into a temp dir, `JSON.parse`, `bash -n`; Kotlin is skipped, no parser answers inside its 2 s deadline) and hands a syntax error to the model as `additionalContext`; it is silent when a parser is missing or slow, and inert until `editSyntaxGate.enabled` is true. Every registration here is Claude Code's: Codex has a `PostToolUse` event and Copilot CLI a `postToolUse` one, but the installer registers none of the pipeline's hooks on either host, so this gate is Claude Code only for now. The recommended hook block ships at `install/templates/claude-hooks.json`; `multi-agent:setup` offers to merge it into `~/.claude/settings.json`. The other deterministic gates (evidence, consensus, intent, learnings) are invoked by the pipeline phases with per-run arguments (a build-log path, the triage JSON, the free-text input), so they are phase-enforced by contract, not OS-hookable.
+Claude Code's `PreToolUse` exit-2 hooks are the HARD blocking gates. Three ship, none needing run-specific arguments so they are naturally hookable: (1) `pre-commit-check.sh` scans the staged diff on every `git commit` and blocks on a detected secret; (2) `agent-guard.sh` runs on `git commit` + `git push` and blocks AI/assistant attribution in a commit message and force-push to a protected branch (main/master/develop); (3) `check-read-size.sh` runs on `Read` and on the shell commands that read a file whole, and routes an oversized read to a cheap worker (`bulk-read.sh`) instead of the caller's own rung. The first two inspect what a run WRITES; the third inspects what it pays to READ, and it is inert until `bulkRead.mode` is set to `observe` or `enforce`, so merging the block changes nothing until the user opts in. Its `observe` mode blocks nothing and only logs, which is how the baseline is measured before anything is routed. All three are self-contained and never execute the inspected command. On an internal error they let the call through in an attended session; `agent-guard.sh` blocks instead under `MULTI_AGENT_UNATTENDED=1`, where nobody is watching to notice a gap. Three capture hooks ship in the same block and block nothing: `SessionEnd` runs `capture-flush.sh --if-stale` (writing a killed run's findings into the per-repo stores, so they do not depend on the run reaching Phase 5) plus `note-session.sh` (the mechanical shape of a non-pipeline session: tools used, commands that failed, calls the user refused - never an argument, never any output), `PreCompact` runs `capture-flush.sh` without `--if-stale` (a compaction summarizes a long phase mid-flight, so it is the moment unflushed findings are at risk; the staleness test exists only so a session exit does not re-flush a finished run, and both store writes are idempotent), and `SessionStart` runs `capture-resume.sh`, at most two lines about an unfinished run and a stale observation queue. None of them calls a model; all exit 0 on every path. One `PostToolUse` hook ships in the same block and blocks nothing either: `edit-syntax-gate.sh` on `Edit|Write|MultiEdit` parses the file the edit just wrote (`swiftc -parse`, `node --check`, `py_compile` into a temp dir, `JSON.parse`, `bash -n`; Kotlin is skipped, no parser answers inside its 2 s deadline) and hands a syntax error to the model as `additionalContext`; it is silent when a parser is missing or slow, and inert until `editSyntaxGate.enabled` is true. The syntax gate also runs on Codex, on `PostToolUse` for `apply_patch` (every file the patch adds, updates or moves to). `multi-agent:setup` Step 8 asks once and registers it there with `host-hooks.mjs install --host codex` from `install/templates/codex-hooks.json`: idempotent, leaving every other hook alone, `status` reports it and uninstall removes it. Codex runs it only after the user trusts it in `/hooks`, which the helper says. Copilot CLI gets no registration: as of 1.0.45 it discards a `postToolUse` hook's output and applies no matcher, so the gate would cost a spawn per tool call and say nothing. Every other registration here is Claude Code's. The recommended hook block ships at `install/templates/claude-hooks.json`; `multi-agent:setup` offers to merge it into `~/.claude/settings.json`. The other deterministic gates (evidence, consensus, intent, learnings) are invoked by the pipeline phases with per-run arguments (a build-log path, the triage JSON, the free-text input), so they are phase-enforced by contract, not OS-hookable.
 
 Copilot CLI has no `PreToolUse` equivalent, so the secret scan there is workflow-enforced (run as a phase step, not OS-blocked) plus a CI smoke-gate step.

package/pipeline/multi-agent-refs/tracker-contract.md

@@ -146,11 +146,11 @@ acted on, not read.
 #### Accounting is a gate, not a request
 
 `update <N> completed` exits **3** for phases 1-4 when nothing was recorded via
-`tokens`. The alternative is what shipped for months: the docs asked for the
-call, `smoke-tracker-tokens-invocation.sh` linted that the docs *mention* the
-call, and no run made it  -  every phase priced at `-`, every completion line
-printed without numbers, and every gate green. A lint over prose cannot observe
-a runtime omission; the tool that would have received the call can.
+`tokens`. A doc that asks for the call, and a lint
+(`smoke-tracker-tokens-invocation.sh`) that checks the doc *mentions* it, cannot
+see a run that skips it: every phase would price at `-` and every completion line
+would print without numbers while every gate passes. A lint over prose cannot
+observe a runtime omission; the tool that would have received the call can.
 
 The refusal is recoverable and loses no work:
 
@@ -160,7 +160,7 @@ phase-tracker.sh tokens <N> <in> <out> [cached]
 phase-tracker.sh update <N> completed
 ```
 
-`model` resolves a full model id to its cost-table family (`claude-opus-5` →
+`model` resolves a full model id to its cost-table family (`claude-opus-5-5` →
 `opus`) and says so out loud when it cannot, because an unpriced name is the
 other way a phase silently costs nothing. A phase that truly ran no LLM call
 completes with `--no-llm`, which is recorded and keeps it out of the run

package/pipeline/schemas/plan-todos.schema.json

@@ -27,8 +27,8 @@
         "properties": {
           "id": {
             "type": "string",
-            "pattern": "^t[0-9]+$",
-            "description": "Stable identifier (t1, t2, ...). Used in dependency edges + progress lines."
+            "pattern": "^[tT][0-9]+$",
+            "description": "Stable identifier: t1, t2 when written directly, T1, T2 when converted from a planning-output document. Used in dependency edges and progress lines."
           },
           "task": {
             "type": "string",
@@ -43,7 +43,7 @@
             "type": "array",
             "default": [],
             "description": "Array of todo IDs that must reach `completed` (or `skipped`) before this one can move to `in_progress`. Empty for parallelizable steps.",
-            "items": { "type": "string", "pattern": "^t[0-9]+$" }
+            "items": { "type": "string", "pattern": "^[tT][0-9]+$" }
           },
           "startedAt": { "type": "string", "format": "date-time" },
           "completedAt": { "type": "string", "format": "date-time" },
@@ -148,7 +148,7 @@
             "properties": {
               "because": {
                 "type": "string",
-                "pattern": "^t[0-9]+$",
+                "pattern": "^[tT][0-9]+$",
                 "description": "The step that drifted."
               },
               "at": { "type": "string", "format": "date-time" },

package/pipeline/schemas/prefs.schema.json

@@ -568,7 +568,7 @@
             "fableEnabled": {
               "type": "boolean",
               "default": false,
-              "description": "Whether the fable rung is available at all on Claude Code. Ships OFF: the top rung is the most expensive thing a run can reach, and a cost control that is on by default is not a control. false makes every persona that declares preferredModel: fable dispatch on opus from the first call, with no dispatch attempt on fable and no error to recover from  -  a cost control, not a fallback. Claude Code only: Copilot CLI does not offer Fable 5, and on Codex CLI the fable rung means gpt-5.6 @ xhigh, which this switch deliberately does not touch. Turning it off also collapses the Phase 3 Claude Code reviewer panel from three to two (Reviewer 1 lands on opus, which Reviewer 2 already holds), and consensus.reviewerCount records 2."
+              "description": "Whether the fable rung is available at all on Claude Code. Ships OFF: the top rung is the most expensive thing a run can reach, and a cost control that is on by default is not a control. false makes every persona that declares preferredModel: fable dispatch on opus from the first call, with no dispatch attempt on fable and no error to recover from  -  a cost control, not a fallback. Claude Code only: Copilot CLI does not offer Fable, and on Codex CLI the fable rung means gpt-5.6 @ xhigh, which this switch deliberately does not touch. Turning it off also collapses the Phase 3 Claude Code reviewer panel from three to two (Reviewer 1 lands on opus, which Reviewer 2 already holds), and consensus.reviewerCount records 2."
             },
             "onDispatchError": {
               "type": "boolean",
@@ -1211,7 +1211,7 @@
         "clarifyAmbiguous": {
           "type": "object",
           "additionalProperties": false,
-          "description": "v8.6+  -  Phase 0 Step 9 clarifying-question loop. Before Phase 1 starts, a cheap Haiku classifier scores task ambiguity (0-10) and emits up to N questions if score < threshold. Cost: ~$0.0025 per Haiku call. Off by default  -  flip on for teams burned by ambiguity-driven rework or when working on cross-team issues where the spec lives in someone else's head.",
+          "description": "v8.6+  -  Phase 0 Step 9 clarifying-question loop. Before Phase 1 starts, a cheap Haiku classifier scores task ambiguity (0-10) and emits up to N questions if score < threshold. Cost: ~$0.0004 per Haiku call. Off by default  -  flip on for teams burned by ambiguity-driven rework or when working on cross-team issues where the spec lives in someone else's head.",
           "properties": {
             "enabled": {
               "type": "boolean",
@@ -1841,7 +1841,7 @@
         "editSyntaxGate": {
           "type": "object",
           "additionalProperties": false,
-          "description": "Parse the file an Edit / Write / MultiEdit just wrote and tell the model when it no longer parses: swiftc -parse, node --check, python3 py_compile (bytecode to a temp dir), JSON.parse, bash -n, chosen by extension, each under a 2 s deadline. Kotlin and every other extension are skipped. The hook is pipeline/scripts/edit-syntax-gate.sh (PostToolUse, Claude Code, installed from install/templates/claude-hooks.json). It never blocks: the message arrives as PostToolUse context and the hook exits 0. A parser that is not installed or runs past the deadline means no message.",
+          "description": "Parse the file an edit just wrote and tell the model when it no longer parses: swiftc -parse, node --check, python3 py_compile (bytecode to a temp dir), JSON.parse, bash -n, chosen by extension, each under a 2 s deadline. Kotlin and every other extension are skipped. The hook is pipeline/scripts/edit-syntax-gate.sh: PostToolUse on Claude Code (install/templates/claude-hooks.json) and on Codex apply_patch (codex-hooks.json, registered by host-hooks.mjs). Copilot CLI is not registered: as of 1.0.45 it discards postToolUse output. It never blocks: the message arrives as PostToolUse context and the hook exits 0. A parser that is not installed or runs past the deadline means no message.",
           "properties": {
             "enabled": {
               "type": "boolean",
@@ -2006,7 +2006,7 @@
               },
               "localRepo": {
                 "type": "string",
-                "description": "Repo that localPath is relative to, e.g. $HOME/multi-agent-plugins. Without it localPath reads as relative to the current repo, which is how both entries came to point at the UPSTREAM tree and stayed wrong through a rename: nothing in the config said which checkout held the derived copies."
+                "description": "Repo that localPath is relative to, e.g. $HOME/multi-agent-plugins. Without it localPath reads as relative to the current repo, so an entry can silently point at the UPSTREAM tree: nothing else in the config says which checkout holds the derived copies."
               },
               "upstreamMarketplace": {
                 "type": "string",

package/pipeline/scripts/_code-graph.mjs

@@ -212,8 +212,8 @@ const IMPORT_LINE_RE = /^[ \t]*import[ \t].*$/gm;
  *
  * Swift's submodule form - `import class DesignKit.PrimaryButton` - otherwise
  * feeds the `class` definition pattern, which registers the MODULE name as a
- * declared type. On a large Swift app that alone lifted two module names into
- * the top ten god-nodes, which is how the bug surfaced. Imports are extracted
+ * declared type. On a large Swift app that alone lifts module names into the
+ * top ten god-nodes. Imports are extracted
  * before this runs, so nothing is lost.
  *
  * @param {string} stripped - output of stripCode