@mmerterden/multi-agent-pipeline 17.6.0 → 19.0.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 4 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
 

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

@@ -9,43 +9,56 @@ Show every active and completed task as a table.
 
 ## Steps
 
-1. **Detect the project**  -  find the repo root from cwd (otherwise scan every known repo):
-   - `~/my-ios-app/.worktrees/`
-   - `~/my-figma-app/.worktrees/`
-   - `~/my-ui-components/.worktrees/`
+1. **Ask the producer, do not go looking.** One command answers the whole
+   question:
 
-2. **Scan worktrees**  -  read `agent-state.json` in each worktree dir. **Also scan the log dir**, because a task whose PR is open has no worktree any more (Phase 6 removes it and salvages its state): `find $HOME/.claude/logs/multi-agent -maxdepth 4 -name agent-state.json -path '*/artifacts/*'`. (`-maxdepth 4`, not 3: Phase 6 always passes `--project`, so the salvaged copy lands at `<project>/<task-id>/artifacts/agent-state.json`, which a depth-3 scan can never reach.) Merge both sets by `taskId`, preferring the worktree copy when both exist, and render a finalized task with its `worktreeRemovedAt` rather than omitting it  -  a task that shipped should not vanish from status.
    ```bash
-   find {repo}/.worktrees/ -name "agent-state.json" -maxdepth 2
+   node "$HOME/.claude/scripts/runs-index.mjs"          # grouped table
+   node "$HOME/.claude/scripts/runs-index.mjs" --json   # the same records
    ```
 
-3. **Parse state**  -  for each task:
-   - `taskId`, `branch`, `currentPhase`, `status`, `startedAt`, `autopilot`
-
-3b. **Sort into three groups, and label them.** `in_progress` alone cannot tell
-   a run that is waiting for you from one that died, and on this machine that
-   difference covered 20 runs: 3 were holding at Phase 6/7 with their PR already
-   open, 11 were left at a Phase 0 question with nothing built, 6 stopped
-   mid-development. One "in progress" label for all three is what made a
-   finished job and a crashed one share a row.
+   `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 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
+   install that combination missed a quarter of the runs and double-counted
+   others. It also scanned worktrees for `agent-state.json`, which Phase 0 has
+   never written there ("never inside the worktree", `phases/phase-0-init.md`).
+
+   The JSON and the table are rendered from the same records, so a dashboard and
+   this command cannot disagree.
+
+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 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`
+   alone cannot tell a run that is waiting for you from one that died, and on
+   this machine that difference covered 21 runs.
 
    | Group | Test | Action offered |
    |---|---|---|
