@mmerterden/multi-agent-pipeline 16.20.0 → 16.23.0

package/README.md

@@ -89,7 +89,7 @@ Depth, autopilot and `--local` are the only knobs on the run itself; everything
 
 ## Commands
 
-`/multi-agent` plus 55 sub-commands. `/multi-agent:help` renders the same catalog in your terminal, in your `outputLanguage`.
+`/multi-agent` plus 51 sub-commands. `/multi-agent:help` renders the same catalog in your terminal, in your `outputLanguage`.
 
 ### Pipeline entries
 
@@ -187,8 +187,6 @@ Depth, autopilot and `--local` are the only knobs on the run itself; everything
 | `/multi-agent:uninstall` | Remove the pipeline from every CLI. Keychain tokens always left intact |
 | `/multi-agent:help` | This catalog, in the terminal, in your `outputLanguage` |
 
-Four names are kept only as redirects: `:dev` and `:dev-local` point at `/multi-agent` and `:local` answered Short, and `:dev-autopilot` / `:dev-local-autopilot` have no equivalent - "fast plus unattended" was removed in v16.0.0.
-
 ### Subagents
 
 Eight are installed alongside the commands and dispatched by the phases: `explorer` and `task-clarifier` (Phase 0-1), `ios-architect` / `android-architect` / `backend-architect` (Phase 2), `dev-critic` (Phase 3), `code-reviewer` and `security-auditor` (Phase 4).
@@ -209,17 +207,17 @@ This enables the matching plugin (+ the shared `ai-common` plugin) in the repo's
 
 ## Tool support
 
-The pipeline runs natively on **Claude Code**, **Copilot CLI** and **Codex CLI** - all three install from the same `pipeline/` source and get the same 55 commands.
+The pipeline runs natively on **Claude Code**, **Copilot CLI** and **Codex CLI** - all three install from the same `pipeline/` source and get the same 51 commands.
 
 | Tool | Flag | What it installs |
 |---|---|---|
-| Claude Code | `--claude` (default) | slash commands + skills + agents + `PreToolUse` secret-scan hook |
-| Copilot CLI | `--copilot` | instructions + 55 sub-command skills + scripts |
-| Codex CLI | `--codex` | one router skill + 55 specs as refs + 8 agent TOML + `AGENTS.md` block + `codex mcp add` |
+| Claude Code | `--claude` (default) | slash commands + skills + agents + three `PreToolUse` hooks (secret scan, agent-guard, read-size gate) |
+| Copilot CLI | `--copilot` | instructions + 51 sub-command skills + scripts |
+| Codex CLI | `--codex` | one router skill + 51 specs as refs + 8 agent TOML + `AGENTS.md` block + `codex mcp add` |
 
 Filter skills by stack with `--platform=ios\|android\|all`.
 
-**Why Codex gets one skill and not 55.** Codex assembles every discovered skill's name
+**Why Codex gets one skill and not 51.** Codex assembles every discovered skill's name
 and description into a single prompt block and drops entries when it overflows, with no
 error. Measured on 0.145: installing one plugin that declares 142 skills surfaced only
 75 of them and evicted an unrelated user skill. So on Codex the pipeline ships a single

package/README.tr.md

@@ -89,7 +89,7 @@ Koşunun kendisinde ayarlanabilen tek şey derinlik, autopilot ve `--local`; ger
 
 ## Komutlar
 
-`/multi-agent` ve 55 alt komut. `/multi-agent:help` aynı katalogu terminalde, `outputLanguage` ayarına göre gösterir.
+`/multi-agent` ve 51 alt komut. `/multi-agent:help` aynı katalogu terminalde, `outputLanguage` ayarına göre gösterir.
 
 ### Pipeline girişleri
 
@@ -187,8 +187,6 @@ Koşunun kendisinde ayarlanabilen tek şey derinlik, autopilot ve `--local`; ger
 | `/multi-agent:uninstall` | Pipeline'ı her CLI'dan kaldırır. Keychain token'larına hiç dokunmaz |
 | `/multi-agent:help` | Bu katalog, terminalde, `outputLanguage`'ine göre |
 
-Dört ad yalnızca yönlendirme olarak duruyor: `:dev` ve `:dev-local` sırasıyla `/multi-agent` ve `:local` çalıştırıp Short seçmeye yönlendirir, `:dev-autopilot` ile `:dev-local-autopilot` ise karşılıksız - "hızlı artı gözetimsiz" v16.0.0'da kaldırıldı.
-
 ### Alt agent'lar
 
 Komutlarla birlikte sekiz agent kurulur ve fazlar bunları çağırır: `explorer` ve `task-clarifier` (Faz 0-1), `ios-architect` / `android-architect` / `backend-architect` (Faz 2), `dev-critic` (Faz 3), `code-reviewer` ve `security-auditor` (Faz 4).
@@ -209,17 +207,17 @@ Bu, ilgili plugin'i (+ ortak `ai-common` plugin'ini) repo'nun `.claude/settings.
 
 ## Araç desteği
 
-Pipeline **Claude Code**, **Copilot CLI** ve **Codex CLI** üzerinde native çalışır - üçü de aynı `pipeline/` kaynağından kurulur ve aynı 55 komutu alır.
+Pipeline **Claude Code**, **Copilot CLI** ve **Codex CLI** üzerinde native çalışır - üçü de aynı `pipeline/` kaynağından kurulur ve aynı 51 komutu alır.
 
 | Araç | Bayrak | Ne kurar |
 |---|---|---|
