@mmerterden/multi-agent-pipeline 18.0.0 → 19.1.0

package/pipeline/commands/multi-agent/resume-local/SKILL.md

@@ -1,6 +1,6 @@
 ---
-description: "Continue already-done LOCAL work through the pipeline tail: Review → Build+Test → Commit/PR → Report (technical analysis + Jira test-scenario comment). No dev phase. Use when local work is already done and only review, build, commit and reporting remain."
-description-tr: "Halihazırda bitmiş LOKAL işi pipeline kuyruğundan geçirir: Review → Build+Test → Commit/PR → Report (teknik analiz + Jira test-senaryosu yorumu). Dev fazı yok."
+description: "Continue already-done LOCAL work through the pipeline tail: Review (with its build gate) → Commit/PR → Report (technical analysis + Jira test-scenario comment). No dev phase. Use when local work is already done and only review, build, commit and reporting remain."
+description-tr: "Halihazırda bitmiş LOKAL işi pipeline kuyruğundan geçirir: Review (build kapısıyla) → Commit/PR → Report (teknik analiz + Jira test-senaryosu yorumu). Dev fazı yok."
 allowed-tools: Agent, Bash, Read, Write, Edit, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, AskUserQuestion, WebFetch, WebSearch, Skill
 ---
 
@@ -25,7 +25,7 @@ You already did the work locally  -  wrote code on the current branch and maybe
 
 ```bash
 /multi-agent:resume-local                       # current branch vs its base; resolve Jira id from branch name
-/multi-agent:resume-local PROJ-12345          # bind to an explicit Jira id for the Phase 7 comment
+/multi-agent:resume-local PROJ-12345          # bind to an explicit Jira id for the Phase 5 comment
 /multi-agent:resume-local --base develop         # override the base branch for the diff
 /multi-agent:resume-local autopilot              # no gate prompts: auto-fix blocking findings, auto-PR, auto-comment
 ```
@@ -34,13 +34,15 @@ You already did the work locally  -  wrote code on the current branch and maybe
 
 ```
 Phase 0: Init          → project/branch detect, resolve base + diff (work-already-done), Jira id, state (NO worktree)
-Phase 4: Review        → deterministic gates + parallel review (Fable + Opus + Sonnet) + Fable triage
-Phase 5: Build+Test    → stack-aware build gate + run existing tests; SUCCESS required (automated, not the interactive user-test)
-Phase 6: Commit        → commit remaining local changes + push + open PR if none exists
-Phase 7: Report        → technical analysis + Jira comment with test scenarios (channels: Jira / PR / Confluence / Wiki)
+Phase 3: Review        → the Verify gate first (stack-aware build + existing tests; SUCCESS required), then
+                         parallel review (Fable + Opus + Sonnet) + Fable triage
+Phase 4: Commit        → commit remaining local changes + push + open PR if none exists
+Phase 5: Report        → technical analysis + Jira comment with test scenarios (channels: Jira / PR / Confluence / Wiki)
 ```
 
-Phases 1-3 (Analysis / Planning / Dev) are skipped by design  -  `ship` treats the current branch's local changes as the Phase 3 output.
+Phases 1-2 (Plan / Dev) are skipped by design  -  `ship` treats the current branch's local changes as the Phase 2 output.
+
+**Why Review runs the build gate here.** Verify is Phase 2 Dev's exit gate since v19.0.0, and this mode has no Dev: the work arrived already written. The gate still has to run, so Review runs it before dispatching reviewers, which is what Review Stage 1 did before the consolidation. Reviewing a branch whose build was never checked is the failure this ordering prevents.
 
 ## Phase 0  -  Context resolution (finish-specific)
 
@@ -52,12 +54,12 @@ Phases 1-3 (Analysis / Planning / Dev) are skipped by design  -  `ship` treats t
 
 ## Phase execution (reuse the existing phase contracts)
 
-- **Phase 4 Review** - run per `$HOME/.claude/multi-agent-refs/phases/phase-4-review.md` against the resolved diff: deterministic gates (Step 1.x), stack-specific parallel reviewers (Fable + Opus + Sonnet on Claude Code; GPT + Opus + Sonnet on Copilot CLI), Fable triage → `triage.accepted`. Blocking/important accepted findings:
+- **Phase 3 Review** - run per `$HOME/.claude/multi-agent-refs/phases/phase-3-review.md` against the resolved diff: deterministic gates (Step 1.x), stack-specific parallel reviewers (Fable + Opus + Sonnet on Claude Code; GPT + Opus + Sonnet on Copilot CLI), Fable triage → `triage.accepted`. Blocking/important accepted findings:
   - interactive: present them and ask (`AskUserQuestion`) whether to fix now (loop back through a minimal Phase-3-style TDD fix) or proceed;
   - `autopilot` (or `prefs.global.resumeLocal.autoFix == true`): auto-fix accepted blocking/important findings, then re-review the fix, before advancing.
