@mmerterden/multi-agent-pipeline 16.19.0 → 16.20.0

package/CHANGELOG.md

@@ -16,6 +16,29 @@ Internal file-layout changes that don't affect the slash-command surface are sti
 
 ## [Unreleased]
 
+## [16.20.0] - 2026-09-07
+
+A comparison against `msitarzewski/agency-agents`, a 150k-star persona catalog, found nothing to copy wholesale and three things to fix: the personas were never registered, the circuit-breaker was prose, and a review finding had no identity from one round to the next. This release gives findings that identity and builds the loop controls, the handoff records and the evidence rules on top of it.
+
+### Added
+
+- **A finding keeps its identity across review rounds.** `finding-fingerprint.mjs` stamps every reviewer, triage and dev-critic finding with `F:xxxxxxxx`, computed from the file and either the cited rule ID or the normalised issue text; the line, the severity and the fix text take no part, so a finding whose line moved after the fix is still the same finding. `review-delta.mjs` compares one round's triage with the previous one and reports `stillPresent`, `resolved`, `downgraded` and `new`, plus how many consecutive rework cycles each survivor has lasted. Phase 4 keeps one `.pipeline/triage-round-<N>.json` per round, injects the previous round's accepted findings into the shared reviewer prefix so reviewers echo instead of rediscover, and stores the delta in `state.reviewIterations[i].delta`. The Phase 3 reflection prompt puts the survivors first, marked `STILL PRESENT`.
+- **The circuit-breaker has two triggers in code.** Trigger 2 (a blocking or important finding that survives `identicalFindingCycles` consecutive rework cycles, default 2) fires from `review-delta.mjs` exit 3 at Phase 4 Step 3.8; trigger 3 (the rework cap) is recorded by the Phase 3 re-entry. Both write `state.circuitBreaker` and halt visibly in autopilot; interactive modes show the survivors and ask. `prefs.global.autopilotCircuitBreaker` and `state.circuitBreaker` now exist in the schemas the feature doc had been naming, `resume` clears the trip, and `smoke-autopilot-circuit-breaker` asserts the schema fields, the scripts and the phase wiring instead of grepping the prose.
+- **Dev states its scope before review reads it.** Phase 3 Step 3.7 writes `.pipeline/scope-check.json`: a reason per touched file, the changes deliberately not made, and the code-simplifier rationales that used to be discarded. `scope-check-gate.mjs` compares it with the real diff; Phase 4 renders it as `<scope-self-check>` so reviewers judge against the stated scope and do not re-propose what was rejected; Phase 6 builds the PR `Changes` bullets and a "Follow-ups not done in this PR" list from it.
+- **PR bodies carry a risk section when the diff earns one.** `channels/pr.md` gains the conditional `## Risk and Security` section (auth flow touched, secret handling changed, data migration, rollback), required whenever `state.diffRisk.signals` carries a high-stakes signal. Phase 4 now persists the diff-risk totals to `state.diffRisk`, and `run-metrics.mjs` reports `diff.filesTouched`, `locAdded`, `locRemoved` and the cross-round delta.
+- **Manual test results are evidence, not a chat reply.** Phase 5 writes `.pipeline/manual-test.json` with one row per acceptance criterion (the quoted spec, the observation, the verdict, the screenshot) and `evidence-gate.mjs --claim manual` refuses an "ok" whose criteria are missing, failed or untested without a reason. The simulator UI report pairs every bug with its spec quote and its before/after captures and ends with a production-readiness verdict that defaults to FAILED.
+- **One green run is not proof.** Verify-by-test re-runs a passing repro test `verifyByTest.repeatCount` times (default 3) before it may downgrade a blocking finding; a run that disagrees makes the verdict `inconclusive` with a `flaky` note. Phase 3 runs every new or changed test `testStability.repeatCount` times (default 3) and records `test.flake_signal` when outcomes disagree: a test that passes only on retry is a flake signal, not a pass.
+- **Persona files round-trip and store readiness asks about symbols and rollout.** `lint-personas.mjs` checks every persona's frontmatter, its `## Output Format` section, and that the Codex TOML rendered from it decodes back to the same description and body byte for byte; the renderer no longer appends a newline the source did not have. The smokes that hardcoded six persona names now derive the list from the directory. `store-ready` flags an archive without dSYMs (or a minified bundle without `mapping.txt`) as blocking, checks that a symbol upload step exists, and ends the report with the phased-rollout thresholds and the rollback owner a release needs written down.
+
+### Changed
+
+- **Token budgets: phase-4-review max 14750 -> 15150, total 58250 -> 60250.** The full contracts for the review delta and the scope self-check live in `multi-agent-refs/features/review-delta.md` and `features/scope-check.md`, outside the budget; the phase docs carry the call, the pref and the exit table, and were compressed twice before the numbers moved. `rules.md` was tightened by 150 bytes to keep the fixed per-run load under its 60000-byte ceiling. Reasoning in `schemas/token-budget.json`.
+
+### Fixed
+
+- **Phase 4 and Phase 7 disagreed on the triage file name.** Phase 4 wrote `.pipeline/triage.json`; Phase 7, `worktree-finalize.sh`, `render-work-summary.sh` and `diff-explain.mjs` read `triage-output.json`. The salvage step bridged it only when the worktree was removed, and everywhere else the triage corpus and the learnings ledger silently stopped being fed. Phase 4 now copies the latest round to `triage-output.json` itself.
+- **The eight personas were never registered as subagents.** `pipeline/agents/*.md` carried `description`, `model`, `preferredModel` and `modelRationale` but no `name:`, and Claude Code drops a subagent file without one silently: no error, no agent. Every `subagent_type: "code-reviewer"`, `"ios-architect"`, `"security-auditor"`, `"dev-critic"` and `"task-clarifier"` dispatch in the phase docs named an agent the host did not have. Each persona now declares `name:` equal to its filename stem, and `smoke-agent-model-routing` fails when a persona lacks it, when the name differs from the stem, or when it is not lowercase kebab-case. Found while comparing the persona format against `msitarzewski/agency-agents`, whose linter treats `name` as a required field.
+
 ## [16.19.0] - 2026-09-02
 
 A review of the three repositories together (pipeline, toolkit MCP, plugin marketplace) with every test suite green found the defects the suites could not see. This release fixes what was found in the pipeline; `@mmerterden/multi-agent-toolkit-mcp` 3.8.0 and the marketplace plugins carry their own halves.

