@mmerterden/multi-agent-pipeline 16.27.0 → 16.28.0

package/pipeline/multi-agent-refs/analysis/review.md

@@ -86,6 +86,21 @@ Fable triages the pooled findings exactly as in `/multi-agent:review`: drop dupl
 
 The verdict names the profile it judged against, the counts per severity, and what was NOT checked (the references gate without a state file, anything the fetch could not reach). Follow the pipeline rule on claiming: state which findings are mechanically proven and which are judgement.
 
+**Every rubric class is printed, including the empty ones.** A verdict that lists only the classes that fired says nothing about the rest: the reader cannot tell "checked, clean" from "never looked". Print A through F in order with a count each, and write `none` where the count is zero. Same rule for the deterministic gates: name each one and its verdict, including the ones that skipped and why.
+
+**Colophon.** Close the verdict with the reviewed document's `evidence_digest` and `base_commit`, taken from its front-matter, plus the reviewer models used. Two reviews of the same feature on the same day are otherwise indistinguishable, and the first question anyone asks of an older verdict is which version of the document it judged. `validate-analysis-doc.mjs --report` prints the per-check verdicts to paste under it.
+
+```
+Verdict: 2 Blocker, 3 Important, 1 Suggestion   (profile: global, mode: full)
+
+  A evidence          2      D altitude          none
+  B backbone          none   E admitted gaps     1
+  C ...                      F contradiction     3
+
+Not checked: references coverage (no state file passed)
+Provenance:  evidence_digest sha256:1f3a9c2   base_commit 4c1b2de
+```
+
 ## Phase 4 - Output
 
 Default is the chat report. Nothing is written anywhere without an explicit choice.

package/pipeline/multi-agent-refs/analysis/synthesis.md

@@ -88,7 +88,7 @@ For each `platform` in `state.analysisSpec.platforms[]`:
    - `web` → `evidence.standards[]` entries matching `react`, `vue`, `next`, `sveltekit` → `~/.claude/rules/code-style.md`
 2. **Apply per-platform omission rules.** Backend-only file drops Sections 5, 6, 7, 8, 16. Web with no UI inventory still keeps 5 (UI exists in code). Sections 1, 2, 4, 9, 13, 14, 20, 21 always present per Locked decision 2 + 13.
 3. **Resolve mode.** If user passed `--lite` → Lite. If user passed `--full` → Full. Otherwise use `state.analysisSpec.liteModeAuto`. Lite mode renders only Sections 1, 2, 4, 9, 13, 14, 21 plus optional 23.
-4. **Produce YAML front-matter header** (see `$HOME/.claude/multi-agent-refs/analysis-template.md`). Include `profile: <state.analysisSpec.profile | global>` and `platform: <platform | none>` so the validator applies the right contract per profile (Locked 32) and recognises the stack-optional render (Locked 35), `mode: full | lite`, plus `ui_tests: <state.analysisSpec.options.uiTests | false>` and `a11y_depth: <state.analysisSpec.options.a11yDepth | basic>` so the pre-dispatch validator can enforce the opt-in coverage (15.6 present when ui_tests, 16.2 walkthrough present when a11y_depth is full).
+4. **Produce YAML front-matter header** (see `$HOME/.claude/multi-agent-refs/analysis-template.md`). Include `profile: <state.analysisSpec.profile | global>` and `platform: <platform | none>` so the validator applies the right contract per profile (Locked 32) and recognises the stack-optional render (Locked 35), `mode: full | lite`, plus `ui_tests: <state.analysisSpec.options.uiTests | false>`, `a11y_depth: <state.analysisSpec.options.a11yDepth | basic>` and `redesign: <state.analysisSpec.options.redesign | false>` so the pre-dispatch validator can enforce the opt-in coverage (15.6 present when ui_tests, 16.2 walkthrough present when a11y_depth is full, 4.5 / 4.6 / 9.5 present when redesign). `status` is written only by `/multi-agent:analysis-resolve`; a rendered document is a draft.
 5. **Read conventions for this platform's repo.** For each cell Pass B fills in Section 13 and in any per-platform projection (Sections 5, 6, 7, 8, 10, 11, 13, 14, 15, 16, 17), read `state.analysisSpec.evidence.conventions[<repo>].<field>` and emit the value with a footnote (Locked 24). If `conventionOverrides` has an entry for that field, use the override and footnote with `^[user-override: <reason>]` instead of evidence path.
 6. **Concatenate non-null sections in canonical order.** Numbering stays sequential `1..N` over the rendered set (omitted sections do not create gaps).
 7. **Schema validation** on the per-platform spec object:

package/pipeline/multi-agent-refs/analysis-template-corporate.md

@@ -433,12 +433,12 @@ Never omitted.
 ## 20. Riskler ve Açık Sorular    <!-- TR -->
 ## 20. Risks and Open Questions   <!-- EN -->
 
-| # | Konu | Neden açık | Kime sorulacak | Etkilediği bölüm |
+| Id | Konu | Neden açık | Kime sorulacak | Etkilediği bölüm |
 |---|---|---|---|---|
-| 1 | <question> | <what evidence is missing> | <role or team> | 2.3 |
+| AS-01 | <question> | <what evidence is missing> | <role or team> | 2.3 |
 ```
 
-The source corporate documents keep open questions out of the page and raise them in conversation instead. This profile keeps them in the document deliberately: an `EKLENECEK` with no matching row here is an unanswered question nobody owns. Every `EKLENECEK` and every unverified assumption in 2.4 emits a row (Locked 33).
+The source corporate documents keep open questions out of the page and raise them in conversation instead. This profile keeps them in the document deliberately: an `EKLENECEK` with no matching `AS-NN` row here is an unanswered question nobody owns. Every `EKLENECEK` and every unverified assumption in 2.4 emits a row (Locked 33).
 
 ## 21. Referanslar / References
 

package/pipeline/multi-agent-refs/analysis-template.md

@@ -46,6 +46,8 @@ platform: ios | android | web | backend | mobile | none
 profile: global | corporate
 language: tr | en
 mode: full | lite
+status: draft | final
+redesign: true | false
 ui_tests: true | false
 a11y_depth: basic | full
 generated: <ISO 8601 UTC timestamp>
@@ -64,6 +66,8 @@ template_version: v3
 
 `ui_tests` and `a11y_depth` record the Phase 0 Step 5a opt-ins (defaults `false` / `basic`) so the coverage choice is auditable and the pre-dispatch validator can enforce it: `ui_tests: true` requires Section 15.6, `a11y_depth: full` requires the Section 16.2 walkthrough.
 
+`status` is the publication claim; absent means `draft`. Under `final` an unresolved `AS-NN` or open Section 20 row is an ERROR, under `draft` it is counted. `/multi-agent:analysis-resolve` flips it, after a confirmation.
+
 `profile` names the template the document was rendered against (Locked 32) and `platform: none` marks the stack-optional render (Locked 35). Both are read by `validate-analysis-doc.mjs`, which applies a different contract per profile: without the key a corporate document would be judged against the global rules and its backbone would read as a pile of Locked 2 violations.
 
 Phase 1 compares `evidence_digest` against an existing document to decide whether to reuse it (Locked 27). Phase 3 reads `platform` to verify file match, `mode` to know which section set to expect, and both `evidence_digest` and `base_commit` to judge freshness: the digest says the evidence changed, `base_commit` says the repo moved. Phase 2 parses the block but gates only on `template_version`.
@@ -284,6 +288,27 @@ EARS states the rule; Gherkin states how you check it. Each rule still maps to a
 
 Each scenario in 4.1-4.3 cites the matching `BR-<slug>-NN` id (and, when a server code applies, the Section 9.4 code). Plain-prose user stories without Given/When/Then are rejected by the renderer.
 
+### 4.5 Mevcut Davranış / Current Behaviour (OPTIONAL)
+
+`redesign: true` only. Locked 37; contract and checks in `analysis/redesign.md`. Evidence and certainty are derived from `repoEvidence`, never graded by the writer.
+
+```markdown
+| Id | Davranış / Behaviour | Kanıt / Evidence | Kesinlik / Certainty |
+|---|---|---|---|
+| CB-<slug>-01 | <what v1 does, present tense, no v2 language> | <repo>/<path>:<line> | confirmed |
+| CB-<slug>-02 | <what v1 does> | <module> (cross-cutting) | uncertain |
+```
+
+### 4.6 Endpoint Eşlemesi / Endpoint Mapping (OPTIONAL)
+
+`redesign: true` only. An unchanged path still gets its row: "unchanged" is an answer, its absence is not.
+
+```markdown
+| v1 | v2 | Değişiklik / Change |
+|---|---|---|
+| GET /v1/<path> | GET /v2/<path> | <shape change, or unchanged> |
+```
+
 ## 5. Tasarım Referansı / Design Reference
 
 Per-platform projection. Omitted if no Figma URL AND no Code Connect mapping. Locked 17 + 18.
@@ -484,6 +509,17 @@ List every HTTP status code one by one.
 | ERR-211 | Empty result set | <screen> |
 ```
 