-| Claude Code | `--claude` (varsayılan) | slash komutları + skill'ler + agent'lar + `PreToolUse` secret-scan hook'u |
-| Copilot CLI | `--copilot` | talimatlar + 55 alt-komut skill'i + script'ler |
-| Codex CLI | `--codex` | bir router skill + ref olarak 55 spec + 8 agent TOML + `AGENTS.md` bloğu + `codex mcp add` |
+| Claude Code | `--claude` (varsayılan) | slash komutları + skill'ler + agent'lar + üç `PreToolUse` hook'u (secret scan, agent-guard, okuma-boyutu geçidi) |
+| Copilot CLI | `--copilot` | talimatlar + 51 alt-komut skill'i + script'ler |
+| Codex CLI | `--codex` | bir router skill + ref olarak 51 spec + 8 agent TOML + `AGENTS.md` bloğu + `codex mcp add` |
 
 Skill'leri stack'e göre filtrele: `--platform=ios\|android\|all`.
 
-**Codex neden 55 değil de tek bir skill alıyor.** Codex, keşfettiği her skill'in adını
+**Codex neden 51 değil de tek bir skill alıyor.** Codex, keşfettiği her skill'in adını
 ve açıklamasını tek bir prompt bloğuna toplar ve blok taştığında girdileri hatasızca
 düşürür. 0.145 üzerinde ölçüldü: 142 skill deklare eden bir plugin kurulduğunda sadece
 75'i yüzeye çıktı ve alakasız bir kullanıcı skill'i tahliye edildi. Bu yüzden Codex'te

package/docs/architecture.md

@@ -117,7 +117,7 @@ graph TB
     end
 
     subgraph "Pipeline Specs"
-        CMD[commands/<br/>55 command files]
+        CMD[commands/<br/>51 command files]
         AGT[agents/<br/>8 agent personas]
         RUL[rules/<br/>12 domain rules]
         PHS[multi-agent-refs/phases/<br/>phase specs + contracts]