-- **Phase 5 Build+Test** - the **automated success gate** (this is what "build+test success" means here; the interactive device user-test is `/multi-agent:manual-test`). Stack-aware: build via `figma-config.build` (iOS scheme / Android gradle / detected backend/web build) and run the existing test suite if present (`swift test` / `xcodebuild test` / `./gradlew test` / `pytest` / `npm test` / `vitest`). Require success to advance; on failure, surface logs and (interactive) stop or (autopilot) attempt a bounded fix loop. **If the repo has no tests, report "no tests present" - never fabricate test results.**
-- **Phase 6 Commit/PR** - per `$HOME/.claude/multi-agent-refs/phases/phase-6-commit.md`: stage + commit any remaining local changes with a conventional message (`{type}(scope): desc [{JIRA_KEY}-{id}]`), push, and open a PR **only if one does not already exist** for the branch. PR body per `$HOME/.claude/multi-agent-refs/rules.md "External System Outputs"` and `$HOME/.claude/rules/git-conventions.md` - `Ref: #N` / `Related: #N`, never `Closes/Fixes/Resolves`; NO AI/bot attribution anywhere.
-- **Phase 7 Report** - per `$HOME/.claude/multi-agent-refs/phases/phase-7-report.md` + `channels.md`: produce the **technical analysis** and **test scenarios**, then post to the configured channels. Default content for `ship`: a Jira **comment** carrying the technical analysis + the test scenarios (and, when the PR was opened, the PR description). Every body runs through the humanizer; bot/tool/AI signatures are FORBIDDEN in comments.
+- **Phase 3 Verify gate** - the **automated success gate** (this is what "build+test success" means here; the interactive device user-test is `/multi-agent:manual-test`). Stack-aware: build via `figma-config.build` (iOS scheme / Android gradle / detected backend/web build) and run the existing test suite if present (`swift test` / `xcodebuild test` / `./gradlew test` / `pytest` / `npm test` / `vitest`). Require success to advance; on failure, surface logs and (interactive) stop or (autopilot) attempt a bounded fix loop. **If the repo has no tests, report "no tests present" - never fabricate test results.**
+- **Phase 4 Commit/PR** - per `$HOME/.claude/multi-agent-refs/phases/phase-4-commit.md`: stage + commit any remaining local changes with a conventional message (`{type}(scope): desc [{JIRA_KEY}-{id}]`), push, and open a PR **only if one does not already exist** for the branch. PR body per `$HOME/.claude/multi-agent-refs/rules.md "External System Outputs"` and `$HOME/.claude/rules/git-conventions.md` - `Ref: #N` / `Related: #N`, never `Closes/Fixes/Resolves`; NO AI/bot attribution anywhere.
+- **Phase 5 Report** - per `$HOME/.claude/multi-agent-refs/phases/phase-5-report.md` + `channels.md`: produce the **technical analysis** and **test scenarios**, then post to the configured channels. Default content for `ship`: a Jira **comment** carrying the technical analysis + the test scenarios (and, when the PR was opened, the PR description). Every body runs through the humanizer; bot/tool/AI signatures are FORBIDDEN in comments.
 
 ## Modes
 
@@ -70,17 +72,17 @@ Before writing anything outward-facing  -  PR body, Jira comment, Confluence pag
 
 ## Required: Phase Tracker Contract
 
-**The phase tracker is required.** Full spec: [`$HOME/.claude/multi-agent-refs/tracker-contract.md`]($HOME/.claude/multi-agent-refs/tracker-contract.md). `ship` registers its active phase set  -  `0:Init 4:Review 5:Build+Test 6:Commit 7:Report`  -  but NEVER resets a tracker that an earlier run already built (load-or-continue; contract section "Continuation runs"):
+**The phase tracker is required.** Full spec: [`$HOME/.claude/multi-agent-refs/tracker-contract.md`]($HOME/.claude/multi-agent-refs/tracker-contract.md). `ship` registers its active phase set  -  `0:Init 3:Review 4:Commit 5:Report`  -  but NEVER resets a tracker that an earlier run already built (load-or-continue; contract section "Continuation runs"):
 
 ```bash
 # Phase 0, first shell call (every CLI). init ONLY when no prior state exists -
-# a task handed off from Phase 5 ("awaiting local test") keeps its full
-# phase 0-3 history (elapsed, tokens, USD).
+# a task handed off from the user test inside Phase 3 ("awaiting local test")
+# keeps its full phase 0-2 history (elapsed, tokens, USD).
 STATE="$HOME/.claude/logs/multi-agent/${TASK_ID}/tracker-state.json"
 if [ ! -f "$STATE" ]; then
   bash $HOME/.claude/scripts/phase-tracker.sh init "$TASK_ID"
 fi
-for p in "0:Init" "4:Review" "5:Build+Test" "6:Commit" "7:Report"; do
+for p in "0:Init" "3:Review" "4:Commit" "5:Report"; do
   bash $HOME/.claude/scripts/phase-tracker.sh add "${p%%:*}" "${p#*:}"   # idempotent: existing phases keep their history
 done
 bash $HOME/.claude/scripts/phase-tracker.sh update 0 in_progress
@@ -91,7 +93,7 @@ bash $HOME/.claude/scripts/phase-tracker.sh update <N> in_progress|completed|fai
 bash $HOME/.claude/scripts/phase-tracker.sh tokens <N> <in> <out> [cached]
 ```
 