-   | Waiting on you | `status == "awaiting_input"`, or a `pr.url`, or phase 6/7 | `resume #N` - the work landed, it needs your answer |
-   | Stopped mid-development | anything else past phase 0 | `resume #N` or `kill #N` |
-   | Left at a question | phase 0 | `garbage-collect --abandoned` - nothing was built |
+   | `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 |
 
-   A run with no `status` is **not** placed in any group. Unknown is not a
-   finding, and calling it dead is the same false claim in the other direction.
+   A run with no `status` is **not** placed in an actionable group. Unknown is
+   not a finding, and calling it dead is the same false claim in the other
+   direction.
 
-4. **Render as a table**, grouped per 3b, with the group as a section heading:
+4. **Render as a table**, grouped per step 3, with the group as a section heading:
    ```
    🤖 Multi-Agent Tasks
 
    | 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
    ```
@@ -59,6 +72,24 @@ Show every active and completed task as a table.
 
    Report `N lesson(s) minable from transcripts  -  /multi-agent:refactor to review` and `N open pipeline observation(s)` when either count is above zero, and print nothing when both are zero. Neither runs a model and neither writes anything: the miner is dry-run by default. Zero candidates alongside a non-zero `toolResultsExamined` means there is nothing to find; zero of both means the read is broken, and that is worth saying rather than reporting a clean queue.
 
+7. **What the spend is doing** (one line, and only when there is something to
+   say). `cost-budget-check.mjs` watches ONE run against ONE ceiling, which is
+   blind to the two ways a budget actually empties: a drift no single run trips,
+   and one pathological session that burns a week in an hour while every run
+   stays under its cap.
+
+   ```bash
+   node "$HOME/.claude/scripts/cost-analyze.mjs" burn --json 2>/dev/null
+   node "$HOME/.claude/scripts/cost-analyze.mjs" anomaly --days 30 --json 2>/dev/null
+   ```
+
+   Report a line only when either exits 10 - an accelerating day, or a day out
+   of family - and say nothing otherwise. The figures are estimates priced from
+   `cost-table.json` at LIST price, so on a subscription they are the right
+   number for comparing days to each other and the wrong number to call a bill;
+   say which when quoting one. `UNMEASURED` means the transcripts could not be
+   read, and it is reported as that rather than as zero.
+
 5. **Quick command hints**  -  based on state:
    - Paused task → suggest `resume #N`
    - Done task → suggest `log #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/_jira-auth.sh

@@ -40,6 +40,14 @@ JIRA_AUTH_PREFS="${JIRA_AUTH_PREFS:-$HOME/.claude/multi-agent-preferences.json}"
 
 _jira_auth_pref() {  # _jira_auth_pref <jq path> -> value or empty
   [ -f "$JIRA_AUTH_PREFS" ] || { printf ''; return 0; }
+  # Without jq this printed empty and returned 0, so "no jq" and "key not set"
+  # were the same answer and the caller went on to authenticate with nothing -
+  # surfacing much later as a 401 that blames the credential.
+  if ! command -v jq >/dev/null 2>&1; then
+    echo "jq not found - cannot read $JIRA_AUTH_PREFS (install: brew install jq)" >&2
+    printf ''
+    return 3
+  fi
   jq -r "$1 // empty" "$JIRA_AUTH_PREFS" 2>/dev/null || printf ''
 }
 

package/pipeline/lib/analysis-jira-write.sh

@@ -125,6 +125,30 @@ fi
 # back in CREATED_KEY. Returning the key on stdout too meant a caller using
 # command substitution swallowed the report - the first dry run printed a header
 # and nothing else, and the tree looked empty.
+# Same gate, same five candidate paths, same refusal as jira-publish.sh and
+# post-pr-review.sh. This file is the only ISSUE-CREATION path in the tree, and
+# a summary plus a description is outbound text like any other - it was the one
+# writer the gate did not cover.
+ma_outbound_gate_text() {
+  local text="$1" og="" tmp rc
+  for c in "$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)/outbound-gate.mjs" \
+           "$HOME/.claude/lib/outbound-gate.mjs" \
+           "$HOME/.copilot/lib/outbound-gate.mjs" \
+           "$HOME/.codex/lib/outbound-gate.mjs"; do
+    [ -f "$c" ] && { og="$c"; break; }
+  done
+  if [ -z "$og" ]; then
+    echo "outbound-gate.mjs not found - refusing to create unchecked issues." >&2
+    return 7
+  fi
+  tmp="$(mktemp)"
+  printf '%s' "$text" > "$tmp"
+  node "$og" --file "$tmp"
+  rc=$?
+  rm -f "$tmp"
+  return $rc
+}
+
 CREATED_KEY=""
 create_issue() {  # create_issue <label> <summary> <issuetype> <parentKey|""> <description>
   local label="$1" summary="$2" itype="$3" parent="$4" desc="$5" body key existing
@@ -146,6 +170,14 @@ create_issue() {  # create_issue <label> <summary> <issuetype> <parentKey|""> <d
     echo "  create  $itype  $summary   [$label]"
     return 0
   fi
+  # After the dry-run branch, because a dry run publishes nothing, and before
+  # the ledger line, because an intent recorded for a POST that never happens
+  # is a false entry in the only record of what was attempted.
+  if ! ma_outbound_gate_text "$summary
+$desc"; then
+    echo "ERR: outbound gate refused '$summary'; nothing was created" >&2
+    return 1
+  fi
   ledger intent "$label"
   local resp
   resp="$(printf '%s' "$body" | jira_api POST "/rest/api/2/issue" --data @- || echo "")"

package/pipeline/lib/ask-choice.sh

@@ -14,6 +14,9 @@
 #
 # Non-interactive / autopilot / CI:
 #   - ASK_CHOICE_DEFAULT=<label-or-1based-index>  picks without prompting.
+#   - MULTI_AGENT_UNATTENDED=1 means nobody is watching even if a terminal is
+#     attached (screen, tmux, a login shell on a server). Same resolution as
+#     the no-TTY case.
 #   - If stdin is not a TTY and no default is set, the FIRST option is chosen
 #     and a notice is written to stderr (never blocks an automated run).
 #
@@ -64,8 +67,16 @@ if [ -n "${ASK_CHOICE_DEFAULT:-}" ]; then
 fi
 
 # Non-interactive with no usable default: pick the first option, don't block.
-if [ ! -t 0 ]; then
-  echo "ask-choice: no TTY and no ASK_CHOICE_DEFAULT - selecting first option '${OPTIONS[0]}'" >&2
+#
+# "No TTY" is the usual shape of that, but it is not the only one. A server run
+# under screen, tmux or a login shell HAS a terminal and still has nobody in
+# front of it, and there the TTY test says "ask" and the process waits forever.
+# MULTI_AGENT_UNATTENDED=1 is the operator saying so out loud; see
+# refs/unattended-contract.md. Unset, nothing below changes.
+if [ ! -t 0 ] || [ "${MULTI_AGENT_UNATTENDED:-}" = "1" ]; then
+  why="no TTY"
+  [ "${MULTI_AGENT_UNATTENDED:-}" = "1" ] && why="MULTI_AGENT_UNATTENDED=1"
+  echo "ask-choice: $why and no ASK_CHOICE_DEFAULT - selecting first option '${OPTIONS[0]}'" >&2
   printf '%s\n' "${OPTIONS[0]}"
   exit 0
 fi

package/pipeline/lib/autopilot-state.sh

@@ -133,6 +133,14 @@ ma_ap_read() { # $1 = filename; empty and exit 1 when absent
 # jq with a default, so a caller never has to distinguish "key absent" from
 # "file absent" from "file unparseable" - all three mean "use the default".
 ma_ap_cfg() { # $1 = jq path, $2 = default
+  # An unreadable queue must not read as an EMPTY queue. Without this, a
+  # machine with no jq made the runner conclude there was no work and go
+  # quiet - the worst failure this mode can have, because it looks like
+  # success.
+  if ! command -v jq >/dev/null 2>&1; then
+    echo "jq not found - cannot read the autopilot config (install: brew install jq)" >&2
+    return 3
+  fi
   local v
   v=$(ma_ap_read config.json 2>/dev/null | jq -r "$1 // empty" 2>/dev/null)
   [ -n "$v" ] && printf '%s\n' "$v" || printf '%s\n' "$2"

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" ;;