@@ -169,8 +169,8 @@ revisions of this diagram - Codex CLI and the two independently-shipped repos
 ```mermaid
 graph TD
     CC["Claude Code<br/>(source of truth)"]
-    COP["Copilot CLI<br/>(instructions + 55 skills)"]
-    COD["Codex CLI<br/>(1 router skill + 55 refs)"]
+    COP["Copilot CLI<br/>(instructions + 51 skills)"]
+    COD["Codex CLI<br/>(1 router skill + 51 refs)"]
     REPO["Pipeline Repo<br/>(npm package)"]
     WEB["Website"]
     PLUGREPO["multi-agent-plugins<br/>(5 stack plugins, own repo)"]

package/docs/ecosystem.md

@@ -5,7 +5,7 @@ separately, wired together at install time and at run time:
 
 | Repo | What it owns | Ships as |
 |---|---|---|
-| **`multi-agent-pipeline`** (this repo) | Orchestration: the 8-phase flow, the 55 slash commands, quality gates, review/triage, cross-CLI parity | npm package (`@mmerterden/multi-agent-pipeline`), installs itself onto Claude Code / Copilot CLI / Codex CLI |
+| **`multi-agent-pipeline`** (this repo) | Orchestration: the 8-phase flow, the 51 slash commands, quality gates, review/triage, cross-CLI parity | npm package (`@mmerterden/multi-agent-pipeline`), installs itself onto Claude Code / Copilot CLI / Codex CLI |
 | **`multi-agent-plugins`** | Stack knowledge: per-platform component/lifecycle skills (iOS, Android, Frontend, Backend) + shared knowledge | Claude Code marketplace, 5 independently-versioned plugins |
 | **`multi-agent-toolkit-mcp`** | The pipeline's hands on devices and browsers: 80 MCP tools across 6 categories (simulator/emulator control, accessibility audit, store compliance, web automation, Figma-vs-mock design audit, an agent-DSL batch runner) | npm package, registered as a standard stdio MCP server on every host |
 
@@ -18,7 +18,7 @@ Either can be swapped or removed without touching the other two's source.
 graph LR
     subgraph PIPE ["multi-agent-pipeline (orchestrator)"]
         direction TB
-        PHASES["8 phases · 55 commands"]
+        PHASES["8 phases · 51 commands"]
         GATES["deterministic gates + review triage"]
     end
 
@@ -64,8 +64,8 @@ only those:
 graph TD
     CC["Claude Code<br/>~/.claude/commands/multi-agent/<br/>(source of truth)"]
 
-    CC -->|"Step 2: copy + reformat<br/>55 sub-command skills"| COP["Copilot CLI<br/>~/.copilot/skills/"]
-    CC -->|"Step 2b: transform<br/>(install.js --codex)"| COD["Codex CLI<br/>1 router skill + 55 refs<br/>+ 8 agent TOML"]
+    CC -->|"Step 2: copy + reformat<br/>51 sub-command skills"| COP["Copilot CLI<br/>~/.copilot/skills/"]
+    CC -->|"Step 2b: transform<br/>(install.js --codex)"| COD["Codex CLI<br/>1 router skill + 51 refs<br/>+ 8 agent TOML"]
     CC -->|"Step 3: genericize<br/>(strip personal data)"| REPO["multi-agent-pipeline repo<br/>pipeline/"]
     CC -->|"Step 4: version + feature sync"| WEB["Website<br/>projects.ts / i18n.tsx"]
 
@@ -153,7 +153,7 @@ measurements behind this table):
 
 | | Claude Code | Copilot CLI | Codex CLI |
 |---|---|---|---|
-| **Pipeline commands** | 55 slash-command skills, native | 55 skills, `multi-agent-{cmd}` naming, copied in | 1 router skill (`multi-agent`) + 55 command specs as reference files - Codex silently truncates its skills block past a few dozen entries, so sub-commands are not peer skills here |
+| **Pipeline commands** | 51 slash-command skills, native | 51 skills, `multi-agent-{cmd}` naming, copied in | 1 router skill (`multi-agent`) + 51 command specs as reference files - Codex silently truncates its skills block past a few dozen entries, so sub-commands are not peer skills here |
 | **Stack plugins** | Marketplace plugin, loaded natively, resolved by `.claude/settings.json` enabled-list | Enabled plugin's authored skills copied flat into `~/.copilot/skills/`; `knowledge/` **not** re-copied (already delivered via `shared/external`) | Copied as reference files under `~/.codex/multi-agent-refs/skills/`, plugin-prefixed on name clash (e.g. `architecture` → `ai-ios-toolkit-architecture`) |
 | **Component dispatch (Phase 3)** | Marketplace plugin's `create-component`/`create-screen` skill via the Skill tool | No plugin loader - the enabled stack plugin's authored skills (incl. `create-component`) are copied flat into `~/.copilot/skills/` at install time (the old frozen `figma-*` copies are pruned, they were never a fallback) | Not part of the enforced parity axis; classification + state-shape must match, skill *inventory* does not |
 | **multi-agent-toolkit-mcp** | `claude mcp add multi-agent-toolkit -- npx -y @mmerterden/multi-agent-toolkit-mcp` | `copilot mcp add multi-agent-toolkit -- npx -y @mmerterden/multi-agent-toolkit-mcp` | `codex mcp add multi-agent-toolkit -- npx -y @mmerterden/multi-agent-toolkit-mcp` (skipped with a warning if `codex` isn't on `PATH`) |

package/docs/features.md

@@ -222,6 +222,7 @@ Phase 3 treats the issue-tracker status update as a required step with a post-mu
 ## Safety & Hygiene
 
 - **Pre-Commit Secret Detection** (12 patterns): `PreToolUse` hook scans staged files for API keys/tokens, AWS access keys, private keys, `.env` files, service account JSON. Commit **blocked** if found.
+- **Read-Size Gate** (opt-in, `prefs.global.bulkRead.mode`): a `PreToolUse` hook inspects `Read` and the shell commands that read a file whole. In `observe` it only logs what it would have caught - the baseline you measure before routing anything. In `enforce` a file over `minLines` (default 350) is blocked and delegated to a haiku-rung worker (`bulk-read.sh`), which returns a line-numbered summary so the follow-up is a bounded `Read(offset:limit:)` instead of the whole file; the full text is parked under `.multi-agent/refs/`. The development phase and any file the run has already touched are exempt, because Claude Code's `Edit` requires its own `Read` first.
 - **Build Queue**: All `xcodebuild` calls acquire a lock. Each worktree uses own `-derivedDataPath`. Stale locks auto-clean after 15 min. Non-Xcode builds don't need the lock.
 - **Context Management**: `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=65` - compaction at 65% usage (prevents degradation in 8-phase sessions).
 - **3-Iteration Hard Kill**: Any retry loop stops after 3 attempts, then pauses for user. No infinite loops.

package/install/templates/claude-hooks.json

@@ -1,5 +1,5 @@
 {
-  "_readme": "Recommended Claude Code hooks for multi-agent-pipeline. Merge the `hooks` object into your ~/.claude/settings.json to make these deterministic, OS-enforced PreToolUse gates real (exit 2 blocks the tool call) rather than prompt-level hopes. Two gates ship here: (1) a staged-diff secret scan on git commit (pre-commit-check.sh); (2) an agent-guard on git commit + git push (agent-guard.sh) that blocks AI/assistant attribution in commit messages and force-push to a protected branch (main/master/develop). Both scripts are self-contained, fail-open on internal error, never execute the inspected command, and need no run-specific arguments, which is why they are naturally PreToolUse hooks. The other deterministic gates (evidence, consensus, intent, learnings) take run-specific arguments and are phase-enforced by the pipeline instead. multi-agent:setup offers to merge this block.",
+  "_readme": "Recommended Claude Code hooks for multi-agent-pipeline. Merge the `hooks` object into your ~/.claude/settings.json to make these deterministic, OS-enforced PreToolUse gates real (exit 2 blocks the tool call) rather than prompt-level hopes. Three gates ship here: (1) a staged-diff secret scan on git commit (pre-commit-check.sh); (2) an agent-guard on git commit + git push (agent-guard.sh) that blocks AI/assistant attribution in commit messages and force-push to a protected branch (main/master/develop); (3) a read-size gate on Read and Bash (check-read-size.sh), which inspects Read plus the shell commands that read a file whole (cat/head/tail/sed) and returns immediately for everything else, which routes an oversized read to a cheap worker 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 `prefs.global.bulkRead.mode` is set to observe or enforce - so merging this block changes nothing until you opt in. All three are self-contained, fail-open on internal error, never execute the inspected command, and need no run-specific arguments, which is why they are naturally PreToolUse hooks. The other deterministic gates (evidence, consensus, intent, learnings) take run-specific arguments and are phase-enforced by the pipeline instead. multi-agent:setup offers to merge this block.",
   "hooks": {
     "PreToolUse": [
       {
@@ -29,6 +29,17 @@
             "statusMessage": "Checking push safety..."
           }
         ]
+      },
+      {
+        "matcher": "Read|Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash $HOME/.claude/scripts/check-read-size.sh",
+            "timeout": 10,
+            "statusMessage": "Checking read size..."
+          }
+        ]
       }
     ]
   }

package/install/templates/copilot-instructions.md

@@ -32,7 +32,7 @@
 
 Depth is the question, not a command: Full runs all 8 phases, Short is
 Init -> Dev(Opus) -> Review -> Test -> Commit -> Report. Review is never
-skipped either way. The multi-agent-dev* names were removed in v16.0.0.
+skipped either way.
 
 ## Language axes (en/tr)
 
@@ -111,7 +111,11 @@ or, on machines with Claude Code also installed:
 ## Progress Tracking - required
 
 Every phase boundary MUST call the cross-CLI tracker. The tracker is the single source of truth
-for user-visible phase progress on Copilot CLI (no TaskCreate native UI here). Banner is optional flair.
+for user-visible phase progress on Copilot CLI (no native task widget here). Banner is optional flair.
+
+Copilot CLI has no TaskCreate equivalent, so the bordered card IS the widget - and Copilot
+collapses tool output, so a card left in stdout never reaches the user. **Reprint the card
+inside your reply at every phase boundary.** `phase-tracker.sh tiles` says so and prints it.
 
 ```bash
 # Bootstrap once at Phase 0 start - initialize all 8 phase tiles:
@@ -119,6 +123,7 @@ bash ~/.copilot/scripts/phase-tracker.sh init "$TASK_ID"
 for p in 0:Init 1:Analysis 2:Planning 3:Dev 4:Review 5:Test 6:Commit 7:Report; do
   bash ~/.copilot/scripts/phase-tracker.sh add "${p%%:*}" "${p#*:}"
 done
+bash ~/.copilot/scripts/phase-tracker.sh tiles
 
 # At each phase boundary - update status. Tracker stamps started_at on first
 # transition to in_progress, completed_at on terminal status (completed/failed/skipped).
@@ -129,6 +134,16 @@ done
 bash ~/.copilot/scripts/phase-tracker.sh update <N> in_progress
 bash ~/.copilot/scripts/phase-tracker.sh update <N> completed    # or failed / skipped
 
+# `update <N> completed` EXITS 3 for phases 1-4 when no tokens were recorded for
+# that phase: record model + tokens first, then re-run the same update. A phase
+# that genuinely ran no LLM call completes with `--no-llm`. Each update prints a
+# `-- NEXT (required) --` block naming what to reprint and the narration line.
+
+# At the end of the run, print the closing report (per-phase elapsed, tokens,
+# model, USD, totals) next to the work summary, and reprint both in your reply:
+bash ~/.copilot/scripts/phase-tracker.sh report
+bash ~/.copilot/scripts/render-work-summary.sh "$TASK_ID"
+
 # After every LLM dispatch, record its token cost against the active phase (v5.5.0):
 bash ~/.copilot/scripts/phase-tracker.sh tokens <N> <input_tokens> <output_tokens>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "16.20.0",
+  "version": "16.23.0",
   "description": "8-phase AI development pipeline with full orchestration on Claude Code, Copilot CLI and Codex CLI. Analysis, planning, TDD, CLI-aware parallel review with consensus surfacing + Fable triage, default-FAIL evidence gates, secret + intent guards, per-phase cost ledger, persistent learnings memory, wiki generation, commit automation. Token-preserving uninstall.",
   "type": "module",
   "main": "index.js",

package/pipeline/agents/bulk-reader.md

@@ -0,0 +1,57 @@
+---
+name: bulk-reader
+description: "Reads ONE large file and returns a structured, line-numbered summary so the full text never enters the caller's context. Dispatched by bulk-read.sh when check-read-size.sh blocks a whole-file read. Haiku by default; a delegated read costs a fraction of a cent."
+model: haiku
+preferredModel: haiku
+modelRationale: "Reading a file and reporting what is in it is extraction, not judgement - the task has a single source, a fixed output shape, and no reasoning chain. Haiku is the right rung and the whole point: the saving is the difference between this rung and the caller's. A worker that reasons is the wrong tool here, and the contract below forbids it explicitly, because a cheap rung's opinion about code is worth less than nothing."
+---
+
+# Bulk Reader
+
+You are given ONE file and ONE question. You return ONE JSON object and nothing
+else: no prose before it, no markdown fence around it, no commentary after it.
+
+The file arrives with its lines numbered. Those numbers are the file's own, so a
+number you report is a number the caller can open directly.
+
+## Rules
+
+- **Every claim carries the line numbers it comes from.** A claim without them is
+  not usable - the caller cannot open it, cannot check it, and ends up reading
+  the file itself, having now paid for it twice. If you cannot cite it, do not
+  claim it.
+- **You describe what IS in the file.** You do not review it, do not judge its
+  quality, do not propose changes, and do not name defects. Judgement about code
+  is the caller's; you are here so the caller has something to judge.
+- **You never guess.** If the question cannot be answered from this file, say
+  exactly that in `answer` and return an empty `regions`. A confident wrong
+  summary is the one outcome worse than the caller paying full price for the
+  file, because nothing downstream can tell it is wrong.
+- **`regions` are where a reader should look next**, most important first, at
+  most 8. Each one is a span worth opening on its own - not the whole file
+  restated as one region.
+- If you did not see the whole file, set `truncated: true`. Do not summarize a
+  part as though it were the whole.
+
+## Output Format
+
+```json
+{
+  "answer": "<direct answer to the question, or why this file cannot answer it>",
+  "summary": "<what this file is and does, 3-6 sentences>",
+  "symbols": [{"name": "<declaration>", "kind": "type|func|var|extension|other", "line": 42}],
+  "regions": [{"why": "<what a reader finds here>", "start": 120, "end": 180}],
+  "truncated": false
+}
+```
+
+Contract: `pipeline/schemas/bulk-read-output.schema.json`.
+
+## What this agent does NOT do
+
+- Does NOT review, rate, or critique the code it reads.
+- Does NOT read a second file, follow an import, or look anything up.
+- Does NOT answer from prior knowledge of a framework - only from this file.
+- Does NOT edit anything. It has no write path by design: a summary has no
+  reliable basis for an edit, which is why the caller comes back with a bounded
+  read before changing a line.

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