-**Continuation path (prior state existed):** (1) if Phase 5 was left `in_progress` with `Now: awaiting local test (user)`, mark it `update 5 completed` + `meta 5 Result "local test done (user)"` before finish's own work (finish re-opens it with `update 5 in_progress` when its Build+Test gate runs; elapsed keeps the original `started_at`, which is expected); (2) print ONE line in `outputLanguage` summarizing the inherited history, e.g. `Continuing PROJ-12345: phases 0-3 finished earlier (12m, 38.4k tok, ~$0.74)` (USD via `phase-tracker.sh cost total`); (3) `render`.
+**Continuation path (prior state existed):** (1) if Phase 3 was left `in_progress` with `Now: awaiting local test (user)`, mark it `update 3 completed` + `meta 3 Result "local test done (user)"` before finish's own work (finish re-opens it with `update 3 in_progress` when its Verify gate runs; elapsed keeps the original `started_at`, which is expected); (2) print ONE line in `outputLanguage` summarizing the inherited history, e.g. `Continuing PROJ-12345: phases 0-3 finished earlier (12m, 38.4k tok, ~$0.74)` (USD via `phase-tracker.sh cost total`); (3) `render`.
 
 ### Visual channel  -  Claude Code (native TaskList widget, required)
 

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

@@ -194,7 +194,7 @@ Every host runs three reviewers; only the second slot differs, because GPT-5.4 e
 
 With the `fable` rung disabled by prefs the Claude Code panel is two reviewers (Opus + Sonnet); see `$HOME/.claude/multi-agent-refs/features/model-fallback.md`.
 
-Each reviewer receives the diff, the module review guides from Step 2b (when any were found), plus the standard reviewer system prompt (see `$HOME/.claude/multi-agent-refs/phases/phase-4-review.md` for the prompt contract). Output: structured `findings[]` per reviewer.
+Each reviewer receives the diff, the module review guides from Step 2b (when any were found), plus the standard reviewer system prompt (see `$HOME/.claude/multi-agent-refs/phases/phase-3-review.md` for the prompt contract). Output: structured `findings[]` per reviewer.
 
 ### 4. Store-compliance cross-reference
 