+### 9.5 Fark Listesi / Difference List (OPTIONAL)
+
+`redesign: true` only. One row per `CB-` id, both directions checked. Closed status vocabulary - `Moved`, `Partial`, `Missing`, `New`, `Out of scope` - in a bilingual cell like Section 20's `Açık / Open`. Every `Missing` and `Partial` owes a Section 20 row by `AS-NN`.
+
+```markdown
+| Id | Durum / Status | Nereye / Where | AS-NN |
+|---|---|---|---|
+| CB-<slug>-01 | Taşındı / Moved | 4.2 | - |
+| CB-<slug>-02 | Eksik / Missing | - | AS-03 |
+```
+
 ## 10. Lokalizasyon Anahtarları / Localization Keys
 
 Per-platform projection. Locked 20 - shape depends on the project `figma-config` `localization.ownership`. The locale set comes from `localization.locales` (default `tr, en, ar, de, es, fr, it, ru`); never hardcode a locale list.

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

@@ -230,6 +230,9 @@ argument-hint: "<input hint>"
 |---|---|
 | Claude → Copilot | Add `name`, `user-invocable: true`, `argument-hint`; remove `allowed-tools`; `description` stays English (localization happens only in the installed Claude tree via `description-tr` + `localize-commands.mjs`, never in repo or Copilot files) |
 | Copilot → Claude | Remove `name`, `user-invocable`, `argument-hint`; add `allowed-tools` (inferred from command's actual tool calls) |
+| Both directions | `not-for: <sibling>` carries across unchanged |
+
+**`not-for`** is optional and lists sibling commands this one must not be chosen for, as bare names (`not-for: jira, review-jira`). It is written for the model reading the routing surface, so it belongs beside the description rather than in prose further down. `lint-skills.mjs` also consumes it: a trigger-vocabulary collision either side has named drops off the warning list and is reported as settled instead, and a name that resolves to no sibling on the same surface is an error - a typo would otherwise leave the pair unanswered while the author believes it is handled. Both trees spell the value the same way; the `multi-agent-` prefix on the Copilot side is stripped before matching.
 
 **Invariant**: the English `description` must have the same meaning on both sides, and a `description-tr` line (when present) must be a faithful translation of it. Semantic drift is not allowed. `description-en` sidecars are an installed-tree artifact and must never appear in repo or Copilot files.
 

package/pipeline/multi-agent-refs/features/jira-context.md

@@ -0,0 +1,101 @@
+# Related-issue context at intake
+
+A development sub-task is often filed with no description of its own. The
+requirement sits on the parent, and the rest of the picture  -  the analysis, the
+test scope  -  sits on the sibling sub-tasks beside it. The fetcher already read
+the parent; it did not read the siblings, so a board that keeps its analysis in a
+separate sub-task handed the pipeline an empty task.
+
+`issue-fetcher.sh` now reads those siblings and exposes them as
+`descriptor.relatedIssues[]`.
+
+## What it costs
+
+One search request, and only when the issue has a parent:
+
+```
+GET /rest/api/2/search?jql=parent="<PARENT>"&fields=summary,issuetype,status,description&maxResults=20
+```
+
+An issue with no parent has no siblings, so the lookup is skipped entirely and
+that run pays nothing. The count does not grow with the number of siblings: the
+issue's own `subtasks` field lists ITS children rather than its siblings, and the
+parent's lists siblings without their descriptions, so either of those shapes
+would cost one GET per sibling. `smoke-jira-context.sh` counts the requests, so
+this stays a measurement rather than a claim.
+
+The request lands before the maturity verdict reaches the user, which is one
+extra round trip on the intake path. `jiraContext.enabled: false` is the way out
+when latency matters more than the context.
+
+## Shape
+
+```json
+"relatedIssues": [
+  {
+    "key": "PROJ-1002",
+    "relation": "sibling",
+    "type": "Sub-task",
+    "status": "Done",
+    "summary": "...",
+    "description": "...",
+    "truncated": false
+  }
+]
+```
+
+`type` is carried through verbatim from Jira and is never matched against in
+code. Boards name their sub-task types differently and the query does not need
+to know: `parent = <key>` returns all of them.
+
+Siblings that carry a description are ordered first, so `maxItems` drops the
+empty ones rather than the useful ones. An empty sibling is still listed  -  its
+key, type and status are information  -  with an empty `description`.
+
+## Settings
+
+`prefs.global.jiraContext`:
+
+| Key | Default | Effect |
+|---|---|---|
+| `enabled` | `true` | `false` skips the search entirely |
+| `maxItems` | `6` | Hard cap; `0` behaves like `enabled: false` |
+| `maxCharsPerItem` | `1200` | Per-sibling truncation, marked `truncated: true` |
+
+Worst case payload is `maxItems x maxCharsPerItem`, next to the 4000-character
+cap on the issue's own description.
+
+## Maturity
+
+One new code, `description_empty_sibling_available`, and it fires narrowly: the
+issue's own description is empty, the parent's is empty or unreachable, AND a
+sibling carries content. Today that combination produces the hard
+`description_empty` blocker; it becomes a warning instead, the same downgrade
+`description_empty_parent_available` already makes one level up.
+
+The narrowness is deliberate. `score` is `100 - 40*blockers - 10*warnings`, and
+the picker continues silently only at `score >= 90`, so a warning that fired
+whenever an issue merely HAD siblings would cost ten points on every parented
+issue and turn a silent intake into a question across the board.
+
+## Where it goes
+
+The descriptor is carried verbatim into the picker state as `issueRef`, and the
+bridge copies `relatedIssues` onto `agent-state.json` when it is non-empty.
+
+Persisting it is the point: `/multi-agent:resume` rebuilds context from durable
+artefacts and never from the conversation, so an intake-only enrichment would be
+gone by the first resume. The task's own `description` and `maturity` are still
+not persisted, which is a known asymmetry rather than an oversight  -  this
+change did not widen the bridge beyond the one field it needed.
+
+Sibling text is added as its own labelled block. It never replaces the working
+description the way an accepted `parentDescription` does: substituting it would
+erase the provenance that Phase 2's parent-story scope-drift check reads.
+
+## Not included
+
+Following the parent's `issuelinks` in a second search. A linked bug can be the
+whole requirement while a linked test-execution record is noise, and the fetcher
+cannot tell them apart, so the scope stops at sub-tasks. There is no setting for
+it: a switch that does nothing is worse than an absent one.

package/pipeline/multi-agent-refs/phases/phase-1-analysis.md

@@ -109,7 +109,7 @@ back. "Copy X and rename it" is the reuse answer, not a hint  -  name X's files.
 
 #### Step 1.5  -  External Context Injection (`state.contextLinks[]`)
 
-Phase 0 Step 1b catalogued every typed external link from the task description into `state.contextLinks[]`. Phase 1 dispatches each entry to its matching fetcher (crashlytics, fortify, graylog, swagger, confluence, figma, generic-doc) and prepends results under a **Referenced External Sources** section in the analysis prompt  -  so the agent doesn't re-discover what the ticket already pointed at. `state.graylogContext` is injected there too, as diagnostic context (advisory only). Failures never fatal (a non-zero fetcher exit is marked skipped and the analysis still runs, exactly as for crashlytics); pending refs are advisories. Full dispatch table, exit-code handling, prompt injection shape, log line shape: `$HOME/.claude/multi-agent-refs/features/external-context-injection.md`.
+Phase 0 Step 1b catalogued every typed external link from the task description into `state.contextLinks[]`. Phase 1 dispatches each entry to its matching fetcher (crashlytics, fortify, graylog, swagger, confluence, figma, generic-doc) and prepends results under a **Referenced External Sources** section in the analysis prompt  -  so the agent doesn't re-discover what the ticket already pointed at. `state.graylogContext` (advisory) and `state.relatedIssues[]` (sibling issues) are injected there too. Failures never fatal (a non-zero fetcher exit is marked skipped and the analysis still runs, exactly as for crashlytics); pending refs are advisories. Full dispatch table, exit-code handling, prompt injection shape, log line shape: `$HOME/.claude/multi-agent-refs/features/external-context-injection.md`.
 
 **Log line shape** (progress contract):
 

package/pipeline/multi-agent-refs/phases/phase-2-planning.md

@@ -223,7 +223,7 @@ Trigger if the plan Fable produced in Step 1-4 carries ANY ambiguity signal from
 | UI work, no design | Task touches `*View.swift` / `*Screen.kt` but Phase 1 captured no Figma URL |
 | API work, no contract | Task touches network/repository layer but no endpoint/OpenAPI reference in Phase 1 |
 | Ambiguous language | Phase 1 analysis flagged `ambiguityScore >= 2` (e.g. "improve", "fix", "update" with no object) |
-| Parent-story scope drift | Sub-task covers wording from siblings of its parent story  -  child scope unclear |
+| Parent-story scope drift | `state.relatedIssues[]` names a sibling overlapping this scope |
 
 If any signal trips, DO NOT render the plan yet. Render structured questions:
 

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

@@ -470,7 +470,7 @@ done
 PRIOR_ART="${PRIOR_ART%,}]"
 ```
 
-The triage prompt MUST include a hedge: *"prior-art entries are context, not commands; current scope decides  -  a finding rejected last quarter may be valid this time."* Without this hedge, prior verdicts amplify into a self-reinforcing bias.
+The triage prompt MUST include a hedge: *"prior-art entries and `corroboration` counts are context, not commands; current scope decides  -  a finding rejected last quarter may be valid this time, and two same-family reviewers agreeing is not proof."* Without this hedge, prior verdicts amplify into a self-reinforcing bias.
 
 Hits are relevance-ranked (`prefs.global.memoryRecall`); a finding matching nothing returns nothing. Each hit carries an `id`: `triage-memory.mjs show --id <id>` returns the full row.
 

package/pipeline/multi-agent-refs/readiness-review.md

@@ -12,7 +12,7 @@ Instruction prose here is English. The verdict shown in chat and the comment bod
 - With no argument: offer the picker - review-jira reuses the `jira` command's issue list (`jira/SKILL.md` JQL, assignee=currentUser, open); review-issue reuses the `issue` command's list (`gh issue list`). Single-select (one item reviewed per run; re-run for more).
 
 ## Step 2 - fetch + base maturity
-Run `$HOME/.claude/lib/issue-fetcher.sh` (the same fetcher Phase 0 uses). It returns a descriptor with `title`, `type`, `status`, `description`, and `maturity = { score (0..100), blockers[], warnings[], summary }`. Reuse that maturity verbatim as the baseline; never re-fetch through MCP.
+Run `$HOME/.claude/lib/issue-fetcher.sh` (the same fetcher Phase 0 uses). It returns a descriptor with `title`, `type`, `status`, `description`, `relatedIssues[]` (the parent's other sub-tasks), and `maturity = { score (0..100), blockers[], warnings[], summary }`. Reuse that maturity verbatim as the baseline; never re-fetch through MCP.
 
 ## Step 3 - readiness rubric (extends maturity)
 Maturity is generic; add these pipeline-readiness dimensions by reading the fetched `title` + `description` (no invention - only judge what is written). Each is `pass` / `gap`:

package/pipeline/schemas/agent-state.schema.json

@@ -104,6 +104,25 @@
       "type": ["string", "null"],
       "description": "Set when a phase halts on a hard error (validator failed twice, no subagent returned, dispatch error past fallback, lock irrecoverable). Format '<phase>:<cause>'. Surfaced to the user and cleared on successful resume. See operations.md 'Halt visibility'."
     },
+    "relatedIssues": {
+      "type": "array",
+      "maxItems": 20,
+      "description": "Jira issues fetched alongside the task at intake: the other sub-tasks under this issue's parent, where a board keeps the analysis and the test scope. NOT the same field as siblings[] below, which is read-only sibling REPOS. Written by the picker bridge from descriptor.relatedIssues; read by Phase 1 as ground truth and by Phase 2's parent-story scope-drift check. Durable on purpose: /multi-agent:resume rebuilds context from artefacts, never from the conversation, so intake-only enrichment would vanish on the first resume. The task's own description and maturity are still NOT persisted here, which is a known asymmetry, not an oversight.",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["key", "relation"],
+        "properties": {
+          "key": { "type": "string" },
+          "relation": { "type": "string", "enum": ["sibling"] },
+          "type": { "type": "string" },
+          "status": { "type": "string" },
+          "summary": { "type": "string" },
+          "description": { "type": "string" },
+          "truncated": { "type": "boolean", "default": false }
+        }
+      }
+    },
     "siblings": {
       "type": "array",
       "maxItems": 10,

package/pipeline/schemas/prefs.schema.json

@@ -1358,6 +1358,32 @@
           "description": "v12.8+ - Phase 4 Step 1.77 reviewer-scope gate. Decides the reviewer count from the deterministic diff-risk report via `pipeline/scripts/review-scope.mjs`: a diff under 20 lines of churn with max_score < 3.0 and no security_path / migration / public_api / no_test_change / test_lines_removed signal runs ONE reviewer instead of the full CLI-aware set (2 on Claude Code, 3 on Copilot CLI). No LLM. Fails safe in one direction only - any error, empty report or validator rejection resolves to the full set, because skipping a reviewer trades coverage for cost. Set false to force the full set on every diff.",
           "$comment": "Shipped inert for a release: the script existed, was unit- and smoke-tested, and no phase doc referenced it, so every diff paid for the full reviewer set. Wired in Step 1.77; smoke-gate-wiring.sh keeps it reachable."
         },
+        "jiraContext": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "v16.28+  -  when a Jira issue has a parent, the intake fetcher also reads the parent's other sub-tasks in ONE extra search request and exposes them as descriptor.relatedIssues[]. A development sub-task filed with an empty description whose analysis sibling carries the real requirement is the case this exists for. Costs nothing on an issue with no parent, because an issue with no parent has no siblings. The extra round trip lands before the maturity verdict is shown, so turn it off when intake latency matters more than the context.",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "default": true,
+              "description": "Master switch. When false the fetcher never issues the search and relatedIssues[] is always empty."
+            },
+            "maxItems": {
+              "type": "integer",
+              "default": 6,
+              "minimum": 0,
+              "maximum": 20,
+              "description": "Hard cap on relatedIssues[]. Siblings that carry a description are kept first, so the cap drops the empty ones. 0 disables the lookup exactly like enabled: false."
+            },
+            "maxCharsPerItem": {
+              "type": "integer",
+              "default": 1200,
+              "minimum": 0,
+              "maximum": 4000,
+              "description": "Per-sibling description truncation, marked with truncated: true. Worst case payload is maxItems x this, next to the 4000-char cap on the issue's own description."
+            }
+          }
+        },
         "priorArtEnrichment": {
           "type": "object",
           "additionalProperties": false,

package/pipeline/scripts/anonymize-findings.mjs

@@ -122,6 +122,30 @@ export function anonymize(input, { seed } = {}) {
     }
   });
 
+  // How many DIFFERENT reviewers reported this finding, counted from the
+  // fingerprints the validator already stamped. It costs nothing: every
+  // reviewer's findings are in this one payload and nowhere else are they
+  // together. `count` names no reviewer, so it survives the identity strip
+  // without reopening what the strip closed.
+  //
+  // It is context for triage, never a rule. ADR-0001 rejected majority voting
+  // precisely because the same hallucination shows up in two of three
+  // same-family reviewers, so a high count is not evidence of truth. The
+  // reading that pays is the other end: count 1 is the finding only one
+  // reviewer saw, which is where a judge should look hardest.
+  const seen = new Map();
+  for (const f of tagged) {
+    const k = typeof f?.fingerprint === "string" && f.fingerprint ? f.fingerprint : null;
+    if (!k) continue;
+    if (!seen.has(k)) seen.set(k, new Set());
+    seen.get(k).add(f.foundBy);
+  }
+  const of = reviewers.length;
+  for (const f of tagged) {
+    const k = typeof f?.fingerprint === "string" && f.fingerprint ? f.fingerprint : null;
+    f.corroboration = { count: k ? seen.get(k).size : 1, of };
+  }
+
   tagged.sort((a, b) => {
     const ka = stableKey(a);
     const kb = stableKey(b);

package/pipeline/scripts/build-references.mjs

@@ -338,7 +338,8 @@ function main() {
     process.stderr.write(
       "usage: build-references.mjs <state.json|-> [--lang tr|en] [--check <doc.md>]\n",
     );
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
 
   let spec;
@@ -346,13 +347,15 @@ function main() {
     spec = readState(statePath);
   } catch (err) {
     process.stderr.write(`ERROR: cannot read state: ${err.message}\n`);
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
 
   const lang = argOf(argv, "--lang") ?? spec.language ?? "tr";
   if (!HEADERS[lang]) {
     process.stderr.write(`ERROR: unknown language "${lang}"; expected tr or en\n`);
-    process.exit(2);
+    process.exitCode = 2;
+    return;
   }
 
   const docPath = argOf(argv, "--check");
@@ -361,10 +364,11 @@ function main() {
     if (problems.length) {
       for (const p of problems) process.stderr.write(`${p}\n`);
       process.stderr.write(`\n${problems.length} references coverage failure(s)\n`);
-      process.exit(1);
+      process.exitCode = 1;
+      return;
     }
     process.stdout.write("references coverage ok\n");
-    process.exit(0);
+    return;
   }
 
   const rows = rowsFrom(spec, lang);
@@ -376,7 +380,7 @@ function main() {
         ? "Bu koşuda getirilen kaynak yok.\n"
         : "No sources were fetched for this run.\n",
     );
-    process.exit(0);
+    return;
   }
   process.stdout.write(`${renderTable(rows, lang)}\n`);
 }

package/pipeline/scripts/council-view.mjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// council-view.mjs  -  what each reviewer found, and what triage did with it.
+//
+// Phase 4 dispatches three reviewers, anonymizes their findings so the judge
+// cannot mark its own homework, and reports the verdict. Everything needed to
+// answer "which model found this, and was it kept" is already on the state -
+// reviewers[].findings, anonymizationMap.labelToModel, triage.accepted -  and
+// nothing ever renders it. run-metrics.mjs reduces it to a ratio; the rows
+// behind the ratio are not visible anywhere.
+//
+// This is the panel view llm-council shows as its stage-1 tabs, built from
+// state that already exists. No model call, no new field, no new phase.
+//
+// De-anonymization is deliberate and safe here: the map is read AFTER triage
+// has ruled, so nothing this prints can bias the judgement it describes. The
+// map never goes into a prompt; this is a report.
+//
+// Usage:
+//   council-view.mjs <agent-state.json> [--json] [--iteration N]
+//
+// Exit codes: 0 rendered, 2 nothing to render (no review iterations), 64 usage.
+
+import { readFileSync } from "node:fs";
+
+const argv = process.argv.slice(2);
+const JSON_OUT = argv.includes("--json");
+const iterFlag = argv.indexOf("--iteration");
+const ONLY = iterFlag !== -1 ? Number(argv[iterFlag + 1]) : null;
+const file = argv.find((a) => !a.startsWith("--") && a !== String(ONLY));
+// `--iteration` with nothing after it made ONLY NaN, and `it.iteration === NaN`
+// is never true, so a state full of iterations exited 2 - which /multi-agent:log
+// is told to read as "the run never reached Phase 4" and quietly omit. A usage
+// error has to look like one.
+const BAD_ITERATION = iterFlag !== -1 && !Number.isInteger(ONLY);
+
+function die(msg, code) {
+  process.stderr.write(msg + "\n");
+  process.exitCode = code;
+}
+
+function verdictOf(triage, fingerprint, issue, fileName) {
+  for (const bucket of ["accepted", "deferred", "rejected"]) {
+    for (const entry of Array.isArray(triage?.[bucket]) ? triage[bucket] : []) {
+      // Only `accepted[]` is a flat finding. triage-output.schema.json defines a
+      // deferred or rejected item as `{ finding, reason }` - the reason is the
+      // point of those buckets - so reading the id off the wrapper made every
+      // ruled-out finding render as `unruled`, which is exactly the column this
+      // view exists to show.
+      const f = entry?.finding ?? entry;
+      if (fingerprint && f?.fingerprint === fingerprint) return bucket;
+      if (!fingerprint && f?.file === fileName && f?.issue === issue) return bucket;
+    }
+  }
+  return "unruled";
+}
+
+function main() {
+  if (!file) return die("usage: council-view.mjs <agent-state.json> [--json] [--iteration N]", 64);
+  if (BAD_ITERATION) return die("council-view: --iteration needs an integer", 64);
+  let state;
+  try {
+    state = JSON.parse(readFileSync(file, "utf8"));
+  } catch (e) {
+    return die(`council-view: cannot read ${file}: ${e.message}`, 64);
+  }
+
+  const iterations = Array.isArray(state?.reviewIterations) ? state.reviewIterations : [];
+  const wanted = ONLY == null ? iterations : iterations.filter((it) => it?.iteration === ONLY);
+  if (wanted.length === 0) return die("council-view: no review iterations on this state", 2);
+
+  const out = [];
+  for (const it of wanted) {
+    // Absent map is the normal state for a run written before anonymization,
+    // and for one where every reviewer timed out. Say "unknown" rather than
+    // guessing a model, the same way run-metrics.mjs degrades.
+    const map = it?.anonymizationMap?.labelToModel || {};
+    const triage = it?.triage || {};
+    const rows = [];
+    for (const r of Array.isArray(it?.reviewers) ? it.reviewers : []) {
+      const model = typeof r?.model === "string" && r.model ? r.model : "unknown";
+      for (const f of Array.isArray(r?.findings) ? r.findings : []) {
+        rows.push({
+          model,
+          severity: f?.severity || "",
+          file: f?.file || "",
+          line: f?.line ?? "",
+          issue: f?.issue || "",
+          fingerprint: f?.fingerprint || null,
+          corroboration: f?.corroboration?.count ?? null,
+          of: f?.corroboration?.of ?? null,
+          verdict: verdictOf(triage, f?.fingerprint, f?.issue, f?.file),
+        });
+      }
+    }
+    out.push({
+      iteration: it?.iteration ?? null,
+      reviewers: Object.keys(map).length ? map : null,
+      findings: rows,
+    });
+  }
+
+  if (JSON_OUT) {
+    process.stdout.write(JSON.stringify(out, null, 2) + "\n");
+    return;
+  }
+
+  const lines = [];
+  for (const block of out) {
+    lines.push(`## Council view  -  iteration ${block.iteration ?? "?"}`);
+    lines.push("");
+    if (block.findings.length === 0) {
+      lines.push("No reviewer returned a finding in this iteration.");
+      lines.push("");
+      continue;
+    }
+    // Per-model totals first: the ratio is the summary, the rows are the evidence.
+    const byModel = new Map();
+    for (const r of block.findings) {
+      const e = byModel.get(r.model) || { raw: 0, accepted: 0 };
+      e.raw += 1;
+      if (r.verdict === "accepted") e.accepted += 1;
+      byModel.set(r.model, e);
+    }
+    lines.push("| Reviewer | Raised | Accepted |");
+    lines.push("| -------- | ------ | -------- |");
+    for (const [m, e] of byModel) lines.push(`| ${m} | ${e.raw} | ${e.accepted} |`);
+    lines.push("");
+    lines.push("| Reviewer | Severity | Where | Finding | Seen by | Triage |");
+    lines.push("| -------- | -------- | ----- | ------- | ------- | ------ |");
+    for (const r of block.findings) {
+      const seen = r.corroboration == null ? "-" : `${r.corroboration}/${r.of}`;
+      const where = r.file ? `${r.file}:${r.line}` : "-";
+      lines.push(
+        `| ${r.model} | ${r.severity} | ${where} | ${r.issue.replace(/\|/g, "\\|")} | ${seen} | ${r.verdict} |`,
+      );
+    }
+    lines.push("");
+  }
+  // `process.exitCode`, never `process.exit()`: stdout to a pipe is async and
+  // exiting on the next line truncates a long table at the pipe buffer.
+  process.stdout.write(lines.join("\n"));
+}
+
+main();