@@ -91,7 +91,6 @@ Lib scripts (`~/.claude/lib/`):
 | `language [en\|tr]` | Show or set the assistant `outputLanguage` (explanations and chat replies). `promptLanguage` is locked to `en` and is not toggleable. No arg = show current `outputLanguage`. With `en` or `tr` = set and persist `outputLanguage`. External payloads (commits, PR bodies, Jira) stay English. |
 | `setup` | Keychain token + Git Identity onboarding |
 | `--local` | No worktree  -  works directly on local branch |
-| `--dev` and `dev-*` | **Removed in v16.0.0.** Depth is the Phase 0 Step 7.5 question, not a flag. Print the redirect and continue at `/multi-agent` (or `:local`) with Short selected; for the two autopilot names there is no equivalent, so print the stub's two options and stop. |
 | `autopilot` | Skip user confirmations, auto commit/PR |
 | No args / `help` | Show usage guide |
 
@@ -124,10 +123,6 @@ This command uses lazy loading for token efficiency. Read the relevant sub-file
 | `build-optimize` | `$HOME/.claude/commands/multi-agent/build-optimize/SKILL.md` |
 | `local` | `$HOME/.claude/commands/multi-agent/local/SKILL.md` |
 | `local-autopilot` | `$HOME/.claude/commands/multi-agent/local-autopilot/SKILL.md` |
-| `dev` | `$HOME/.claude/commands/multi-agent/dev/SKILL.md` |
-| `dev-autopilot` | `$HOME/.claude/commands/multi-agent/dev-autopilot/SKILL.md` |
-| `dev-local` | `$HOME/.claude/commands/multi-agent/dev-local/SKILL.md` |
-| `dev-local-autopilot` | `$HOME/.claude/commands/multi-agent/dev-local-autopilot/SKILL.md` |
 | `create-jira` | `$HOME/.claude/commands/multi-agent/create-jira/SKILL.md` (loads `$HOME/.claude/multi-agent-refs/generate-issue.md`) |
 | `stack` | `$HOME/.claude/commands/multi-agent/stack/SKILL.md` |
 | `language` | Handled inline  -  set/show prompt language in preferences |

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

@@ -95,11 +95,6 @@ Four pipeline entries:
 
   /multi-agent:resume-local [jira-id] [autopilot]     Continue already-done LOCAL work: Review → Build+Test → PR → Jira analysis + test scenarios (no dev)
 
-Removed in v16.0.0:
-  :dev -> /multi-agent + Short · :dev-local -> :local + Short
-  :dev-autopilot and :dev-local-autopilot have no equivalent  -  fast plus
-  unattended is gone; pick unattended-and-Full or fast-and-attended.
-
 ------------------------------------------------------------
 
 Status & Resume:
@@ -372,11 +367,6 @@ Dört pipeline girişi:
 
   /multi-agent:resume-local [jira-id] [autopilot]     Lokalde biten işi sürdür: Review → Build+Test → PR → Jira teknik analiz + test senaryoları (dev yok)
 
-v16.0.0'da kaldırılanlar:
-  :dev -> /multi-agent + Kısa · :dev-local -> :local + Kısa
-  :dev-autopilot ve :dev-local-autopilot'un karşılığı yok  -  hızlı+gözetimsiz
-  bitti; ya gözetimsiz-ve-Tam ya hızlı-ve-insan-başında seçilir.
-
 ------------------------------------------------------------
 
 Status & Resume:

package/pipeline/commands/multi-agent/ios-coding-standard/SKILL.md

@@ -1,6 +1,6 @@
 ---
-description: "Audit an iOS module against the shared coding-standard registry (99 stable-ID rules), produce a remediation plan, then hand off to dev/dev-local. Use for a standards pass on a module, or when a review needs rule IDs rather than opinions."
-description-tr: "Bir iOS modulunu paylasilan kodlama-standardi registry'sine (99 sabit-ID kural) gore denetler, duzeltme plani cikarir, sonra dev/dev-local'e devreder. Bir modulde standart gecisi icin, ya da bir review'un gorus yerine kural ID'si istedigi durumda kullan."
+description: "Audit an iOS module against the shared coding-standard registry (99 stable-ID rules), produce a remediation plan, then hand off to /multi-agent or :local. Use for a standards pass on a module, or when a review needs rule IDs rather than opinions."
+description-tr: "Bir iOS modulunu paylasilan kodlama-standardi registry'sine (99 sabit-ID kural) gore denetler, duzeltme plani cikarir, sonra /multi-agent veya :local'e devreder. Bir modulde standart gecisi icin, ya da bir review'un gorus yerine kural ID'si istedigi durumda kullan."
 argument-hint: "[module name or path]"
 allowed-tools: Skill, Bash, Read, Edit, Write, AskUserQuestion
 ---

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

@@ -67,7 +67,7 @@ Depth is a separate axis, asked at Phase 0 Step 7.5 rather than encoded in the c
 
 ## Delegation
 
-Orchestrator routing: the routing table in `$HOME/.claude/commands/multi-agent/SKILL.md` resolves `local-autopilot` as the union of the `dev-local` + `autopilot` mode mixins. Contract details: `$HOME/.claude/multi-agent-refs/phases/phase-0-init.md` Step 6 (local branch) + `$HOME/.claude/multi-agent-refs/phases/phase-2-planning.md` Step 5 (autopilot gate skip + safety classifier).
+Orchestrator routing: the routing table in `$HOME/.claude/commands/multi-agent/SKILL.md` resolves `local-autopilot` as the union of the `local` + `autopilot` mode mixins. Contract details: `$HOME/.claude/multi-agent-refs/phases/phase-0-init.md` Step 6 (local branch) + `$HOME/.claude/multi-agent-refs/phases/phase-2-planning.md` Step 5 (autopilot gate skip + safety classifier).
 ## Required: outward-facing payload contracts
 
 Before writing anything outward-facing  -  PR body, Jira comment, Confluence page, closing report  -  load `$HOME/.claude/multi-agent-refs/payload-contracts.md`. It names the canonical section set for each payload, the markup dialect per surface (PR body is Markdown, Jira is wiki markup  -  mixing them is a defect), and the token/duration numbers the closing report must carry. Improvising a payload shape from memory is the most common failure of the short modes.

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