@@ -312,7 +312,7 @@ Per the `$HOME/.claude/multi-agent-refs/tracker-contract.md` tokens contract, af
 bash $HOME/.claude/scripts/phase-tracker.sh tokens 4 <input_count> <output_count>
 ```
 
-Standalone `/multi-agent:review` runs use phase id 4 (matches Phase 4 Review in the full pipeline) so cost aggregation stays consistent.
+Standalone `/multi-agent:review` runs use phase id 3 (matches Phase 3 Review in the full pipeline) so cost aggregation stays consistent.
 
 ## Input matrix
 

package/pipeline/commands/multi-agent/review-analysis/SKILL.md

@@ -23,7 +23,7 @@ Read `$HOME/.claude/multi-agent-refs/analysis/review.md` and execute it:
 
 ## Why it cites Locked decisions
 
-The analysis flow already declares 36 Locked decisions and two deterministic validators. A reviewer that says "I would have written this differently" gives the author nothing to act on; one that says "Locked 34: the Confluence page is in the evidence record but not in Section 21" gives them a fix and a reason. Findings that map to no rule are still allowed, but they are marked as judgement, not dressed up as a violation.
+The analysis flow already declares 36 Locked decisions and two deterministic validators. A reviewer that says "I would have written this differently" gives the author nothing to act on; one that says "Locked 33: the Confluence page is in the evidence record but not in Section 21" gives them a fix and a reason. Findings that map to no rule are still allowed, but they are marked as judgement, not dressed up as a violation.
 
 ## What it never does
 

package/pipeline/commands/multi-agent/route-off/SKILL.md

@@ -0,0 +1,36 @@
+---
+description: "Disable model routing and keep its rules, so turning it back on does not re-ask for the same configuration. Use when asked to turn model routing off."
+description-tr: "Model yönlendirmesini kapatır ve kurallarını saklar; tekrar açıldığında aynı yapılandırma yeniden sorulmaz."
+---
+
+# multi-agent route-off  -  disarm routing, keep the configuration
+
+```bash
+bash "$HOME/.claude/lib/route-state.sh" off
+```
+
+Sets `prefs.global.modelRouting.enabled` to `false`. Dispatch returns to the
+plain ladder immediately: every persona takes its `preferredModel`, and the
+`modelFallback` rules are the only thing that can move it.
+
+## The rules are not deleted
+
+`strategy`, `scope`, `rules[]` and `budgetCeilingUsd` all survive. `route-on`
+brings back exactly what was configured, without asking again.
+
+This is the same contract `autopilot-off` follows with its repo selection, for
+the same reason: a command named after a toggle that quietly discards
+configuration is a destructive action in disguise. To actually remove the rules,
+replace them with an empty array:
+
+```bash
+echo '[]' > /tmp/none.json
+bash "$HOME/.claude/lib/route-state.sh" set-rules /tmp/none.json
+```
+
+## What stays behind
+
+Routing decisions already written to the cost ledger stay there. They are a
+record of what happened on past runs, and deleting them would make a run's cost
+unexplainable after the fact - which is the one thing the ledger exists to
+prevent.

package/pipeline/commands/multi-agent/route-on/SKILL.md

@@ -0,0 +1,74 @@
+---
+description: "Enable policy-driven model routing: pick a strategy, a scope, and the rules that say which rung a call lands on. Use when asked to turn model routing on."
+description-tr: "Politika güdümlü model yönlendirmesini açar: strateji, kapsam ve hangi çağrının hangi basamağa düşeceğini söyleyen kuralları sorar."
+argument-hint: "[--strategy=manual|task-fit|cost-ceiling] [--scope=subagent,bulk-read,research]"
+---
+
+# multi-agent route-on  -  arm model routing
+
+```bash
+bash "$HOME/.claude/lib/route-state.sh" on ${ARGUMENTS}
+```
+
+Routing ships **off**. This is the command that turns it on, and it writes to
+`prefs.global.modelRouting`, validated against the repo's `schemas/route-config.schema.json`.
+
+## What a rule is
+
+```json
+{ "when": { "persona": "code-reviewer" }, "prefer": ["opus", "sonnet"] }
+{ "when": { "phase": 2 },                 "prefer": ["sonnet", "haiku"] }
+```
+
+Ordered, first match wins. `when` matches on `persona`, `phase` (0..5) or
+`taskKind`; `prefer` lists rungs in descending preference.
+
+**Rung names are the contract; model ids are not.** `opus` is a rung here and a
+model id in `cost-table.json`, and the second can change without anyone editing
+a rule. Writing `claude-opus-5` into a rule pins a decision to a string that will
+go stale.
+
+Set rules with:
+
+```bash
+bash "$HOME/.claude/lib/route-state.sh" set-rules path/to/rules.json
+```
+
+## Strategies
+
+| Strategy | What it does |
+|---|---|
+| `manual` | only the explicit rules apply, nothing is inferred. The default, because a router that guesses is a router nobody can predict |
+| `task-fit` | a rule may match on `taskKind`, and the cheapest rung clearing it is chosen |
+| `cost-ceiling` | rungs downgrade as the run approaches `budgetCeilingUsd` |
+
+## Scope, and the value that is not in it
+
+`scope` names the call sites routing may act on: `subagent`, `bulk-read`,
+`research`. Every one of them is a call **this pipeline makes itself**.
+
+There is no `host-session` value, and that absence is enforced by that schema
+rather than written as advice. Routing a host session means rewriting the CLI's
+base URL to point at a local gateway - which sends the user's *entire* session
+through a third layer, including work that has nothing to do with this pipeline,
+breaks the subscription's auth model, and silently changes which model answered.
+Passing `--scope=host-session` is refused with that reason, not ignored.
+
+## The limit this command prints every time
+
+On Claude Code a subagent cannot be dispatched to a non-Anthropic model: subagent
+dispatch belongs to the host, not to us. So Phase 1, 2 and 3 personas stay inside
+the Anthropic ladder no matter what the rules say, and external providers apply
+only at `bulk-read` and `research`, where the pipeline makes the HTTP call.
+
+This is printed by `route-status` on every invocation instead of living in a doc,
+because the question it answers - "routing is on, why is the reviewer still on
+Opus" - otherwise arrives days later as a bug report.
+
+## Related
+
+- `/multi-agent:route-off` - disables routing and **keeps** the rules
+- `/multi-agent:route-status` - what is active, and what it costs
+- `/multi-agent:model` - whether the top rung exists at all. That is a different
+  question: this command decides which rung a call picks, that one decides
+  whether the top one is in play

package/pipeline/commands/multi-agent/route-status/SKILL.md

@@ -0,0 +1,56 @@
+---
+description: "Report model routing: whether it is armed, which rule applies where, which rung the last dispatches took, and what this run has cost. Use when asked which model is being used or why."
+description-tr: "Model yönlendirmesinin durumunu raporlar: açık mı, hangi kural nerede geçerli, son çağrılar hangi basamağa gitti, bu koşu ne tuttu."
+---
+
+# multi-agent route-status  -  what is actually routing
+
+```bash
+bash "$HOME/.claude/lib/route-state.sh" status
+```
+
+Reports the stored policy, then the part that matters more: **what it can and
+cannot reach.**
+
+## Three states, told apart
+
+| Output | Meaning |
+|---|---|
+| `routing: false`, rules present | configured and disarmed. `route-on` restores it as-is; nothing is lost |
+| `routing: true`, `rules: 0` | armed with nothing to match. Not an error - a configuration state, and the most common "I turned it on and nothing changed" |
+| `routing: true` with rules listed | live. Each rule is printed as `when <key>=<value> -> rung > rung` |
+
+A disabled router with rules is deliberately not reported as "off" alone: that
+reads as "unconfigured" and sends the user through `route-on`'s questions a
+second time.
+
+## The limit, printed every time
+
+On Claude Code a subagent cannot be sent to a non-Anthropic model. Subagent
+dispatch belongs to the host; the pipeline asks for a persona and the host
+decides what answers. So Phase 1, 2 and 3 personas stay inside the Anthropic
+ladder whatever the rules say, and an external provider is only reachable where
+the pipeline makes the HTTP call itself - `bulk-read.sh` and `research_ask`.
+
+This paragraph is output, not documentation, because the alternative is the
+question arriving later as "routing is on but the reviewer is still on Opus, is
+it broken". It is not broken; it is the seam.
+
+## Where decisions are recorded
+
+With `recordDecisions: true` (the default) every routing decision is written to
+the cost ledger: which rule matched, which rung it chose, and why. That is what
+makes a run's cost explainable after it finished - a router whose choices are not
+recorded cannot be audited, and the cost question always arrives after the run,
+never during it.
+
+Per-run cost and the model breakdown come from the same ledger:
+
+```bash
+node "$HOME/.claude/scripts/token-budget-report.mjs" --json
+```
+
+## Related
+
+- `/multi-agent:route-on` / `/multi-agent:route-off` - arm and disarm
+- `/multi-agent:model` - whether the top rung exists at all

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

@@ -558,7 +558,7 @@ Re-run scan from Step 1. Show final status:
 All tokens present. Pipeline ready to use.
 
 Optional per-project features (configured on first use, nothing to do now):
-  • Phase 7 Report Step 2 Wiki  -  auto-generates component wiki pages + Figma
+  • Phase 5 Report Step 2 Wiki  -  auto-generates component wiki pages + Figma
     screenshots. Activates when (a) task is a component AND (b) a Figma token
     is in Keychain. Four adapters supported: submodule / in-repo / github-wiki
     / separate-repo. First run asks: use auto-detected path, use a custom
@@ -803,7 +803,7 @@ All tokens are optional in the sense that every service can be answered with Ski
 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 three capture hooks that block nothing (`PreCompact`, `SessionEnd`, `SessionStart`). 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 7 then loses its findings exactly as it did before they existed. Preserve existing hooks; never duplicate a matcher already calling the same script.
+- 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`.
 

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