package/pipeline/scripts/phase-tracker.sh

@@ -570,7 +570,10 @@ tracker_next_hint() {
   [ "${TRACKER_QUIET:-0}" = "1" ] && return 0
   name=$(load_state | jq -r --arg id "$pid" '(.phases[] | select(.id == $id) | .name) // ""')
   case "$(host_kind)" in
-    claude) mirror="TaskUpdate(\"Phase $pid $name\", status=\"$status\")" ;;
+    # Not every Claude Code build ships the tile API, and the shell cannot see
+    # the model's tool list. Naming the fallback on the same line is what keeps a
+    # build without TaskUpdate from advancing eight phases in silence.
+    claude) mirror="TaskUpdate(\"Phase $pid $name\", status=\"$status\") - or, if TaskUpdate is not one of your tools, reprint the card above inside your reply text" ;;
     codex) mirror="update_plan: set step \"Phase $pid $name\" to $status (send the FULL step list, it is not a delta)" ;;
     *) mirror="no task widget on this host - reprint the card above inside your reply text" ;;
   esac
@@ -1166,10 +1169,24 @@ GATE
     }
     case "$(host_kind)" in
       claude)
+        # The native tile API is not in every Claude Code build. This script
+        # cannot probe the model's tool list, and a run that fires nothing and
+        # says nothing is the failure that reached a user: the tracker state was
+        # written correctly, every phase advanced, and the screen stayed empty
+        # for the whole run. So the fallback is named here rather than assumed,
+        # and the branch is taken where the information actually lives - the
+        # model knows which tools it has, the shell does not.
         echo "REQUIRED  -  create one native tile per phase, in this exact order,"
         echo "BEFORE any TaskUpdate. The widget renders by creation order, not by"
         echo "phase number, so an out-of-order call scrambles the stack."
         echo "$tiles_state" | jq -r '.phases[] | "  TaskCreate(subject: \"Phase \(.id) \(.name)\")"'
+        echo
+        echo "IF TaskCreate IS NOT ONE OF YOUR TOOLS this build has no native tile"
+        echo "API. Do not skip the signal: the card below IS the widget then, and"
+        echo "it must be reprinted inside your reply at every phase boundary  - "
+        echo "tool output is collapsed, so a card left in stdout never arrives."
+        echo
+        render
         ;;
       codex)
         echo "REQUIRED  -  register the plan in ONE update_plan call with this step"