@@ -12,7 +12,7 @@ You already did the work locally  -  wrote code on the current branch and maybe
 
 ## When to use it
 
-- You ran `dev-local` / `local` (which skip Review + Test) and now want the full quality tail on the same branch.
+- You ran `:local` and answered Short (which skips Review + Test) and now want the full quality tail on the same branch.
 - You hand-coded or hand-tested a change and want review + build/test + PR + Jira write-up without re-running dev.
 - You want the "reviewed, built, tested, PR'd, documented on Jira" finish with a single command.
 
@@ -47,7 +47,7 @@ Phases 1-3 (Analysis / Planning / Dev) are skipped by design  -  `ship` treats t
 1. **Project + branch:** detect project (cwd), current branch (`git branch --show-current`). No worktree; work stays on the current branch.
 2. **Base + diff:** resolve base branch in order: `--base <arg>` → `figma-config.project.baseBranch` → `develop` → the branch's upstream/merge-base. The **work under review** is `git diff <base>...HEAD` PLUS uncommitted working-tree changes (`git status`). Abort with a clear message if the diff is empty (`ERR: no local work to finish on <branch> vs <base>`).
 3. **Task binding:** Jira id from the `--`/positional arg, else parse the branch name (`bugfix/PROJ-XXXX` / `feature/PROJ-XXXX`); `taskType` inferred from the diff (bugfix/feature/refactor/chore) for the report wording. GitHub issue `#N` from branch/arg when present.
-4. **Prior state (optional):** if an `agent-state.json` / tracker-state exists for this branch (left by a prior `dev-local`/`local` run), load its analysis summary + Jira/issue binding to enrich the report; otherwise synthesize a minimal state over the diff. Never require a prior full-pipeline run.
+4. **Prior state (optional):** if an `agent-state.json` / tracker-state exists for this branch (left by a prior `:local` run), load its analysis summary + Jira/issue binding to enrich the report; otherwise synthesize a minimal state over the diff. Never require a prior full-pipeline run.
 5. Persist state under `.claude/logs/multi-agent/{project}/{taskId}/` (same as `--local`).
 
 ## Phase execution (reuse the existing phase contracts)

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

@@ -813,13 +813,15 @@ 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 hook (optional, Claude Code)
+### Step 8  -  Enforcement hooks (optional, Claude Code)
 
-Offer to make the secret scan a HARD pre-commit gate (a non-zero exit blocks the commit) instead of an advisory step. The recommended block ships at `install/templates/claude-hooks.json`.
+Offer to make the three hookable gates HARD (a non-zero exit blocks the tool call). The block ships at `install/templates/claude-hooks.json`: secret scan, agent-guard, read-size gate.
+
+- Ask (picker): "Install the pipeline's PreToolUse gates into `~/.claude/settings.json`?" Default Yes.
+- On Yes, deep-merge the template's `hooks.PreToolUse` (preserve existing hooks; never duplicate a matcher already calling the same script).
+- Say what the merge does NOT cover: only these three need no run-specific arguments, so only these three 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`.
 
-- Ask (picker): "Install the pre-commit secret-scan hook into `~/.claude/settings.json`?" Default Yes.
-- On Yes, deep-merge the template's `hooks.PreToolUse` into the user's `settings.json` (preserve any existing hooks; do not duplicate a matcher that already calls `pre-commit-check.sh`).
-- Honest note to show: this is the only deterministic gate that is OS-enforceable as a hook (it needs no run-specific arguments). The evidence / consensus / intent / learnings gates are invoked by the pipeline phases with per-run arguments, so they are enforced by the phase contract + the installed gate scripts, not by a hook.
 ### Step 9  -  Default stack plugin enablement
 
 Stack skills ship as versioned plugins in the `{owner}/multi-agent-plugins` marketplace. On first setup, wire the stack so the pipeline works out of the box.

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

@@ -59,8 +59,8 @@ Run every step automatically:
 ```
 Step 1: PLATFORM    Detect macOS / Linux / Windows (Git Bash / WSL); export PLATFORM env
 Step 1.5: DETECT    Compare timestamps, find stale targets
-Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 55 sub-command skills)
-Step 2b: CODEX      Claude Code -> Codex CLI (1 router skill + 55 specs as refs + 8 agent TOML)
+Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 51 sub-command skills)
+Step 2b: CODEX      Claude Code -> Codex CLI (1 router skill + 51 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)
@@ -166,7 +166,7 @@ If nothing is stale → report "All targets up to date" and stop.
 Unlike the Copilot step, this one does **not** hand-copy files. The Codex tree is a
 *transform* of the Claude tree, not a mirror of it, and the transform is real work:
 
-- the 55 sub-command specs become reference files, because Codex silently truncates
+- the 51 sub-command specs become reference files, because Codex silently truncates
   its skills block (see `cross-cli-contract.md` 2.6 for the measurement)
 - every `$HOME/.claude/...` reference to a CLI-owned tree is retargeted, with
   `agents/<persona>.md` becoming `.toml` and the dispatcher becoming the router skill