@@ -19,7 +19,7 @@ Show every active and completed task as a table.
 
    `runs-index.mjs` resolves through `lib/run-paths.sh` / `scripts/_run-paths.mjs`,
    so it sees both directory layouts (`<project>/<id>/` and the flat `<id>/`),
-   the salvaged `artifacts/` copy Phase 6 leaves behind, and every spelling of a
+   the salvaged `artifacts/` copy Phase 4 leaves behind, and every spelling of a
    task id - and it counts a run that exists in both layouts once. Do NOT
    re-scan the tree by hand: the earlier instruction here listed three
    hard-coded `.worktrees/` paths and a single `find` depth, and on a real
@@ -33,7 +33,7 @@ Show every active and completed task as a table.
 2. **Fields per run** (already in the output): `taskId`, `project`, `branch`,
    `currentPhase`, `status`, `startedAt`, `worktreePath`, `prUrl`, `autopilot`,
    `phases[]`, `tokens`, `estUsd`, `group`, plus `duplicateOf` when the run also
-   exists in the other layout and `salvaged` when its state is the Phase 6 copy.
+   exists in the other layout and `salvaged` when its state is the Phase 4 copy.
 
 3. **Groups are computed, not judged.** `runs-index.mjs` assigns `group` by the
    table below; report what it returns rather than re-deriving it. `in_progress`
@@ -42,7 +42,7 @@ Show every active and completed task as a table.
 
    | Group | Test | Action offered |
    |---|---|---|