package/install/_codex-agents.mjs

@@ -94,10 +94,10 @@ export function tomlString(s) {
     return JSON.stringify(s);
   }
   if (!s.includes("'''")) {
-    return `'''\n${s}\n'''`;
+    return `'''\n${s}'''`;
   }
   const escaped = s.replace(/\\/g, "\\\\").replace(/"""/g, '\\"\\"\\"');
-  return `"""\n${escaped}\n"""`;
+  return `"""\n${escaped}"""`;
 }
 
 /**

package/install/_dev-only-files.mjs

@@ -59,6 +59,7 @@ const DEV_ONLY_TOOLING = Object.freeze([
   "run-smokes.mjs",
   "scorecard.mjs",
   "lint-skills.mjs",
+  "lint-personas.mjs", // imports install/_codex-agents.mjs, which never ships to scripts/
   "lint-mcp-refs.mjs",
   "check-md-links.mjs",
   "validate-schemas.mjs", // validates the repo's own schema files, needs ajv

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmerterden/multi-agent-pipeline",
-  "version": "16.19.0",
+  "version": "16.20.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",
@@ -14,11 +14,11 @@
   },
   "scripts": {
     "start": "node index.js",
-    "test": "npm run format:check && node --test test/*.test.mjs && node pipeline/scripts/run-smokes.mjs && node pipeline/scripts/lint-skills.mjs && node pipeline/scripts/lint-mcp-refs.mjs && node pipeline/scripts/eval-triage.mjs && node pipeline/scripts/eval-golden-tasks.mjs && node pipeline/scripts/eval-intent.mjs && node pipeline/scripts/eval-recall.mjs && node pipeline/scripts/validate-schemas.mjs && node pipeline/scripts/validate-prefs.mjs && node pipeline/scripts/scorecard.mjs",
+    "test": "npm run format:check && node --test test/*.test.mjs && node pipeline/scripts/run-smokes.mjs && node pipeline/scripts/lint-skills.mjs && node pipeline/scripts/lint-personas.mjs && node pipeline/scripts/lint-mcp-refs.mjs && node pipeline/scripts/eval-triage.mjs && node pipeline/scripts/eval-golden-tasks.mjs && node pipeline/scripts/eval-intent.mjs && node pipeline/scripts/eval-recall.mjs && node pipeline/scripts/validate-schemas.mjs && node pipeline/scripts/validate-prefs.mjs && node pipeline/scripts/scorecard.mjs",
     "test:unit": "node --test test/*.test.mjs",
     "test:smoke": "node pipeline/scripts/run-smokes.mjs",
     "lint:skills": "node pipeline/scripts/lint-skills.mjs",
-    "test:quick": "node --test test/*.test.mjs && node pipeline/scripts/lint-skills.mjs && node pipeline/scripts/lint-mcp-refs.mjs",
+    "test:quick": "node --test test/*.test.mjs && node pipeline/scripts/lint-skills.mjs && node pipeline/scripts/lint-personas.mjs && node pipeline/scripts/lint-mcp-refs.mjs",
     "test:coverage": "c8 --clean --reporter=none node --test test/*.test.mjs && c8 --clean=false --check-coverage --reporter=text --reporter=lcov node pipeline/scripts/run-smokes.mjs",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
@@ -85,6 +85,7 @@
     "!pipeline/scripts/eval-*.mjs",
     "!pipeline/scripts/scorecard.mjs",
     "!pipeline/scripts/lint-skills.mjs",
+    "!pipeline/scripts/lint-personas.mjs",
     "!pipeline/scripts/lint-mcp-refs.mjs",
     "!pipeline/scripts/check-md-links.mjs",
     "!pipeline/scripts/validate-schemas.mjs",

package/pipeline/agents/android-architect.md

@@ -1,4 +1,5 @@
 ---
+name: android-architect
 description: Android architect  -  evaluates design decisions, patterns, and module structure
 model: fable
 preferredModel: fable

package/pipeline/agents/backend-architect.md

@@ -1,4 +1,5 @@
 ---
+name: backend-architect
 description: Backend architect  -  evaluates API design, data modeling, and system architecture
 model: fable
 preferredModel: fable

package/pipeline/agents/code-reviewer.md

@@ -1,4 +1,5 @@
 ---
+name: code-reviewer
 description: "Code reviewer for multi-agent Phase 4  -  security, architecture, quality, performance. Default model is fable (opus is the first fallback); Phase 4 orchestrator overrides to sonnet for Reviewer 3."
 model: fable
 preferredModel: fable

package/pipeline/agents/dev-critic.md

@@ -1,4 +1,5 @@
 ---
+name: dev-critic
 description: "Phase 3.5 evaluator  -  runs after Dev's last edit, before Phase 4. Verifies build/test/checklist gates; returns pass | fix-list. Sonnet by default; Phase 3 orchestrator may override."
 model: sonnet
 preferredModel: sonnet
@@ -79,7 +80,7 @@ Apply the platform checklist verbatim. **Cite the rule file + line/section** so
 - **Max 2 critic iterations.** Generator gets feedback, edits, you re-evaluate. If round 2 still fails gates, **escalate**: return `escalate: true` and let the orchestrator decide (pause user / abort / continue with known failures).
 - Round 1 budget: full critic pass with all gates + checklist.
 - Round 2 budget: ONLY re-check the items that failed round 1. Don't re-flag what the generator fixed.
-- Never add new findings in round 2 that weren't in round 1's output  -  that's scope creep, not iteration.
+- Never add new findings in round 2 that weren't in round 1's output  -  that's scope creep, not iteration. Round-2 findings carry the round-1 `fingerprint` (`finding-fingerprint.mjs annotate --kind dev-critic`); a round-2 finding with no round-1 fingerprint is the scope creep this rule forbids.
 
 ## Output Format
 

package/pipeline/agents/explorer.md

@@ -1,4 +1,5 @@
 ---
+name: explorer
 description: "Codebase explorer agent for multi-agent Phase 1  -  scans project structure, patterns, and impact areas"
 model: sonnet
 preferredModel: sonnet

package/pipeline/agents/ios-architect.md

@@ -1,4 +1,5 @@
 ---
+name: ios-architect
 description: iOS architect  -  evaluates design decisions, patterns, and module structure
 model: fable
 preferredModel: fable

package/pipeline/agents/security-auditor.md

@@ -1,4 +1,5 @@
 ---
+name: security-auditor
 description: Security specialist  -  analyzes code for vulnerabilities and compliance issues
 model: opus
 preferredModel: opus

package/pipeline/agents/task-clarifier.md

@@ -1,4 +1,5 @@
 ---
+name: task-clarifier
 description: "Phase 0 Step 9 task ambiguity scorer  -  reads task description, emits clarity score (0-10) and up to N clarifying questions. Haiku by default; cost stays under 1¢ per call."
 model: haiku
 preferredModel: haiku

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

@@ -47,5 +47,9 @@ Lets you switch to the task branch for manual testing in Xcode before the PR is
 5. **Wait for the user's reply**
 
 6. **Branch on the answer**:
-   - **OK** → `phase-tracker.sh update 5 completed` + `phase-tracker.sh meta 5 Result "local test passed (user)"`, recreate the worktree, continue to Phase 6
+   - **OK** → first write `$WORKTREE/.pipeline/manual-test.json` (one entry per acceptance criterion from the analysis doc test plan, the plan tasks, or the user's own words):
+     ```json
+     {"criteria":[{"spec":"<quote>","source":"analysis 15.2 | plan task 3 | user","observed":"<what was seen>","verdict":"pass|fail|not-tested","reason":"<required when not-tested>","screenshot":"<path or null>"}],"verdict":"passed|failed"}
+     ```
+     then run `node $HOME/.claude/scripts/evidence-gate.mjs --claim manual --status passed --evidence "$WORKTREE/.pipeline/manual-test.json"`. Exit 1 means the "ok" is not accepted: name the criterion that is missing evidence and wait for the next reply. Exit 0 → `phase-tracker.sh update 5 completed` + `phase-tracker.sh meta 5 Result "local test passed (user)"`, recreate the worktree, continue to Phase 6. Full contract: `$HOME/.claude/multi-agent-refs/phases/phase-5-test.md` step 5.
    - **Fix needed** → `phase-tracker.sh now 5 "applying fix: <summary>"`, recreate the worktree, apply the fix

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

@@ -23,6 +23,7 @@ Resume a paused or failed task from the last successful phase.
    - `currentPhase`  -  last completed phase
    - `status`  -  `paused` | `failed` | `in_progress`
    - `haltReason`  -  if set, show it so the user knows why the run stopped; clear it on successful re-entry
+   - `circuitBreaker`  -  if `tripped`, show `trigger` + `detail`, then set `tripped: false` and keep `counters`; if the same trigger fires again at the next checkpoint the breaker re-trips (no silent bypass)
    - `autopilot`  -  preserve the mode
 
 3. **Load context**  -  rebuild working context from durable artifacts, never from conversation memory:

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

@@ -218,10 +218,22 @@ is a guess the user must be able to correct.
   Use the fallback only when the tool is genuinely absent, and say in the report
   which path ran  -  a rule set that silently differed between two invocations is
   worse than a missing gate.
+
+  Then, whichever path ran, count `<archive>/dSYMs/*.dSYM`. Zero is a blocking
+  finding: `[SYMBOLS] archive carries no dSYM; crash reports will not symbolicate`,
+  with the hint `DEBUG_INFORMATION_FORMAT = dwarf-with-dsym` for the Release
+  configuration. This check runs from the package alone and does not need the
+  MCP tool.
 - **Android**: `android_apk_audit` on the artifact, plus the
   `google-play-compliance` skill's 21 rules  -  `bundletool validate` and manifest
   dump, `aapt2 dump badging`, `apksigner verify`, ABI / native scan.
 
+  Then, when the module has `minifyEnabled true` and the bundle build produced no
+  `mapping.txt`, raise the same class of blocking finding:
+  `[SYMBOLS] minified bundle carries no mapping.txt; crash reports will not
+  deobfuscate`. This check reads the module config and the build output alone
+  and does not need the MCP tool.
+
 `error` findings are blocking; `warning` is advisory. Group by severity and keep
 each finding's ITMS / Play policy code  -  Gate 2 may return the same code on iOS,
 and seeing it in both places tells the user it is real rather than a heuristic.
@@ -259,6 +271,7 @@ that catches what a human reviewer rejects, so it reads source, not the binary.
 | Privacy policy | reachable in-app and in the metadata |
 | IAP | anything unlocking features goes through StoreKit, with no external purchase path |
 | Sign in with Apple | present when a third-party social login is offered |
+| Crash symbolication | a dSYM upload step exists: an Xcode run-script calling `upload-symbols`, or a Crashlytics / Sentry / Datadog upload in CI |
 
 **Android**  -  `ai-android-toolkit:play-store-review`:
 
@@ -272,6 +285,7 @@ that catches what a human reviewer rejects, so it reads source, not the binary.
 | Account deletion | if the app creates accounts, an in-app deletion path exists, plus the web deletion URL Play requires |
 | Content rating | the questionnaire answers match the app's actual content |
 | Signing | Play App Signing configured, upload key distinct from the app signing key |
+| Crash symbolication | a `mapping.txt` upload exists: the Firebase Crashlytics Gradle plugin, or the Play App Bundle deobfuscation file |
 
 For each: `pass` / `fail` / `not-applicable` with the evidence path that justifies
 it. `not-applicable` needs a reason  -  an unexamined area is not a pass.
@@ -303,6 +317,12 @@ Advisory
 
 Not run
   Gate 2: no local Play validator  -  authoritative check is server-side only
+
+Before rollout (human inputs, not verified)
+  Phased rollout: <1% -> 10% -> 50% -> 100% | full>
+  Halt thresholds: crash-free < 99.5% (iOS, Android) or ANR > 0.47% (Android) => pause the rollout
+  Rollback / forward-fix owner: <name>
+  Forward-fix plan: <one line>
 ```
 
 Rules for the report:
@@ -311,6 +331,8 @@ Rules for the report:
   skip. An Android run therefore reads `2 of 3 gates cleared, 1 skipped` at best.
 - Every blocking finding carries a file path or a store code. A finding the user
   cannot act on is noise.
+- The `Before rollout` block is filled by a human, never inferred. When it is
+  left unfilled the verdict line gains the suffix `, rollout plan missing`.
 - Humanize via `--lang en` by default (`promptLanguage` is locked to `"en"`); pass
   `--lang=tr` explicitly to opt into Turkish.
 - No AI or assistant attribution anywhere, per

package/pipeline/commands/sim-test.md

@@ -253,16 +253,18 @@ Then output full report:
 - **Steps**: 1. Open app -> 2. Tap {X} -> 3. Observe {issue}
 - **Expected**: {correct behavior}
 - **Actual**: {what's wrong}
+- **Spec**: "<quoted acceptance criterion from the analysis doc Section 15 / 20, or: no spec, model expectation>" (<source>)
+- **Evidence**: before=<png path> after=<png path>
 
 ### BUG-2: ...
 
 ## Screens Visited ({N})
 
-| #   | Screen   | Light | Dark  | Large Text | Bugs |
-| --- | -------- | ----- | ----- | ---------- | ---- |
-| 1   | Home     | ok    | BUG-1 | ok         | 1    |
-| 2   | Login    | ok    | ok    | BUG-2      | 1    |
-| 3   | Settings | ok    | ok    | ok         | 0    |
+| #   | Screen   | Light | Dark  | Large Text | Bugs | Evidence |
+| --- | -------- | ----- | ----- | ---------- | ---- | -------- |
+| 1   | Home     | ok    | BUG-1 | ok         | 1    | 3        |
+| 2   | Login    | ok    | ok    | BUG-2      | 1    | 4        |
+| 3   | Settings | ok    | ok    | ok         | 0    | 2        |
 
 ## Summary
 
@@ -272,8 +274,11 @@ Then output full report:
 - Critical: {N} | Major: {N} | Minor: {N}
 - Accessibility audit (accessibility scenario): {N} audited, {N} not audited (reason per screen), deep pass: {ran / skipped: reason}
 - Crashes (full scenario): {N} during this run
+- Production readiness: FAILED | NEEDS WORK | READY
 ```
 
+`Evidence` in a bug block is the captures already written to files in Step 4: a tap-driven finding needs both `before` and `after`, a static finding (layout, contrast, dark mode, large text) needs `after` only. The `Evidence` column in Screens Visited is the count of screenshot files written for that screen. Production readiness defaults to FAILED; it is NEEDS WORK when only Minor bugs remain, and READY only when there are zero Critical / Major bugs and every planned screen was visited.
+
 Save to: `$HOME/.claude/logs/sim-test/{bundle_id}/{timestamp}.md`
 
 ### Step 7  -  Fix Offer

package/pipeline/multi-agent-refs/channels/pr.md

@@ -14,14 +14,15 @@ The PR description targets code reviewers  -  it stays technical. Every adapter
 | 2 | `changes` | `## Değişiklikler` | `## Changes` | always |
 | 3 | `architecture` | `## Mimari Kararlar` | `## Architecture Decisions` | when a non-trivial design choice was made |
 | 4 | `verification` | `## Doğrulama` | `## Verification` | always |
-| 5 | `dependencies` | `## Bağımlılıklar` | `## Dependencies` | when deps added/removed/bumped |
-| 6 | `related` | `## İlgili` | `## Related` | always (Jira/issue ref; never `Closes/Fixes`) |
+| 5 | `risk` | `## Risk ve Güvenlik` | `## Risk and Security` | when `state.diffRisk.signals` carries a high-stakes signal (`security_path`, `migration`, `public_api`, `no_test_change`, `test_lines_removed`) |
+| 6 | `dependencies` | `## Bağımlılıklar` | `## Dependencies` | when deps added/removed/bumped |
+| 7 | `related` | `## İlgili` | `## Related` | always (Jira/issue ref; never `Closes/Fixes`) |
 
 ### Section content rules
 
 **`summary`**  -  1-3 sentences in `outputLanguage`. The "why" of the change. Past tense, no marketing voice. Code identifiers stay verbatim.
 
-**`changes`**  -  bullet list, one item per logically distinct change. Each bullet starts with the touched component and ends with a one-line "what". Use the stack's native file extensions / module paths  -  the example below shows the **shape**, not a stack lock-in:
+**`changes`**  -  bullet list, one item per logically distinct change. Each bullet starts with the touched component and ends with a one-line "what". The source is `$WORKTREE/.pipeline/scope-check.json` `files[].reason` (Phase 3 Step 3.7): a file the dev could not justify there is a file this list cannot describe either, so the bullet quotes the gate output instead of inventing a reason. Use the stack's native file extensions / module paths  -  the example below shows the **shape**, not a stack lock-in:
 
 ```markdown
 ## Changes
@@ -50,6 +51,17 @@ Skeleton (the adapter fills the body with the actual stack-appropriate lines at
 
 Multi-repo PRs (one PR per repo) emit verification commands for that repo's stack only  -  never mix iOS + Android commands into a single PR body.
 
+**`risk`**  -  only when `state.diffRisk.signals` (Phase 4 Step 1.75) contains a high-stakes signal. Four fixed lines, each answered, never left as a placeholder; the source is Phase 1 `touchedAreas` plus the signals themselves, and when a signal is present the absence of this section is a Phase 6 Step 3 blocker:
+
+```markdown
+## Risk and Security
+
+- Auth flow touched: yes | no
+- Secret handling changed: yes | no
+- Data migration: yes | no
+- Rollback: feature flag <name> | git revert <sha> | none, and why
+```
+
 **`dependencies`**  -  only when `Package.swift` / `Podfile` / `build.gradle` / `package.json` changed. Each entry: `package@old → new  -  reason`.
 
 **`related`**  -  flat list, plain text. Examples:
@@ -61,15 +73,21 @@ Multi-repo PRs (one PR per repo) emit verification commands for that repo's stac
 - Issue: #123
 - Confluence: <page-url> (if work referenced a spec)
 - Figma: <design-url> (if work referenced a design)
+
+Follow-ups not done in this PR:
+- <scope-check.json notDone[].what>  -  <why>
+- <deferred triage finding>  -  <triage reason>
 ```
 
+The follow-up list is present only when `scope-check.json` `notDone[]` or the final triage `deferred[]` is non-empty; the two sources merge into one list.
+
 Never use `Closes #N`, `Fixes #N`, `Resolves PROJ-X`. Issues require 4-approval close, the auto-close keywords break that contract.
 
 ### Assembly order (per run)
 
 ```
 1. Read agent-state.json (taskId, contextLinks, identity, language).
-2. Build section bodies in markdown  -  summary first, then in the table order, skipping conditional sections that don't apply.
+2. Build section bodies in markdown  -  summary first, then in the table order, skipping conditional sections that don't apply. Section order is fixed: `summary` → `changes` → `architecture` (cond.) → `verification` → `risk` (cond.) → `dependencies` (cond.) → `related`.
 3. Run the assembled body through the `humanizer` skill.
 4. Apply Multi-repo cross-links (## Related PRs prepend when projects.length > 1).
 5. Dispatch per the Behaviour-by-remote table.

package/pipeline/multi-agent-refs/features/autopilot-circuit-breaker.md

@@ -2,7 +2,7 @@
 
 **Pattern**: autopilot runs with zero interaction, which is exactly when a silent failure loop is most expensive  -  an agent can burn a budget re-attempting the same broken fix, or thrash between two phases, with nobody watching. A circuit-breaker converts "keep going no matter what" into "keep going until a defined unsafe condition, then halt and hand back to the user." This is the sanctioned autopilot pause (same class as the Phase 7 channels pause): the run stops, records why, and waits for an explicit `resume`.
 
-**Gated by `prefs.global.autopilotCircuitBreaker`** (default: enabled; thresholds tunable). Halting is always safe, so the breaker itself defaults on. Disable per-run only with an explicit override. Complements, does not replace, the existing autopilot safety rules (build-fail max 3 retries, Phase 4 blocking-finding rework, destructive-op confirmations).
+**Gated by `prefs.global.autopilotCircuitBreaker`** (`enabled` default true, `identicalFindingCycles` default 2, `maxReworkCycles` default 3; `schemas/prefs.schema.json`). Halting is always safe, so the breaker itself defaults on. Disable per-run only with an explicit override. Complements, does not replace, the existing autopilot safety rules (build-fail max 3 retries, Phase 4 blocking-finding rework, destructive-op confirmations).
 
 ## Trip conditions
 
@@ -18,12 +18,25 @@ Any one trips the breaker. All are evaluated from `agent-state.json` + telemetry
 
 Trigger 2 is the key addition over the plain build-retry cap: a build can "fail differently" three times (legitimate iteration) or "fail identically" twice (stuck). Only the identical-failure case is a stall; the retry cap catches the rest.
 
+## Wiring status
+
+| Trigger | Evaluated by | Status |
+|---|---|---|
+| 2, finding half | `review-delta.mjs` exit 3 at Phase 4 Step 3.8: a blocking/important finding whose `fingerprint` (finding-fingerprint.mjs) stays in the accepted set for `identicalFindingCycles` consecutive rounds | **code** (v16.20.0) |
+| 3 | Phase 3 re-entry item 6: the `retryCount === 3` hard-kill records the trip | **code** (v16.20.0) |
+| 2, build-error half | needs a build-log signature normaliser | documented behaviour, no script yet |
+| 1 | needs checkpoint-to-checkpoint artifact diffing | documented behaviour, no script yet |
+| 4 | belongs to `cost-budget-check.mjs` | documented behaviour, no script yet |
+| 5 | Phase 6 push | documented behaviour, no script yet |
+
+State shape: `state.circuitBreaker = {tripped, trigger, detail, checkpoint: {phase, step, iteration}, trippedAt, counters: {identicalFindingCycles, reworkCycles}}` (`schemas/agent-state.schema.json`). The per-round classification the finding half reads lives in `state.reviewIterations[i].delta` (`new`, `stillPresent`, `resolved`, `downgraded`, `recurrence`, `plateau`). `smoke-autopilot-circuit-breaker.sh` asserts the schema fields, the scripts and the phase wiring, not only this prose.
+
 ## Action on trip
 
 1. Set `agent-state.json.circuitBreaker = {tripped: true, trigger: <#>, detail, checkpoint}` and flip `autopilot` handling to paused (the run does not continue unattended).
 2. Emit one actionable line per the progress contract: what tripped, the evidence (error signature / cycle count / spend vs ceiling), and the single next action (`resume #N` after a fix, or `kill #N`).
 3. Never auto-resolve the underlying cause  -  no force-anything, no conflict auto-merge, no budget self-raise. The breaker hands control back; it does not paper over the problem.
-4. `resume #N` clears the tripped flag and continues from the recorded checkpoint. If the same trigger fires again immediately, the breaker re-trips (no silent bypass).
+4. `resume #N` clears `circuitBreaker.tripped` (keeping `counters`) and continues from the recorded checkpoint. If the same trigger fires again immediately, the breaker re-trips (no silent bypass).
 
 ## Why this is the right autopilot exception
 

package/pipeline/multi-agent-refs/features/review-delta.md

@@ -0,0 +1,89 @@
+# Feature: Cross-round review delta (Phase 4 Steps 2.1, 2.2, 3.8)
+
+**Pattern**: reviewers re-read the whole diff every round with no memory of the round before, so they rediscover last round's findings in new words and nothing can tell "still broken" from "new". A finding therefore needs an identity that survives the fix: `finding-fingerprint.mjs` computes `F:xxxxxxxx` from the file and either the cited `ruleId` or the normalised issue text (lowercase, quotes stripped, paths reduced to basenames, digit runs collapsed). The line, the severity, the fix text and the reviewer take no part, because all of them change between rounds without the finding changing. `review-delta.mjs` then compares round N with round N-1 and reports `stillPresent`, `resolved`, `downgraded` (re-reported but no longer accepted by triage) and `new`, plus `recurrence`: how many consecutive rework cycles each survivor has lasted. That count is the autopilot circuit-breaker's trigger 2.
+
+Gated by `prefs.global.autopilotCircuitBreaker` (`enabled` default true, `identicalFindingCycles` default 2). Computed by scripts, never by the model: an older triage JSON gets its fingerprints on the fly, and a reviewer that echoes one is respected but not relied on.
+
+## Files per round
+
+Phase 4 Step 3.2.1 writes `$WORKTREE/.pipeline/triage-round-<N>.json` (N = `state.reviewIterations | length`), validates it, annotates it and copies it to `$WORKTREE/triage-output.json`, the name Phase 7, `worktree-finalize.sh`, `render-work-summary.sh` and `diff-explain.mjs` read. A copy rather than a symlink because the salvage is `cp -R`, and `.pipeline/` is on the salvage list, so every round survives into `artifactsPath`. Step 3.7 rewrites the round file; the copy is repeated after it.
+
+## Step 2.1 block: previous-round findings (iteration >= 2)
+
+```bash
+ITERATION=$(jq '.reviewIterations | length' "$STATE_FILE")
+PREV_ROUND="$WORKTREE/.pipeline/triage-round-$((ITERATION-1)).json"
+PREV_BLOCK=""
+[ "$ITERATION" -ge 2 ] && [ -f "$PREV_ROUND" ] && PREV_BLOCK=$(node $HOME/.claude/scripts/finding-fingerprint.mjs annotate "$PREV_ROUND" 2>/dev/null \
+  | jq -r '[.accepted[] | select(.severity=="blocking" or .severity=="important")] | sort_by(.severity != "blocking") | .[:40][] | "- \(.fingerprint) [\(.severity)] \(.file): \(.issue)"')
+```
+
+Rendered at the end of the shared prefix (Step 1.9), identical for every reviewer and for the triage call of that iteration:
+
+```
+<previous-round-findings>
+Each entry below was accepted last round and sent for rework.
+- If the issue is still present, report it again with the SAME fingerprint value and the current line.
+- If it is fixed, omit it. Omission is how you report resolution; never emit a "resolved" finding.
+- Any finding not listed here is new: leave fingerprint unset.
+{PREV_BLOCK}
+</previous-round-findings>
+```
+
+The cap of 40 entries drops `important` before `blocking` so the prefix stays bounded. The block never enters the repo-stable prefix `prompt-assembly.md` describes: the diff it follows is already per-run. After each reviewer's validator gate, `finding-fingerprint.mjs annotate --in-place` fills in any fingerprint the reviewer left unset; `anonymize-findings.mjs` strips only identity keys, so the fingerprint reaches triage, and the triage prompt tells the model to preserve it verbatim.
+
+## Step 2.2 block: scope self-check (every iteration)
+
+Phase 3 Step 3.7 wrote `$WORKTREE/.pipeline/scope-check.json` (contract: `features/scope-check.md`). Render it so reviewers judge the diff against the dev's stated scope and do not re-propose what was rejected:
+
+```bash
+SCOPE_JSON="$WORKTREE/.pipeline/scope-check.json"
+SCOPE_GATE=$(git -C "$WORKTREE" diff --name-only "origin/$BASE_BRANCH"...HEAD \
+  | node $HOME/.claude/scripts/scope-check-gate.mjs --check "$SCOPE_JSON" --diff-files - --advisory 2>/dev/null)
+```
+
+```
+<scope-self-check>
+Files and the reason the dev gave for touching each:
+{jq -r '.files[] | "- \(.path): \(.reason)"' "$SCOPE_JSON"}
+Files in the diff with no stated reason (flag as scope drift if the change is not obviously required):
+{jq -r '.unjustified[]' <<< "$SCOPE_GATE"}
+Deliberately not done (do not raise these as findings; they are known):
+{jq -r '.notDone[] | "- \(.what) (\(.why))"' "$SCOPE_JSON"}
+</scope-self-check>
+```
+
+A missing record renders the block with `no scope-check.json written` and a `review.scope_check=missing` metric; the review proceeds, and the absence is itself information for the reviewer.
+
+## Step 3.8: delta + trigger 2
+
+```bash
+TRIP=$(jq -r '.global.autopilotCircuitBreaker.identicalFindingCycles // 2' "$PREFS_FILE")
+DELTA_JSON=$(node $HOME/.claude/scripts/review-delta.mjs --rounds-dir "$WORKTREE/.pipeline" --iteration "$ITERATION" --trip-cycles "$TRIP"); DELTA_RC=$?
+jq -c --argjson d "$DELTA_JSON" --argjson i "$((ITERATION-1))" \
+  '{reviewIterations: (.reviewIterations | .[$i] += {delta: ($d + {computedAt: (now | todate)})})}' "$STATE_FILE" \
+  | node $HOME/.claude/scripts/write-state.mjs "$STATE_FILE"
+$HOME/.claude/scripts/log-metric.sh "$TASK_ID" 4 review.delta iteration=$ITERATION \
+  new=$(jq '.counts.new // 0' <<< "$DELTA_JSON") still_present=$(jq '.counts.stillPresent // 0' <<< "$DELTA_JSON") \
+  resolved=$(jq '.counts.resolved // 0' <<< "$DELTA_JSON") plateau=$(jq '.plateau // false' <<< "$DELTA_JSON") tripped=$([ "$DELTA_RC" -eq 3 ] && echo true || echo false)
+```
+
+| Exit | Meaning | Action |
+|---|---|---|
+| 0 | Progress, or nothing to compare (iteration 1, missing previous round) | Continue to Step 4. |
+| 3 | A blocking/important finding survived `identicalFindingCycles` consecutive rework cycles | **Autopilot** with `enabled`: trip the breaker. `state.circuitBreaker = {tripped: true, trigger: 2, detail: "finding <fingerprint> (<file>: <issue>) survived <n> consecutive rework cycles", checkpoint: {phase: 4, step: "3.8", iteration: N}, trippedAt, counters: {identicalFindingCycles: <max recurrence>, reworkCycles: N-1}}`, then the halt-visibility protocol from `phases/operations.md` (`status=paused`, `haltReason="4:circuit-breaker:identical-finding"`, tracker meta, the `>&2 HALT` line, the usage report). **Interactive modes**: do not trip; show `delta.stillPresent` and ask (picker-contract) `Continue rework` / `Escalate to me` / `Accept as deferred`, the last moving those findings to `deferred[]` with reason `circuit-breaker: accepted by user after <n> cycles`. |
+| 1 | Unreadable round file | Log `review.delta_skipped reason=invalid` and continue; the delta is advisory and never blocks on its own failure. |
+
+`plateau` (the still-present set unchanged from the previous delta) is logged, not acted on: at the default threshold it coincides with trigger 2 and with the Phase 3 `retryCount` hard-kill. The rework-storm cap itself is trigger 3, recorded by the Phase 3 re-entry. The Phase 3 reflection prompt names each accepted finding by `fingerprint` and quotes `delta.stillPresent` first, marked `STILL PRESENT after round N-1's fix`.
+
+## Why fingerprints are computed, not stored
+
+Same argument `shortId()` in `_retrieval.mjs` makes for corpus rows: derived from the finding's own content, so existing triage files get ids without a migration and a re-annotated file keeps the ids it had. The known trade-off is over-merging: two findings in one file that differ only by a number share a fingerprint. The delta output prints `file: issue` beside every id and the trip needs two consecutive recurrences, so a merge is visible and cannot halt a run by itself. Under-merging (a reviewer that rewrites rather than echoes) only ever suppresses a trip; it never causes one.
+
+## Telemetry
+
+`review.delta` once per iteration >= 2: `iteration`, `new`, `still_present`, `resolved`, `plateau`, `tripped`. `run-metrics.mjs` reports `reviewDelta.stillPresentFinal`, `resolvedTotal` and `tripped`; Phase 7 renders the three counts per round.
+
+## Reference
+
+Scripts: `$HOME/.claude/scripts/_fingerprint.mjs`, `finding-fingerprint.mjs`, `review-delta.mjs`. Schemas: `reviewer-output` 1.2.0, `triage-output` 3.4.0, `dev-critic-output` (optional `fingerprint`), `agent-state` (`reviewIterations[].delta`, `circuitBreaker`). Breaker: `features/autopilot-circuit-breaker.md`. Smokes: `smoke-review-delta.sh`, `smoke-autopilot-circuit-breaker.sh`.

package/pipeline/multi-agent-refs/features/scope-check.md

@@ -0,0 +1,41 @@
+# Feature: Scope self-check (Phase 3 Step 3.7)
+
+**Pattern**: Phase 4 reconstructs everything from the diff. The one thing it cannot reconstruct is why each file was touched and what was left out on purpose, so Dev states both before the handoff, and a deterministic gate checks the statement against the real diff. The record also carries the code-simplifier rationales (Step 3.6) that used to be discarded, and it feeds two later consumers: the `<scope-self-check>` block in the Phase 4 reviewer prefix and the PR body in Phase 6.
+
+## The record
+
+`$WORKTREE/.pipeline/scope-check.json`, schema `schemas/scope-check.schema.json`:
+
+```json
+{
+  "version": "1.0.0",
+  "taskId": "<taskId>",
+  "files": [{ "path": "<repo-relative path>", "reason": "<why this task needs this exact file>" }],
+  "notDone": [{ "what": "<change considered and not made>", "why": "out-of-scope | follow-up | rejected-abstraction" }],
+  "simplifier": { "applied": 0, "skipped": 0, "rationales": ["<Step 3.6 rationale strings>"] }
+}
+```
+
+Rules:
+
+- One entry per file in the diff, no entry for a file outside it. A reason names the task requirement, never "while I was here".
+- `notDone` carries every hypothetical the dev chose not to defend against and every abstraction it considered and rejected, so review does not re-propose them.
+- Component tasks (`taskType === "component"`) write the record too; the plugin skill's file table is the `files[]` source.
+
+## The gate
+
+```bash
+git -C "$WORKTREE" diff --name-only "origin/$BASE_BRANCH"...HEAD \
+  | node $HOME/.claude/scripts/scope-check-gate.mjs --check "$WORKTREE/.pipeline/scope-check.json" --diff-files -
+```
+
+Output `{ok, justified, unjustified[], unlisted[], notDone}`. Exit 1 lists `unjustified[]` (in the diff, no reason or an empty one); `unlisted[]` (in the record, not in the diff) is reported and never fatal. Complete the record once and re-run. A second exit 1 does not block: log `dev.scope_check=incomplete unjustified=<n>` and hand off; Phase 4 receives the gate output inside `<scope-self-check>`, so reviewers see which files arrived without a stated reason. `--advisory` (used by Phase 4) always exits 0. Progress line: `    → checking scope self-check ({n} files, {m} not done)`.
+
+## Consumers
+
+- Phase 4 Step 2.2 renders file reasons, unjustified files and `notDone[]` into the shared reviewer prefix (`features/review-delta.md`).
+- Phase 6 Step 3 builds the PR `## Changes` bullets from `files[].reason` and lists `notDone[]` under `## Related` as "Follow-ups not done in this PR", merged with the final triage `deferred[]` (`channels/pr.md`).
+
+## Reference
+
+Script: `$HOME/.claude/scripts/scope-check-gate.mjs`. Schema: `$HOME/.claude/schemas/scope-check.schema.json`. Smoke: `smoke-scope-check.sh`. Unit: `test/scope-check-gate.test.mjs`.

package/pipeline/multi-agent-refs/features/verify-by-test.md

@@ -5,7 +5,7 @@
 **Gated by `prefs.global.verifyByTest.enabled`** (default: `false`). When enabled, after triage 3.6 and before Step 4, IF the validated triage output contains at least one `accepted` blocking finding:
 
 1. Dispatch ONE verifier sub-agent for the iteration (model: `verifyByTest.model`, default `sonnet`)  -  never one dispatch per finding. Input: up to `verifyByTest.maxFindings` (default 3) accepted blocking findings, the diff hunks for their files, and the Phase 1 test conventions.
-2. Per finding, the verifier writes ONE minimal repro test asserting the correct behavior the finding claims is broken, then runs ONLY that test via the Phase 3 single-test invocation (`xcodebuild test -only-testing:`, `pytest {file}::{name}`, `npm test -- --testPathPattern=`, `./gradlew test --tests`) under `acquire_build_lock`/`release_build_lock`, log tee'd to `$WORKTREE/.pipeline/verify-<i>.test.log`.
+2. Per finding, the verifier writes ONE minimal repro test asserting the correct behavior the finding claims is broken, then runs ONLY that test via the Phase 3 single-test invocation (`xcodebuild test -only-testing:`, `pytest {file}::{name}`, `npm test -- --testPathPattern=`, `./gradlew test --tests`) under `acquire_build_lock`/`release_build_lock`. One green run is not trusted: the same single-test invocation runs `verifyByTest.repeatCount` times (default 3; value 1 disables the repeat) as a shell loop, each run's log tee'd to `$WORKTREE/.pipeline/verify-<i>-<k>.test.log` for `k` in `1..repeatCount`. ALL runs must pass, and each log must clear `evidence-gate.mjs --claim test --status passed`, before the outcome counts as "passes". A first run that fails as predicted ends the loop early (`confirmed` needs no repeat).
 3. Stamp each processed finding with a `verification` object (triage-output schema v3.2.0) and re-run `validate-triage.mjs` on the mutated triage file under the standard 3.2.1 gate protocol.
 4. Findings beyond `maxFindings` keep their judgment-only verdict (log `verify_by_test=cap-exceeded`).
 5. The whole step is bounded by `verifyByTest.stepTimeoutSec` (default 600); on breach or verifier crash, remaining findings keep judgment-only verdicts and the pipeline proceeds. Never blocks.
@@ -15,7 +15,8 @@
 | Repro test outcome | `verification.result` | Action |
 |---|---|---|
 | Fails as the finding predicts | `confirmed` | Finding stays accepted blocking. Repro test KEPT in the worktree, recorded in `redTests[]`. |
-| Passes (not reproducible) | `not-reproduced` | Downgrade gated by `evidence-gate.mjs --claim test --status passed` on the test log (exit 0 required). Finding moves `accepted[]` -> `deferred[]` with reason `verify-by-test: not reproduced - repro test <testRef> passed`; repro test file deleted. Evidence-gate failure -> treat as `inconclusive`. |
+| Passes (not reproducible) | `not-reproduced` | Only when ALL `verifyByTest.repeatCount` runs pass and every `verify-<i>-<k>.test.log` clears `evidence-gate.mjs --claim test --status passed` (exit 0 required on each). Finding moves `accepted[]` -> `deferred[]` with reason `verify-by-test: not reproduced - repro test <testRef> passed`; repro test file deleted. Evidence-gate failure on any run -> treat as `inconclusive`. |
+| Passes on some runs, fails on others | `inconclusive` | Flake, not proof either way. Finding stays accepted blocking, `verification.note = "flaky: passed k/N"`, repro test file deleted, telemetry line gains `flaky=<count>`. |
 | Compile error / timeout / not unit-testable | `inconclusive` | Finding stays accepted blocking (judgment stands). Partial test deleted, cause in `verification.note`. |
 
 Downgrades go to `deferred`, never `rejected`: triage judged the issue real, and deferred items surface in the Phase 7 report for a human eye.
@@ -30,12 +31,12 @@ After Step 3.7, the only uncommitted verifier artifacts are the confirmed repro
 
 ## Telemetry
 
-One `review.verify_by_test` metric per iteration: `attempted`, `confirmed`, `downgraded`, `inconclusive`, `duration_ms` (plus `tokens_in/out` when available), forwarded to the tracker like all Phase 4 metrics. Timeout emits `triage=verify-by-test-timeout`.
+One `review.verify_by_test` metric per iteration: `attempted`, `confirmed`, `downgraded`, `inconclusive`, `flaky` (findings whose repeat runs disagreed), `duration_ms` (plus `tokens_in/out` when available), forwarded to the tracker like all Phase 4 metrics. Timeout emits `triage=verify-by-test-timeout`.
 
 ## Off by default reason
 
-Adds one Sonnet call plus up to `maxFindings` single-test runs (and build-lock contention on Xcode projects) per review iteration that has accepted blockers. On clean runs it never fires, but on noisy-reviewer repos it can add minutes per iteration. Flip on for security-critical work, release branches, or repos where reviewer false-positive rate is high.
+Adds one Sonnet call plus up to `maxFindings` single-test runs (and build-lock contention on Xcode projects) per review iteration that has accepted blockers. Each passing repro test is re-run `verifyByTest.repeatCount` times (default 3), so a downgrade costs up to `repeatCount` single-test runs rather than one. On clean runs it never fires, but on noisy-reviewer repos it can add minutes per iteration. Flip on for security-critical work, release branches, or repos where reviewer false-positive rate is high.
 
 ## Reference
 
-Wiring: `$HOME/.claude/multi-agent-refs/phases/phase-4-review.md` Step 3.7. Schema: `$HOME/.claude/schemas/triage-output.schema.json` v3.2.0 (`$defs.verification`). Evidence gate: `$HOME/.claude/scripts/evidence-gate.mjs`. Prefs: `prefs.global.verifyByTest` in `$HOME/.claude/schemas/prefs.schema.json`.
+Wiring: `$HOME/.claude/multi-agent-refs/phases/phase-4-review.md` Step 3.7. Schema: `$HOME/.claude/schemas/triage-output.schema.json` v3.2.0 (`$defs.verification`). Evidence gate: `$HOME/.claude/scripts/evidence-gate.mjs`. Prefs: `prefs.global.verifyByTest` (including `repeatCount`) in `$HOME/.claude/schemas/prefs.schema.json`.

package/pipeline/multi-agent-refs/features/worktree-finalize.md

@@ -49,7 +49,7 @@ This is why the removal is safe:
 
 | Consumer | Reads | Without salvage |
 |---|---|---|
-| Phase 7 triage-memory ingest | `triage-output.json` | `[ -f ]`-guarded, so it degrades **silently**: the triage corpus and learnings ledger stop being fed and no error appears |
+| Phase 7 triage-memory ingest | `triage-output.json` | `[ -f ]`-guarded, so it degrades **silently**: the triage corpus and learnings ledger stop being fed and no error appears. Since v16.20.0 Phase 4 writes `triage-output.json` itself (Step 3.2.1, the latest copy of `.pipeline/triage-round-<N>.json`), so the salvage is a second copy, not the only bridge |
 | Phase 7 learnings-ledger distill | same file | same silent degradation |
 | `render-work-summary.sh` | `agent-state.json`, `phase-tracker.json` (falls back to `logs/multi-agent/<task>/tracker-state.json`, which survives removal) | loses the salvaged copies but keeps the tracker via the logs fallback |
 | `:resume` | `agent-state.json` | cannot continue a Phase 7 pause |

package/pipeline/multi-agent-refs/payload-contracts.md

@@ -10,7 +10,7 @@ description: "Canonical required-reading list for outward-facing payloads (PR bo
 
 | Read | Before | Governs |
 |---|---|---|
-| [`channels/pr.md`]($HOME/.claude/multi-agent-refs/channels/pr.md) | assembling the PR body | fixed section set (`summary` → `changes` → `architecture` cond. → `verification` → `dependencies` cond. → `related`), Markdown-only rule, reviewer-preserving Bitbucket PUT payload |
+| [`channels/pr.md`]($HOME/.claude/multi-agent-refs/channels/pr.md) | assembling the PR body | fixed section set (`summary` → `changes` → `architecture` cond. → `verification` → `risk` cond. → `dependencies` cond. → `related`), Markdown-only rule, reviewer-preserving Bitbucket PUT payload |
 | [`phases/phase-6-commit.md`]($HOME/.claude/multi-agent-refs/phases/phase-6-commit.md) | committing | commit convention, default-reviewer fetch, draft/ready prompt, push-must-succeed loop |
 | [`rules.md`]($HOME/.claude/multi-agent-refs/rules.md) "External System Outputs" | any REST payload | real newlines, no HTML entities, no hand-rolled JSON, markup dialect per surface |