@@ -480,25 +480,25 @@ When invoked with the `release` argument:
 ## Sub-Command Sync (Claude Code <-> Copilot CLI Skills)
 
 This runs on the Claude <-> Copilot axis. Codex is NOT synced here: it receives the
-same 55 specs as reference files rather than as peer skills, via Step 2b -  see
+same 51 specs as reference files rather than as peer skills, via Step 2b -  see
 `cross-cli-contract.md` 2.6 for why the parity axis differs per host.
 
 | Claude Code | Copilot CLI |
 |-------------|-------------|
 | `~/.claude/commands/multi-agent/{cmd}/SKILL.md` | `~/.copilot/skills/multi-agent-{cmd}/SKILL.md` |
 
-**55 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
+**51 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
 
 ```
 analysis, analysis-resolve, autopilot, build-optimize, channels,
-complaint-analysis, create-jira, design-check, dev, dev-autopilot, dev-local,
-dev-local-autopilot, diff-explain, 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
+complaint-analysis, create-jira, design-check, diff-explain, 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
 ```
 
 **NOT synced**: `$HOME/.claude/multi-agent-refs/*`  -  lazy-load references, Claude Code specific

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

@@ -6,18 +6,18 @@
 
 ---
 
-## 1. Command Inventory (55 files, 51 live commands)
+## 1. Command Inventory (51 commands)
 
 ```
 analysis, analysis-resolve, autopilot, build-optimize, channels,
-complaint-analysis, create-jira, design-check, dev, dev-autopilot, dev-local,
-dev-local-autopilot, diff-explain, 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
+complaint-analysis, create-jira, design-check, diff-explain, 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
 ```
 
 Categories:
@@ -25,15 +25,12 @@ Categories:
 - **Interactive pickers** (single-purpose, not modes): `jira`, `issue`
 - **Issue generator** (one-shot, no worktree, asks type Task/Bug/Story, hard approval gate before create): `create-jira`
 - **Pipeline entries**: `autopilot`, `local`, `local-autopilot` (plus the bare `/multi-agent` in the dispatcher). Depth is not a command: `/multi-agent` and `local` ask Full or Short at Phase 0 Step 7.5; the two autopilot entries never ask and always run Full.
-- **Retired stubs** (v16.0.0, deleted next minor  -  they print a redirect and run no phase): `dev`, `dev-local` redirect to the picker entries with Short; `dev-autopilot`, `dev-local-autopilot` have no equivalent, because fast-plus-unattended no longer exists
 - **Tail modes** (run the pipeline tail over already-done local work): `resume-local`
 - **Ops commands** (one-shot, no worktree): `status`, `log`, `kill`, `steer`, `purge`, `uninstall`, `resume`, `review`, `review-jira`, `review-issue`, `analysis`, `analysis-resolve`, `complaint-analysis`, `build-optimize`, `channels`, `scan`, `search`, `diff-explain`, `garbage-collect`, `graph`, `prune-logs`, `prune-prompts`
 - **Local audits** (worktree only to build; no commit, push, PR or channels): `design-check`, `testflight-validation`, `ios-coding-standard`. `testflight-validation` additionally never invokes `altool --upload-app`  -  a validation run must not be able to ship a build by accident.
 - **Meta-ops**: `setup`, `sync`, `update`, `help`, `refactor`, `test`, `stack`, `manual-test`, `language`
 - **Routines** (user-defined routine registry; the routines they create are local-only and never synced): `save`, `routines`, `forget`
 
-The count is 55 files and 51 live commands until the four stubs are deleted, at which point both numbers become 51. A stub is still installed and still invocable, so counting it as absent would be wrong; counting it as a command would be worse.
-
 > **Inventory drift is a contract violation.** Adding a slash command under `pipeline/commands/multi-agent/` without updating this list + its counterpart Copilot dir (`pipeline/skills/shared/core/multi-agent-<cmd>/`) is a merge blocker. `smoke-commands-skills-parity.sh` enforces command ↔ skill directory parity; `smoke-cross-cli-behavior.sh` enforces behavior parity. This doc is the authoritative command list  -  bump the count + table together.
 
 ### 1.1 Figma / component work (plugin-based on Claude Code; NOT parity-enforced)
@@ -244,6 +241,7 @@ argument-hint: "<input hint>"
 
 | Concept | Claude Code | Copilot CLI | Codex CLI |
 |---|---|---|---|
+| Print the registration calls | `phase-tracker.sh tiles` (emits the TaskCreate list) | `phase-tracker.sh tiles` (emits the reprint instruction) | `phase-tracker.sh tiles` (emits the update_plan payload) |
 | Register a phase | `TaskCreate` tool call with subject/description | `phase-tracker.sh add <N> <name>` | `update_plan` step, `status: pending` |
 | Mark a phase in-progress | `TaskUpdate` → `in_progress` | `phase-tracker.sh update <N> in_progress` | `update_plan` step → `in_progress` |
 | Mark a phase complete | `TaskUpdate` → `completed` | `phase-tracker.sh update <N> completed` | `update_plan` step → `completed` |

package/pipeline/multi-agent-refs/phases/modes.md

@@ -73,7 +73,7 @@ Bu is icin hangi pipeline? / Which pipeline for this task?
 
 **Who is asked.** `/multi-agent` and `/multi-agent:local`. Both autopilot entries always run Full without asking.
 
-**Why there is no fast-and-unattended combination.** It existed until v16.0.0 as `--dev autopilot`, and removing it is a real behaviour change, not a rename. Autopilot may not ask, so something has to choose, and unattended is the worst place to drop analysis and planning: nobody is watching to notice what the shortcut lost. A cron job or script that called `dev-autopilot` now has to pick - stay unattended and pay for the full pipeline, or stay fast and have a person present.
+**Why there is no fast-and-unattended combination.** It existed until v16.0.0, and removing it was a real behaviour change, not a rename. Autopilot may not ask, so something has to choose, and unattended is the worst place to drop analysis and planning: nobody is watching to notice what the shortcut lost. A cron job or script that wants both now has to pick - stay unattended and pay for the full pipeline, or stay fast and have a person present.
 
 **Pipeline in a Short run:**
 

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