-   | `waiting` - Waiting on you | `status == "awaiting_input"`, or a `pr.url`, or phase >= 6 | `resume #N` - the work landed, it needs your answer |
+   | `waiting` - Waiting on you | `status == "awaiting_input"`, or a `pr.url`, or phase >= 4 | `resume #N` - the work landed, it needs your answer |
    | `stopped` - Stopped mid-development | anything else past phase 0 | `resume #N` or `kill #N` |
    | `question` - Left at a question | phase 0 | `garbage-collect --abandoned` - nothing was built |
    | `unknown` - Status not recorded | no `status` field | say so; offer nothing |
@@ -57,8 +57,8 @@ Show every active and completed task as a table.
 
    | ID | Jira/Task | Branch | Phase | Status | Duration |
    |----|-----------|--------|-------|--------|----------|
-   | #1 | {JIRA-KEY}-12345 | feature/{JIRA-KEY}-12345-... | 7/7 DONE | ✅ Complete | 12m |
-   | #3 | {JIRA-KEY}-12345 | feature/{JIRA-KEY}-12345-... | 7/7 DONE | ✅ Complete | 8m |
+   | #1 | {JIRA-KEY}-12345 | feature/{JIRA-KEY}-12345-... | 5/5 DONE | ✅ Complete | 12m |
+   | #3 | {JIRA-KEY}-12345 | feature/{JIRA-KEY}-12345-... | 5/5 DONE | ✅ Complete | 8m |
 
    💡 log #1 | resume #N | kill #N
    ```

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

@@ -41,7 +41,7 @@ is being replaced.
    | `paused` / `failed` | Say the task is not running, and that `/multi-agent:resume #N` will re-enter with the instruction applied at that phase's entry. Queue it. |
    | `complete` | Refuse. Nothing will read it. Point at `/multi-agent` for a follow-up run. |
 
-   `currentPhase` is 7 and status is `in_progress` → warn that Phase 7 is the
+   `currentPhase` is 7 and status is `in_progress` → warn that Phase 5 is the
    last one, so an instruction queued now may never be consumed.
 
 3. **Read the instruction**  -  from the argument, or ask for it when the
@@ -52,7 +52,7 @@ is being replaced.
 4. **Show what will be queued, and ask**:
 
    ```
-   Steer #3 ({JIRA-KEY}-12345, Phase 3 Dev, in_progress)
+   Steer #3 ({JIRA-KEY}-12345, Phase 2 Dev, in_progress)
 
      "the field is called web, not frontend"
 

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

@@ -65,8 +65,8 @@ Run every step automatically:
 ```
 Step 0: DOCTOR      doctor.mjs  -  exit 2 or 4 stops the sync
 Step 1.5: DETECT    Compare timestamps, find stale targets
-Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 56 sub-command skills)
-Step 2b: CODEX      Claude Code -> Codex CLI (1 router skill + 56 specs as refs + 8 agent TOML)
+Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 60 sub-command skills)
+Step 2b: CODEX      Claude Code -> Codex CLI (1 router skill + 60 specs as refs + 8 agent TOML)
 Step 3: REPO        Claude Code -> pipeline repo (genericized, personal data scrub, bash -n on all sh)
 Step 3c: PLUGINS    pipeline shared/external -> multi-agent-plugins marketplace (rebuild knowledge/,
                      bump changed plugins' patch version, commit + push the plugins repo)
@@ -494,19 +494,18 @@ same 56 specs as reference files rather than as peer skills, via Step 2b -  see
 |-------------|-------------|
 | `~/.claude/commands/multi-agent/{cmd}/SKILL.md` | `~/.copilot/skills/multi-agent-{cmd}/SKILL.md` |
 
-**56 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
+**60 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
 
 ```
-analysis, analysis-jira, analysis-resolve, autopilot, autopilot-off,
-autopilot-on, autopilot-status, build-optimize, channels, complaint-analysis,
-create-jira, design-check, diff-explain, doctor, feedback, forget,
-garbage-collect, graph, help, ios-coding-standard, issue, jira, kill,
-language, local, local-autopilot, log, manual-test, prune-logs,
-prune-prompts, purge, refactor, resume, resume-local, review,
-review-analysis, review-issue, review-jira, routines, save, scan, search,
-setup, stack, status, steer, store-ready, sync, test, test-accessibility,
-test-dark-mode, test-dynamic-type, test-screenshots, testflight-validation,
-uninstall, update
+analysis, analysis-jira, analysis-resolve, autopilot, autopilot-off, autopilot-on,
+autopilot-status, build-optimize, channels, complaint-analysis, create-jira,
+design-check, diff-explain, doctor, feedback, forget, garbage-collect, graph, help,
+ios-coding-standard, issue, jira, kill, language, local, local-autopilot, log,
+manual-test, model, prune-logs, prune-prompts, purge, refactor, resume, resume-local,
+review, review-analysis, review-issue, review-jira, route-off, route-on, route-status,
+routines, save, scan, search, setup, stack, status, steer, store-ready, sync, test,
+test-accessibility, test-dark-mode, test-dynamic-type, test-screenshots,
+testflight-validation, uninstall, update
 ```
 
 **NOT synced**: `$HOME/.claude/multi-agent-refs/*`  -  lazy-load references, Claude Code specific

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

@@ -1,6 +1,6 @@
 ---
 description: "UI Bug Hunter  -  iOS Simulator (simctl) + Android Emulator (adb). Auto-detects platform. Screenshot + tap + analyze on the booted device. The Phase 5 Manual Test flow lives at /multi-agent:manual-test. Use when a running app should be driven on a simulator or emulator to hunt UI bugs."
-description-tr: "UI Bug Hunter - iOS Simulator (simctl) + Android Emulator (adb). Platformu otomatik algılar. Açık cihazda screenshot + tap + analiz. Faz 5 Manuel Test akışı /multi-agent:manual-test'te."
+description-tr: "UI Bug Hunter - iOS Simulator (simctl) + Android Emulator (adb). Platformu otomatik algılar. Açık cihazda screenshot + tap + analiz. Faz 3 Manuel Test akışı /multi-agent:manual-test'te."
 argument-hint: '[scenario]  -  e.g. "dark mode" | "accessibility" | "dynamic type" | "screenshot tr" | "store-ready" | (empty = full sweep)'
 ---
 

package/pipeline/lib/credential-inventory.sh

@@ -345,7 +345,7 @@ capability_of() {
     esac
   fi
   case "$1" in
-    jira)              echo "read the ticket, its comments and its linked issues; post the Phase 7 comment" ;;
+    jira)              echo "read the ticket, its comments and its linked issues; post the Phase 5 comment" ;;
     bitbucket_token)   echo "read the repo, open and update pull requests" ;;
     bitbucket_user)    echo "identify the PR author (paired with bitbucket_token)" ;;
     github)            echo "read issues, open pull requests, read Actions runs" ;;