@@ -12,16 +12,21 @@ $HOME/.claude/scripts/phase-tracker.sh init "$TASK_ID"
 for p in 0:Init 1:Analysis 2:Planning 3:Dev 4:Review 5:Test 6:Commit 7:Report; do
   $HOME/.claude/scripts/phase-tracker.sh add "${p%%:*}" "${p#*:}"
 done
+$HOME/.claude/scripts/phase-tracker.sh tiles
 $HOME/.claude/scripts/phase-tracker.sh update 0 in_progress
 ```
 
+`tiles` prints this host's widget-registration calls: **make them before continuing.** The card alone lands in collapsed tool output, so a run that skips them runs in silence. Contract: `tracker-contract.md`, "The card is not the widget".
+
 If `INPUT_TASK_ID` isn't known yet (free-text, project not selected), use a placeholder; rename later via `mv` once parsed in Step 1.
 
-Every subsequent phase (1-7) MUST call `phase-tracker.sh update <N> in_progress` on entry and `phase-tracker.sh update <N> completed|failed|skipped` on exit. Sub-phase milestones use `phase-tracker.sh sub <N> <subN> "<name>" <status>`. See `$HOME/.claude/multi-agent-refs/phases.md` "Visual Phase Tracker" for the full contract.
+Every subsequent phase (1-7) MUST call `phase-tracker.sh update <N> in_progress` on entry and `phase-tracker.sh update <N> completed|failed|skipped` on exit. Each `update` prints a `-- NEXT (required) --` block: act on it. Sub-phase milestones use `phase-tracker.sh sub <N> <subN> "<name>" <status>`. See `$HOME/.claude/multi-agent-refs/phases.md` "Visual Phase Tracker" for the full contract.
+
+`update <N> completed` **exits 3** for phases 1-4 with no recorded spend: record `model` + `tokens`, or pass `--no-llm`, then re-run it. Contract: `tracker-contract.md`, "Accounting is a gate".
 
 ##### TaskCreate ordering on Claude Code (strict)
 
-On Claude Code, fire all `TaskCreate` calls in strict phase-number order (0 → 7) BEFORE any `TaskUpdate`. Full contract: `$HOME/.claude/multi-agent-refs/tracker-contract.md` section "TaskCreate ordering (strict)".
+On Claude Code, fire all `TaskCreate` calls in strict phase-number order (0 → 7) BEFORE any `TaskUpdate` - which is the order `tiles` prints them in. Full contract: `$HOME/.claude/multi-agent-refs/tracker-contract.md` section "TaskCreate ordering (strict)".
 
 ---
 

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

@@ -298,7 +298,7 @@ Set by the Phase 0 Step 7.5 depth picker, or by autopilot never (autopilot alway
 
 Because the agent determines its own scope here, Phase 4 is the only place that checks the result against anything external. Record every skill, plugin skill and guide consulted during this phase into `state.telemetry.skillCalls[]` with the files it was applied to  -  Phase 4 resolves the criteria set independently, and this record is what lets it tell "applied and honoured" from "never opened".
 
-**Never combined with autopilot.** Autopilot skips the depth question and runs Full, so `onlyDevelop` is false in every unattended run. "Fast plus unattended" was `--dev autopilot` until v16.0.0 and no longer exists: something has to choose when nobody is asked, and unattended is the worst place to drop analysis and planning.
+**Never combined with autopilot.** Autopilot skips the depth question and runs Full, so `onlyDevelop` is false in every unattended run. "Fast plus unattended" was removed in v16.0.0 and no longer exists: something has to choose when nobody is asked, and unattended is the worst place to drop analysis and planning.
 
 **Tracker visibility during Opus dispatch**: on Claude Code the model switch to Opus happens via subagent dispatch, and the parent widget cannot move while an Agent call is in flight. Dispatch per task from the self-generated task list (never one monolithic call for the whole phase), set the pre-dispatch `activeForm` marker, and record tokens between chunks  -  full rules in `$HOME/.claude/multi-agent-refs/tracker-contract.md` section "Delegated phases".
 

package/pipeline/multi-agent-refs/phases/phase-7-report.md

@@ -251,7 +251,14 @@ fi
 
 The ledger is JSONL at `~/.claude/memory/multi-agent/<repo-slug>/learnings-ledger.jsonl`, next to the triage corpus, per-repo isolated. Its brief is replayed into Phase 1 analysis and Phase 4 triage on future runs.
 
-Print compact summary to terminal:
+Print the closing report to the terminal. Two blocks, in this order  -  what the pipeline spent, then what it changed:
+
+```bash
+bash $HOME/.claude/scripts/phase-tracker.sh report
+bash $HOME/.claude/scripts/render-work-summary.sh "$TASK_ID" --worktree "$WORKTREE_PATH"
+```
+
+`report` prices the run phase by phase; `render-work-summary.sh` says what changed on disk. Both land in tool output, which the host collapses, so **reprint them in your reply** followed by this line:
 
 ```
 {jiraId} complete

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

@@ -81,6 +81,6 @@ In autopilot, `ask_choice` resolves to `default` (or the safe first option) with
 
 ## Deterministic gates note
 
-Claude Code's `PreToolUse` exit-2 hooks are the HARD blocking gates. Two ship, both needing no 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). Both are self-contained, fail-open on internal error, and never execute the inspected command. 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, fail-open on internal error, and never execute the inspected command. 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.