package/pipeline/lib/fetch-fortify.sh

@@ -49,7 +49,7 @@
 #   6  not configured (prefs.global.hosts.fortify empty, or an instance-id-only
 #      lookup with no prefs.global.fortify.versionIds to search)
 #
-# Phase 4 review gate contract:
+# Phase 3 review gate contract:
 #   Critical > 0   → blocking=true, reason="critical-findings"
 #   High > 0       → blocking=false, reason="high-findings-warning"
 #   else           → blocking=false, reason="clean"

package/pipeline/lib/model-dispatch.sh

@@ -0,0 +1,140 @@
+#!/usr/bin/env bash
+# model-dispatch.sh  -  which rung answers this call.
+#
+# The one place `prefs.global.modelRouting` turns into a rung. Every call site
+# that may be routed asks here, so the policy has a single implementation and
+# `/multi-agent:route-status` describes something real.
+#
+# Usage:
+#   model-dispatch.sh <call-site> [--persona P] [--phase N] [--task-kind K]
+#                                 [--default RUNG] [--task-id ID]
+#
+# <call-site> is one of the `scope` members: subagent | bulk-read | research.
+# stdout is a single rung NAME. Rung names are the contract; the model id behind
+# one lives in cost-table.json and moves without a config edit.
+#
+# Exit is always 0 and stdout is always a usable rung. A router that can fail
+# turns every call site into a place the run can die, for a feature that ships
+# disabled; when anything is missing, unparseable or out of scope, the caller's
+# default comes back unchanged.
+#
+# Two layers, and the difference is the safety argument the schema spells out:
+#
+#   Layer 1  an Anthropic rung. Reachable from every call site, because it
+#            writes to a seam that already exists and opens no new network path.
+#   Layer 2  a non-Anthropic rung. Reachable ONLY from a call site the pipeline
+#            makes itself. A subagent is dispatched by the HOST, so a rule that
+#            prefers an external rung for a subagent cannot be honoured - and
+#            this script says so on stderr rather than pretending it was.
+
+set -uo pipefail
+
+CALL_SITE="${1:-}"
+shift || true
+
+PERSONA=""; PHASE=""; TASK_KIND=""; DEFAULT_RUNG=""; TASK_ID="${MULTI_AGENT_TASK_ID:-unknown}"
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --persona)   PERSONA="${2:-}"; shift 2 ;;
+    --phase)     PHASE="${2:-}"; shift 2 ;;
+    --task-kind) TASK_KIND="${2:-}"; shift 2 ;;
+    --default)   DEFAULT_RUNG="${2:-}"; shift 2 ;;
+    --task-id)   TASK_ID="${2:-}"; shift 2 ;;
+    *) shift ;;
+  esac
+done
+
+emit() { printf '%s\n' "$1"; exit 0; }
+
+case "$CALL_SITE" in
+  subagent|bulk-read|research) ;;
+  *) emit "$DEFAULT_RUNG" ;;
+esac
+
+[ -n "$DEFAULT_RUNG" ] || DEFAULT_RUNG="sonnet"
+
+command -v jq >/dev/null 2>&1 || emit "$DEFAULT_RUNG"
+
+PREFS=""
+for candidate in \
+  "${MULTI_AGENT_PREFS:-}" \
+  "$HOME/.claude/multi-agent-preferences.json" \
+  "$HOME/.config/multi-agent-pipeline/multi-agent-preferences.json"
+do
+  [ -n "$candidate" ] && [ -f "$candidate" ] && { PREFS="$candidate"; break; }
+done
+[ -n "$PREFS" ] || emit "$DEFAULT_RUNG"
+
+ENABLED=$(jq -r '.global.modelRouting.enabled // false' "$PREFS" 2>/dev/null) || emit "$DEFAULT_RUNG"
+[ "$ENABLED" = "true" ] || emit "$DEFAULT_RUNG"
+
+# Out of scope is not a failure and not a warning. The user named the call sites
+# routing may touch; the ones they left out keep their existing behaviour, which
+# is the point of naming them.
+IN_SCOPE=$(jq -r --arg cs "$CALL_SITE" \
+  '((.global.modelRouting.scope // ["subagent"]) | index($cs)) != null' "$PREFS" 2>/dev/null)
+[ "$IN_SCOPE" = "true" ] || emit "$DEFAULT_RUNG"
+
+# First rule whose every stated condition matches. A `when` with three keys has
+# to match on all three - the schema requires at least one, so an always-matching
+# rule cannot be written by accident.
+MATCH=$(jq -r \
+  --arg persona "$PERSONA" --arg phase "$PHASE" --arg kind "$TASK_KIND" \
+  '[ (.global.modelRouting.rules // [])[]
+     | select(
+         ((.when.persona  // null) as $p | $p == null or $p == $persona)
+         and ((.when.phase   // null) as $h | $h == null or ($phase != "" and ($h | tostring) == $phase))
+         and ((.when.taskKind // null) as $k | $k == null or $k == $kind)
+       )
+   ] | first | (.prefer // []) | join(" ")' "$PREFS" 2>/dev/null) || emit "$DEFAULT_RUNG"
+[ -n "$MATCH" ] && [ "$MATCH" != "null" ] || emit "$DEFAULT_RUNG"
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+COST_TABLE="$HERE/../scripts/cost-table.json"
+
+# The fable rung answers only when the fable switch is on. Routing is a policy
+# over what is available; it is not a second way to turn a rung on, or
+# `/multi-agent:model off` would stop meaning anything the moment a rule named
+# fable.
+FABLE_ON=$(jq -r '.global.modelFallback.fableEnabled // false' "$PREFS" 2>/dev/null)
+
+record() {
+  [ -x "$HERE/../scripts/log-metric.sh" ] || return 0
+  local rec
+  rec=$(jq -r '.global.modelRouting.recordDecisions // true' "$PREFS" 2>/dev/null)
+  [ "$rec" = "false" ] && return 0
+  "$HERE/../scripts/log-metric.sh" "$TASK_ID" "${PHASE:-0}" model_routing.decision \
+    call_site="$CALL_SITE" rung="$1" reason="$2" >/dev/null 2>&1 || true
+}
+
+for rung in $MATCH; do
+  if [ ! -f "$COST_TABLE" ]; then
+    record "$rung" "no cost table; rung taken on trust"
+    emit "$rung"
+  fi
+  PROVIDER=$(jq -r --arg r "$rung" '.prices[$r].provider // ""' "$COST_TABLE" 2>/dev/null)
+  # A rung nobody priced is a typo in a config far more often than it is a new
+  # model. Skipping it silently would route to the next one and leave the user
+  # certain their rule applied.
+  if [ -z "$PROVIDER" ]; then
+    echo "model-dispatch: rung '$rung' is not in cost-table.json; skipping it" >&2
+    continue
+  fi
+  if [ "$rung" = "fable" ] && [ "$FABLE_ON" != "true" ]; then
+    echo "model-dispatch: rule prefers 'fable' but modelFallback.fableEnabled is false; skipping it" >&2
+    continue
+  fi
+  if [ "$PROVIDER" != "anthropic" ] && [ "$CALL_SITE" = "subagent" ]; then
+    # The honest limit, said out loud at the moment it bites. Subagent dispatch
+    # belongs to the host; we cannot send one to another provider, and a router
+    # that quietly downgraded to an Anthropic rung here would leave the user
+    # believing a rule worked that never could.
+    echo "model-dispatch: rung '$rung' is $PROVIDER and subagent dispatch belongs to the host; skipping it" >&2
+    continue
+  fi
+  record "$rung" "rule matched"
+  emit "$rung"
+done
+
+record "$DEFAULT_RUNG" "every preferred rung was unavailable"
+emit "$DEFAULT_RUNG"