amicus 4.8.0 → 4.9.0

package/src/council/chair-fallback.js

@@ -0,0 +1,95 @@
+// src/council/chair-fallback.js
+'use strict';
+
+/**
+ * @module council/chair-fallback
+ * Chair fallback promotion + attempt classification for the headless chair
+ * walk. Moved verbatim from run-chair.js@eb0ff79c:25-104 (v4.9 W4 size-gate
+ * split, zero behavior): pickFallbackChair (spec §4 promotion) and
+ * classifyChairAttempt (spec §8 LC-5 outcome taxonomy), each with its full
+ * docblock. run-chair.js re-exports both, so every existing import path
+ * (run.js mid-walk, run-server.js pre-seed, the test suites) is unchanged.
+ */
+
+/**
+ * Chair fallback promotion (spec §4): the highest peers-only street-cred
+ * model from `council stats` that is not a bench seat and not the failed
+ * chair. "Highest street-cred" = BEST = numerically LOWEST mean rank
+ * (deriveReliability's avgStreetCredPeersOnly; lower is better).
+ *
+ * The reserved seat name 'claude' is never eligible (v4.1 §4.4 "never chairs"):
+ * a --claude-review run puts a real 'claude' row in the ledger, so without this
+ * filter a LATER run could promote it and walk straight past the pre-flight
+ * --chair claude guard — with no Claude leg to launch.
+ *
+ * v4.7 GOA-7 D11: exclusions test the group key AND aliases[]; the promoted
+ * name is aliases[0] (most-recent alias) so the launch string stays routable
+ * through the same alias policy both call sites (run.js mid-walk, run-server.js
+ * pre-seed) already resolve.
+ * @returns {string|null}
+ */
+function pickFallbackChair(statsRows, bench, failedChair) {
+  const benchSet = new Set(bench);
+  // v4.7 GOA-7 D11: an aggregate's identity is its key PLUS every alias it was
+  // observed under — post-D10 keys may be executable ids while bench/o.chair
+  // stay alias-space, so every exclusion tests the whole name set (a bench
+  // seat's resolved-keyed group must never be promoted as its own chair).
+  // The LAUNCHED name is aliases[0] (most-recent alias): alias-space names
+  // re-enter the router's alias bridge and current key/gateway policy; a raw
+  // executable id would dodge them (divergent-vendor forms, openrouter-
+  // literals under --gateway direct, dropped aliases). aliases[] is non-empty
+  // for every ledger-derived group; the bare-model fallback covers pre-D10
+  // aggregate shapes only.
+  const names = (r) => [r.model, ...(Array.isArray(r.aliases) ? r.aliases : [])];
+  const excluded = (r) => names(r).some(n => n === 'claude' || benchSet.has(n) || n === failedChair);
+  // v4.8 PR4a: every sort term is read off the row, so CANDIDATE SELECTION is
+  // independent of the order `statsRows` arrives in — previously that order
+  // (deriveReliability's Map insertion order = council-ledger.jsonl row order)
+  // silently decided every exact street-cred tie, and such ties are an ordinary
+  // arithmetic outcome. Terms: street cred (lower mean rank = better), then
+  // council appearances, then model id for a guaranteed total order. ⚠️ `runs`
+  // is the count of DISTINCT runIds across the group's ledger rows (v4.8 PR4b
+  // R4b-1, ledger-stats.js's countRuns) — one council run contributes 1 however many
+  // seats that executable filled, and rows from `judged:false` runs that
+  // contributed no street cred still count. It is a tie-break, never a ranking
+  // signal. Always present on deriveReliability output; the default serves
+  // fixtures.
+  // Full rationale + the tie arithmetic: tests/council/run-chair.test.js.
+  const runsOf = (r) => (typeof r.runs === 'number' ? r.runs : 0);
+  const candidates = (statsRows || [])
+    .filter(r => !excluded(r) && typeof r.avgStreetCredPeersOnly === 'number')
+    .sort((a, b) => (a.avgStreetCredPeersOnly - b.avgStreetCredPeersOnly)
+      || (runsOf(b) - runsOf(a))
+      || (a.model < b.model ? -1 : a.model > b.model ? 1 : 0));
+  if (!candidates.length) { return null; }
+  const top = candidates[0];
+  return (Array.isArray(top.aliases) && top.aliases.length) ? top.aliases[0] : top.model;
+}
+
+/**
+ * Outcome taxonomy for one fallback-walk attempt (spec §8, LC-5). The ch4
+ * VERDICT repair is deliberately NOT an attempt: its chair leg already
+ * completed — only the verdict line is being re-prompted — and the outcome
+ * enum has no honest value for it.
+ * @param {object|null} rawLeg the UNFILTERED leg (attemptChair nulls `leg` on
+ *   failure; this is the one before that narrowing, so a failed leg document
+ *   is still visible here)
+ * @param {object|null} [errorDoc] set when the launch never produced a wave
+ *   at all (pre-flight refusal) — the only source of a reason in that case
+ * @returns {{outcome: 'completed'|'error'|'timeout'|'no-output', reason: string|null}}
+ */
+function classifyChairAttempt(rawLeg, errorDoc) {
+  if (!rawLeg) {
+    const reason = (errorDoc && (errorDoc.message || errorDoc.reason)) || 'no leg document';
+    return { outcome: 'error', reason };
+  }
+  if (rawLeg.status === 'timeout') { return { outcome: 'timeout', reason: rawLeg.reason || null }; }
+  if (rawLeg.status === 'complete') {
+    const hasOutput = rawLeg.summary && String(rawLeg.summary).trim();
+    return hasOutput ? { outcome: 'completed', reason: null }
+      : { outcome: 'no-output', reason: rawLeg.reason || null };
+  }
+  return { outcome: 'error', reason: rawLeg.reason || rawLeg.error || String(rawLeg.status) };
+}
+
+module.exports = { pickFallbackChair, classifyChairAttempt };

package/src/council/debate.js

@@ -12,6 +12,11 @@
  */
 
 const { peersOf, unattributedPeerDrops } = require('./peer-split');
+// v4.9 W11 (PR1F-2): the ONE runStats row builder. This module is DI-free, not
+// require-free (it already takes ./peer-split), and ./run-stats-entry is
+// require-FREE by its own design contract precisely so consumers outside
+// ./run-assemble's graph can import it — so this adds only a leaf edge.
+const { buildRunStatsEntry } = require('./run-stats-entry');
 
 // __proto__: null — an inherited/unknown action (e.g. "toString") must fall
 // through the `|| 'no-response'` guards below and in run-debate.js, never
@@ -142,33 +147,45 @@ function decorateRecord(record, debateFindings) {
 }
 
 /**
- * runStats rows for the debate legs (spec §5.5), plus v4.7 D2/E4's row-per-launch
- * extras: role is 'rebuttal' | 'revote' for the primary defense/re-vote legs,
- * 'superseded' for an original leg a successful repair replaced, and 'repair' for
- * a repair attempt that itself never became usable (error status rides naturally
- * off the raw leg). The rebuttal/revote legs never enter meta.models, so the
- * ledger stays one row per (run × model × resolvedModel) pair — a debate round
- * can never ADD a row (v4.8 PR4b: meta.models is still the row driver, and the
- * pair fan-out only splits an alias whose own joinable rows resolved
- * differently). DEBATE_ROLES remains the debate-role
- * vocabulary (rebuttal/revote); the ledger's overwrite protection for ALL FOUR
- * of these row-per-launch roles — rebuttal, revote, superseded AND repair —
- * lives in ledger.js's own LEDGER_JOIN_ROLES allowlist (v4.7 D4, Task 7):
- * a role not named there never joins, full stop, regardless of which module
+ * runStats rows for the debate legs (spec §5.5), plus v4.7 D2/E4's row-per-launch extras: role is
+ * 'rebuttal' | 'revote' for the primary defense/re-vote legs, 'superseded' for an original leg a
+ * successful repair replaced, and 'repair' for a repair attempt that itself never became usable
+ * (error status rides naturally off the raw leg). The rebuttal/revote legs never enter meta.models,
+ * so the ledger stays one row per (run × model × resolvedModel) pair — a debate round can never ADD
+ * a row (v4.8 PR4b: meta.models is still the row driver, and the pair fan-out only splits an alias
+ * whose own joinable rows resolved differently). DEBATE_ROLES remains the debate-role vocabulary
+ * (rebuttal/revote); the ledger's overwrite protection for ALL FOUR of these row-per-launch roles —
+ * rebuttal, revote, superseded AND repair — lives in ledger.js's own LEDGER_JOIN_ROLES allowlist
+ * (v4.7 D4, Task 7): a role not named there never joins, full stop, regardless of which module
  * produced the row or whether it is even in DEBATE_ROLES.
  * @param {{defenseLegs: Array, revoteLegs: Array, supersededLegs?: Array,
  *   repairLegs?: Array}} args leg metadata
  * @returns {Array<object>}
  */
 function debateRunStatsRows({ defenseLegs, revoteLegs, supersededLegs, repairLegs }) {
-  const mk = (role) => (l) => ({
-    model: l.model, role, wasChair: false, conformance: l.conformance || 'clean',
-    status: l.status || 'unknown',
-    durationMs: typeof l.durationMs === 'number' ? l.durationMs : null,
-    usage: l.usage || null,
-    ...(l.waveId ? { waveId: l.waveId } : {}),
-    ...(l.resolvedModel ? { resolvedModel: l.resolvedModel } : {}),
-  });
+  // v4.9 W11 (PR1F-2): ONE builder — debate rows take the entry's key order, its defaults and its
+  // emit-when-set rules instead of a fourth hand-rolled body. ⚠️ Nothing propagates on its OWN (claim
+  // corrected in W14): `mk` hands the entry a SYNTHETIC leg of five fields plus three explicit params,
+  // so seat/findingsUnverified/repairRefused/summary — and any future leg-sourced field — reach these
+  // rows ONLY by widening THIS list. MEASURED, already shipped: W13's `ttftMs` rides the leg into the
+  // entry and debate rows do not carry it. Widening is a behaviour change needing its own pins; filed.
+  // ⚠️ The four lists hold NORMALIZED rows, not leg docs, and their model fields MIRROR the entry's
+  // `leg` contract: `l.model` is the ALIAS and `l.resolvedModel` the executable id, where the entry
+  // reads `leg.model` AS the resolved id and takes the alias as its own `model` — passing `l`
+  // unchanged would stamp the alias into `resolvedModel` on 118 of the 137 measured rows. Holding
+  // `summary`/`seat` back is deliberate too: no runStats row has ever carried review prose, and
+  // `seat` here is a materializeDebate filename input, not a seat OBJECT (pin G1b). ⚠️ The re-key's
+  // ONE divergence from the hand-rolled body is MEASURED-DEAD — a normalized row with `model`
+  // undefined but `resolvedModel` set now emits the resolved id AS `model`, where the old body left
+  // the key out of the JSON; `l.model` was an alias STRING on 137/137 census invocations, so no
+  // producer emits that shape today (pin G1d — dead, not impossible). ⚠️ `l.status || 'unknown'` is
+  // GONE, not moved: it never fired and cannot — result-schema.js :: buildRunResult applies its own
+  // `metadata.status || 'unknown'` a layer below. The MEASURED census and every pin named here live
+  // in tests/council/runstats-byte-order.test.js.
+  const mk = (role) => (l) => buildRunStatsEntry({
+    leg: { status: l.status, durationMs: l.durationMs, usage: l.usage,
+      waveId: l.waveId, model: l.resolvedModel },
+    model: l.model, role, conformance: l.conformance });
   return [
     ...(defenseLegs || []).map(mk('rebuttal')),
     ...(revoteLegs || []).map(mk('revote')),

package/src/council/findings.js

@@ -142,7 +142,7 @@ function validateFindings(jsonText) {
   // ⚠️ v4.4.1 FINAL-REVIEW C — a body that parses to nothing usable.
   // `JSON.parse('null')` SUCCEEDS: it returns null and throws nothing, so the catch
   // above never sees it and every `parsed.<key>` below threw
-  // `TypeError: Cannot read properties of null`. Because run-stages.js:164 calls this
+  // `TypeError: Cannot read properties of null`. Because run-stages.js:152 calls this
   // from inside run.js's try/catch, ONE seat emitting a `null` body aborted an entire
   // PAID council as exit 1 rather than degrading that seat — the fail-closed shape
   // this release exists to remove.
@@ -166,7 +166,8 @@ function validateFindings(jsonText) {
 
   // ⚠️ LC-10 (owner ruling, 2026-07-26). A review that read the material and found
   // nothing is a VALID review — the anti-sycophancy clause shipped in every Stage-1
-  // briefing says so verbatim ("An empty severity category is a valid result"), and
+  // review briefing says so verbatim ("An empty severity category is a valid result";
+  // task briefings state the same rule in claims wording — v4.9 W6), and
   // rejecting it structurally pressured models into inventing findings to satisfy
   // the schema. costgate01's grok did exactly that, and the fabrication reached
   // tally.json, the street-cred rankings, the chair synthesis and a human decision.

package/src/council/ledger.js

@@ -105,8 +105,8 @@ const { benchLegs, credFor, splitFindingsBySeat } = require('./ledger-join');
  * most-recently-seen-first, and pickFallbackChair LAUNCHES `aliases[0]`, so
  * first-occurrence anchoring (what a naive `new Map(model+'\0'+resolved)`
  * gives for free) promotes the executable-id-shaped name over the short alias
- * on `--models gpt-5,openai/gpt-5,gpt-5` — the form run-chair.js:48-52 argues
- * against. On a bench where no alias repeats AND no alias has more than one
+ * on `--models gpt-5,openai/gpt-5,gpt-5` — the form run-chair.js :: pickFallbackChair
+ * (body in chair-fallback.js since the v4.9 W4 split) argues against. On a bench where no alias repeats AND no alias has more than one
  * joinable runStats row, lastIndexOf === indexOf and the row set and its order
  * are unchanged from pre-PR4b.
  *

package/src/council/parse-stage2.js

@@ -4,8 +4,9 @@
 /**
  * @module council/parse-stage2
  * Stage-2 output parsing for the headless council engine (spec §5): the
- * judge's trailing JSON block ({ranking, adjudications}) and the chair's
- * final `VERDICT:` line. Shares last-JSON-block extraction with findings.js.
+ * judge's trailing JSON block ({ranking, adjudications}) and the chair's final
+ * terminal line — `VERDICT:` on a review run, `ANSWER:` on a task run (v4.9
+ * W7 #146). Shares last-JSON-block extraction with findings.js.
  * Pure — the ≤2-repair loop lives in run-stages.js; the tri-state
  * (clean|repaired|unstructured) is recorded by the driver.
  */
@@ -14,6 +15,16 @@ const { lastJsonBlock } = require('./findings');
 
 const JUDGE_VERDICTS = ['agree', 'dispute', 'neutral'];
 const CHAIR_VERDICTS = ['Ship it', 'Fix these first', 'Fundamental rethink'];
+/**
+ * The TASK chair's scale (v4.9 W7, #146). Independently spelled from
+ * briefings-chair-task.js :: CHAIR_ANSWER_VALUES exactly as CHAIR_VERDICTS is
+ * from briefings-chair.js :: CHAIR_VERDICT_VALUES; both pairs are drift-pinned
+ * in tests/council/chair-scale-drift.test.js (named mutant ANSWERSCALEDRIFT).
+ * ⚠️ The two scales MUST stay disjoint — that disjointness plus the distinct
+ * keyword is what makes parseChairVerdict and parseChairAnswer unable to read
+ * each other's terminal line.
+ */
+const CHAIR_ANSWERS = ['Converged', 'Split', 'Insufficient'];
 
 /**
  * Parse + shape-validate one judge's output.
@@ -38,7 +49,7 @@ function parseJudgeOutput(text, { labels, findingIds }) {
   // ⚠️ v4.4.1 FINAL-REVIEW C. `JSON.parse('null')` SUCCEEDS — it returns null and
   // throws nothing — so a body of literal `null` sailed past the catch above and
   // `parsed.ranking` threw `TypeError: Cannot read properties of null`. parseDebateDefense
-  // (:129) and parseRevote (:167) below already carried this `!parsed` guard; the judge
+  // (parse-stage2.js :: parseDebateDefense) and parseRevote (parse-stage2.js :: parseRevote) below already carried this `!parsed` guard; the judge
   // path and findings.js's validateFindings did not, which made it an asymmetry among
   // five consumers of one extractor rather than a new rule. Guarded on BOTH derefs so
   // a `null` body reports exactly what a keyless `{}` body already reported —
@@ -79,28 +90,35 @@ function parseJudgeOutput(text, { labels, findingIds }) {
 }
 
 /** Per-phrase `^<phrase>(?![A-Za-z0-9])` matchers — prefix-anchored, case-sensitive. */
-const CHAIR_VERDICT_PREFIXES = CHAIR_VERDICTS.map(
+const phrasePrefixes = (phrases) => phrases.map(
   (v) => new RegExp('^' + v.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '(?![A-Za-z0-9])')
 );
+const CHAIR_VERDICT_PREFIXES = phrasePrefixes(CHAIR_VERDICTS);
+const CHAIR_ANSWER_PREFIXES = phrasePrefixes(CHAIR_ANSWERS);
+const VERDICT_LINE = /^\s*VERDICT:\s*(.+?)\s*$/;
+const ANSWER_LINE = /^\s*ANSWER:\s*(.+?)\s*$/;
 
 /**
- * Parse the chair's final verdict line. Last matching `VERDICT:` line wins. A
- * line matches when the text after `VERDICT:` equals a canonical phrase, or
- * starts with one followed by a word boundary (trailing rationale, e.g.
- * `VERDICT: Fix these first — <gaps>`). Returns the canonical phrase, not the
- * trailing text.
- * @param {string} text
- * @returns {string|null} one of CHAIR_VERDICTS, or null
+ * The chair's terminal line, whichever keyword carries it. Last matching line
+ * wins. A line matches when the text after the keyword equals a canonical
+ * phrase, or starts with one followed by a word boundary (trailing rationale,
+ * e.g. `VERDICT: Fix these first — <gaps>`). Returns the canonical phrase,
+ * never the trailing text.
+ *
+ * v4.9 W7 generalized the matcher rather than copying it, on the W6
+ * `composeWith` precedent: the review path delegates, so it is byte-identical
+ * by construction and every tolerance this parser earned in production
+ * (live-gate bug runId b89b67d1 among them) holds for both intents at once.
  */
-function parseChairVerdict(text) {
+function parseTerminalLine(text, lineRe, phrases, prefixes) {
   let found = null;
   for (const line of String(text || '').split('\n')) {
-    const m = line.match(/^\s*VERDICT:\s*(.+?)\s*$/);
+    const m = line.match(lineRe);
     if (!m) { continue; }
     const rest = m[1];
-    for (let i = 0; i < CHAIR_VERDICTS.length; i++) {
-      if (rest === CHAIR_VERDICTS[i] || CHAIR_VERDICT_PREFIXES[i].test(rest)) {
-        found = CHAIR_VERDICTS[i];
+    for (let i = 0; i < phrases.length; i++) {
+      if (rest === phrases[i] || prefixes[i].test(rest)) {
+        found = phrases[i];
         break;
       }
     }
@@ -108,6 +126,35 @@ function parseChairVerdict(text) {
   return found;
 }
 
+/**
+ * Parse the chair's final `VERDICT:` line (review intent).
+ * @param {string} text
+ * @returns {string|null} one of CHAIR_VERDICTS, or null
+ */
+function parseChairVerdict(text) {
+  return parseTerminalLine(text, VERDICT_LINE, CHAIR_VERDICTS, CHAIR_VERDICT_PREFIXES);
+}
+
+/**
+ * Parse the chair's final `ANSWER:` line (task intent, #146).
+ * @param {string} text
+ * @returns {string|null} one of CHAIR_ANSWERS, or null
+ */
+function parseChairAnswer(text) {
+  return parseTerminalLine(text, ANSWER_LINE, CHAIR_ANSWERS, CHAIR_ANSWER_PREFIXES);
+}
+
+/**
+ * The run-intent dispatcher run-chair.js parses through. `intent` is the W5
+ * channel (`'task'` | absent); anything else reads the VERDICT line
+ * (fail-closed), so a review run is byte-identical to the direct call.
+ * @param {string} text
+ * @param {string} [intent]
+ */
+function parseChairTerminal(text, intent) {
+  return intent === 'task' ? parseChairAnswer(text) : parseChairVerdict(text);
+}
+
 const DEBATE_ACTIONS = ['defend', 'amend', 'withdraw'];
 const REVOTE_VERDICTS = ['agree', 'dispute', 'neutral'];
 
@@ -189,5 +236,6 @@ function parseRevote(text, expectedIds) {
 
 module.exports = {
   parseJudgeOutput, parseChairVerdict, CHAIR_VERDICTS, JUDGE_VERDICTS,
+  parseChairAnswer, parseChairTerminal, CHAIR_ANSWERS,
   parseDebateDefense, parseRevote, DEBATE_ACTIONS, REVOTE_VERDICTS,
 };

package/src/council/report-cost.js

@@ -0,0 +1,61 @@
+// src/council/report-cost.js
+'use strict';
+
+/**
+ * @module council/report-cost
+ * The report model's COST TABLE: `runStats[]` (+ the optional wave total) to the
+ * `{rows, total}` half of the neutral model `council/report.js :: toModel`
+ * returns. Extracted from ./report (v4.9 W8 T-A) for the same reason
+ * ./report-md exists — report.js was at 296/300 and the task-intent fork it had
+ * to grow did not fit. Nothing here is task-aware: this moved to make ROOM, and
+ * the rendered bytes of every existing report are unchanged (measured: the four
+ * report suites, including both .snap documents, are green across the move).
+ *
+ * ⚠️ NO back-require of ./report, unlike ./report-md and ./report-html — this
+ * module needs neither TIER_ORDER nor SYMBOL, so report.js requires it eagerly
+ * at load and there is no cycle to keep lazy.
+ */
+
+const { sumWaveUsage } = require('../utils/pricing');
+
+// Cost-row role tag (Plan 2 final review F1, extended v4.7 D6): #83 gave
+// judges their own runStats row, so a bench model can now appear twice
+// (seat + judge), indistinguishable by `model` alone. v4.7's row-per-launch
+// producers (chair-attempt/repair/superseded) create the exact same
+// collision for their model. Tag ONLY these four roles — old verdicts have
+// none of them, so chair/critic/lens/seat rows stay byte-identical to their
+// historical rendering (report.test.js:189-199 pins the judge case exactly).
+// Object.create(null): a plain `{...}` literal inherits Object.prototype, so a role
+// literally named 'constructor'/'toString'/etc would resolve to an inherited (truthy)
+// function via bracket lookup instead of `undefined` — silently corrupting that row's
+// rendered model label. A null-prototype object has no inherited keys to collide with.
+// ⚠️ Module scope, where toModel rebuilt it per call: it is a constant lookup that no
+// caller can reach (not exported) and nothing mutates. Behaviour is identical — the
+// digests in the T-A step-1 evidence are byte-for-byte the pre-move ones.
+const ROLE_SUFFIX = Object.create(null);
+ROLE_SUFFIX.judge = 'judge';
+ROLE_SUFFIX['chair-attempt'] = 'chair-attempt';
+ROLE_SUFFIX.repair = 'repair';
+ROLE_SUFFIX.superseded = 'superseded';
+
+/**
+ * @param {Array<object>} runStats the verdict's runStats rows (already defaulted to [])
+ * @param {object} [wave] optional wave.json — its usage total WINS when it carries one
+ * @returns {{rows: Array<{model: string, status: string, durationMs: number, cost: object|null}>, total: object|null}}
+ */
+function buildCostModel(runStats, wave) {
+  // v4.8 PR5a T5: name the row by its SEAT when it has one. On a twin bench the four
+  // seat/judge rows were previously indistinguishable. Depends on T4 — with T5 alone only
+  // the two seat rows separate, because judge rows carried no seat until then.
+  // ⚠️ Only seat and judge rows carry one: repair, superseded and debate rows still
+  // collapse on a twin, and the chair row is not a bench seat at all. Disclosed, not fixed.
+  const rows = runStats.map(r => ({
+    model: ROLE_SUFFIX[r.role] ? `${r.seat || r.model} (${ROLE_SUFFIX[r.role]})` : (r.seat || r.model),
+    status: r.status, durationMs: r.durationMs,
+    cost: r.usage && r.usage.cost ? r.usage.cost : null,
+  }));
+  const total = (wave && wave.usage && wave.usage.cost) ? wave.usage.cost : sumWaveUsage(runStats).cost;
+  return { rows, total };
+}
+
+module.exports = { buildCostModel };

package/src/council/report-html.js

@@ -65,17 +65,39 @@ function renderHtml(m) {
   // formatDegrade) rendered into the row, not a second HTML dialect.
   const lostRows = (m.degrades || []).map(d =>
     `<tr><td>${esc(d.channel)}</td><td>${esc(formatDegrade(d).trimEnd())}</td></tr>`).join('');
+  // v4.9 W8 T-A: kind:'info' records are announcements, not losses (`report.js ::
+  // toModel` splits them). A <ul>, not a second table: the debate lists below use
+  // exactly this idiom, and a note carries no channel column's worth of weight.
+  const noteItems = (m.notes || []).map(d => `<li>${esc(formatDegrade(d).trimEnd())}</li>`).join('');
   const meta = [h.date, h.chair ? `chair: ${h.chair}` : null, `council: ${h.council.join(', ')}`,
     h.claudeInCouncil ? 'Claude in council' : null].filter(Boolean).map(esc).join(' · ');
 
   // Heading-over-nothing, same guard idiom as debateSection below: absent or
   // empty degrades ⇒ no section at all, so a clean verdict's HTML stays
   // byte-identical to before this section existed. Losses are headline news,
-  // so the section sits directly after the Verdict-summary table (report-md.js's
-  // renderMd mirrors this placement immediately after the tier loop).
+  // so the section sits directly after the summary tier table (report-md.js's
+  // renderMd mirrors this placement immediately after the tier loop). ⚠️ Named
+  // by ROLE, not by heading text: that heading forks with intent (see
+  // `summaryHeading` below), so 'the Verdict-summary table' was true of review
+  // runs only from B1 onward.
   const lostSection = lostRows
     ? `<h2>What was lost</h2><table><tr><th>Channel</th><th>Notice</th></tr>${lostRows}</table>`
     : '';
+  // Same heading-over-nothing guard, one level quieter: no info records ⇒ nothing
+  // at all, so every report that has none is byte-identical to before this existed.
+  const notesSection = noteItems ? `\n<p><strong>Notes:</strong></p><ul>${noteItems}</ul>` : '';
+  // v4.9 W8 T-A (spec §5.4): the concurrence qualifier rides the tier table on a
+  // TASK run only, placed where a reader of the tiers cannot miss it — the mirror
+  // of report-md.js :: renderMd's placement, pinned SEPARATELY per renderer so
+  // neither can regress silently. Named mutant: QUALIFIERDROP.
+  const qualifier = m.intent === 'task'
+    ? '\n<p class="legend">Tiers report peer concurrence, never verification.</p>' : '';
+  // v4.9 PR #200 round-4 B1: the primary summary heading is named for what the
+  // run PRODUCED — a task run answers, it does not adjudicate a verdict. The
+  // mirror of report-md.js :: renderMd's fork, pinned SEPARATELY per renderer.
+  // A review run renders the identical old string, so both .snap documents and
+  // every shipped review report stay byte-identical. Named mutant: SUMMARYLABEL.
+  const summaryHeading = m.intent === 'task' ? 'Answer summary' : 'Verdict summary';
 
   // m.debate is absent on hand-built models (tests/council/report.test.js calls
   // renderHtml directly with no debate key) — the guard must tolerate that, and
@@ -134,8 +156,8 @@ td.c { text-align: center; }
 </style></head><body>
 <h1>Council Report — ${esc(h.runType)} (${esc(h.runId)})</h1>
 <p class="meta">${meta}</p>
-<h2>Verdict summary</h2>
-<table><tr><th>Tier</th><th>Count</th></tr>${tierRows}</table>${lostSection}
+<h2>${summaryHeading}</h2>
+<table><tr><th>Tier</th><th>Count</th></tr>${tierRows}</table>${qualifier}${lostSection}${notesSection}
 <h2>Adjudication matrix</h2>
 <table><tr><th>Finding</th><th>Sev</th><th>Raiser</th>${judgeHead}<th>Tier</th><th>Decision</th></tr>${matrixRows}</table>
 <p class="legend">✓ agree · ✗ dispute · – neutral · <sup>*</sup> raiser's own vote</p>${m.findings.some(f => f.sameModelCorroboration) ? '\n<p class="legend"><sup>†</sup> corroborated only by another seat running the SAME model — concurrence, not independent support.</p>' : ''}

package/src/council/report-md.js

@@ -27,9 +27,25 @@ function renderMd(m) {
     h.claudeInCouncil ? 'Claude in council' : null].filter(Boolean).join(' · ');
   out.push(`\n_${meta}_\n`);
 
-  out.push('## Verdict summary\n');
+  // v4.9 PR #200 round-4 B1: the section carrying the run's PRIMARY summary is
+  // named for what the run PRODUCED. A task run has no verdict — its chair closes
+  // with `ANSWER:` (`parse-stage2.js :: parseChairTerminal` picks that parser off
+  // the same intent, `verdict.js :: CHAIR_ANSWERS` is its scale) — so 'Verdict
+  // summary' named the wrong artifact on the one heading a skimmer reads. Forked
+  // in BOTH renderers, pinned SEPARATELY per renderer (the R8/street-cred rule:
+  // a shared pin would let either regress silently). Review runs keep the exact
+  // old string, which is what holds both .snap documents byte-identical.
+  // Named mutant: SUMMARYLABEL (tests/council/report-intent.test.js).
+  out.push(m.intent === 'task' ? '## Answer summary\n' : '## Verdict summary\n');
   out.push('| Tier | Count |\n|---|---|');
   for (const t of TIER_ORDER) { out.push(`| ${t} | ${m.tierCounts[t]} |`); }
+  // v4.9 W8 T-A (spec §5.4): the concurrence qualifier, on a TASK run only, and
+  // directly under the counts it qualifies — a reader who reads only the tier
+  // table must not be able to miss it. Gated exactly as the `†` legend below is:
+  // written unconditionally it would shift every later line of every review
+  // report and redden both .snap documents. Named mutant: QUALIFIERDROP
+  // (tests/council/report-intent.test.js).
+  if (m.intent === 'task') { out.push('\n_Tiers report peer concurrence, never verification._'); }
 
   // Heading-over-nothing: emitted ONLY when the run actually degraded, so a
   // clean verdict's report stays byte-identical to before this section
@@ -40,6 +56,16 @@ function renderMd(m) {
     // ONE voice (Plan 1's formatDegrade) — the report must not grow a dialect.
     for (const d of m.degrades) { out.push(`- ${formatDegrade(d).trimEnd()}`); }
   }
+  // v4.9 W8 T-A: kind:'info' records are announcements, not losses (`report.js ::
+  // toModel` splits them), so they get their own list and NOT the '## What was
+  // lost' heading. A bold lead-in rather than an `##` heading — the same weight
+  // the debate sub-lists below carry, because a note is not headline news.
+  // `m.notes &&` matches the `m.degrades || []` tolerance report-html.js already
+  // has: hand-built models in the report suites carry neither key.
+  if (m.notes && m.notes.length) {
+    out.push('\n**Notes:**\n');
+    for (const d of m.notes) { out.push(`- ${formatDegrade(d).trimEnd()}`); }
+  }
 
   out.push('\n## Adjudication matrix\n');
   out.push(`| Finding | Sev | Raiser | ${m.judges.join(' | ')} | Tier | Decision |`);
@@ -94,7 +120,9 @@ function renderMd(m) {
   // human-facing here rather than model-facing. State the clean bench instead
   // of leaving the heading to dangle.
   if (!m.findings.length) {
-    out.push('_No findings were raised on this bench — a clean review is a valid review._\n');
+    out.push(m.intent === 'task'
+      ? '_No adjudicable claims were declared on this bench — an answer whose reasoning is fully inline is a valid answer._\n'
+      : '_No findings were raised on this bench — a clean review is a valid review._\n');
   } else {
     for (const t of TIER_ORDER) {
       const group = m.findings.filter(f => f.tier === t);

package/src/council/report.js

@@ -15,7 +15,9 @@
  * file's own job that narrowed.
  */
 
-const { sumWaveUsage } = require('../utils/pricing');
+// v4.9 W8 T-A: the cost table's model lives in ./report-cost (extraction, this
+// file's headroom). Eager, not lazy: that module back-requires nothing here.
+const { buildCostModel } = require('./report-cost');
 
 const TIER_ORDER = ['Disputed', 'Contested', 'Confirmed', 'Singleton'];
 // __proto__: null — an inherited/unknown vote key (e.g. "toString") must fold as unrecognized, never resolve off Object.prototype.
@@ -117,11 +119,12 @@ function toModel(verdict, wave) {
   // 'council' (verdict.council / meta.models) is the street-cred universe and
   // legitimately includes 'claude' on a --claude-review run (buildTallyInput's
   // run-assemble.js:226, docs/council.md:326). 'judges' is the matrix column
-  // set: SKILL.md:448 / run-stage2.js:61-62 guarantee Claude is judged but
+  // set: SKILL.md:448 / run-stage2.js :: runStage2 (the ROSTER-not-bundle
+  // derivation of `judges`) guarantee Claude is judged but
   // never judges, so its reserved seat must never grow a matrix column — filter
   // it out ONLY when claudeInCouncil is true. This is name+flag gated, not
   // vote-derived: a bench judge that cast zero adjudications (dead/unstructured
-  // leg, run-stages.js:204-207) is still in council/judges and must still get
+  // leg, run-stages.js:192-195) is still in council/judges and must still get
   // its (blank) column — deriving the roster from "who actually voted" would
   // silently delete that column too and break the byte-unchanged-artifact
   // contract for degraded v4.0.1-shaped runs.
@@ -232,50 +235,50 @@ function toModel(verdict, wave) {
     noResponse: verdict.findings.filter(f => f.debate && f.debate.action === 'no-response')
       .map(f => ({ id: f.id, previousTier: f.debate.previousTier, tier: f.tier })),
   };
-  const runStats = verdict.runStats || [];
-  // Cost-row role tag (Plan 2 final review F1, extended v4.7 D6): #83 gave
-  // judges their own runStats row, so a bench model can now appear twice
-  // (seat + judge), indistinguishable by `model` alone. v4.7's row-per-launch
-  // producers (chair-attempt/repair/superseded) create the exact same
-  // collision for their model. Tag ONLY these four roles — old verdicts have
-  // none of them, so chair/critic/lens/seat rows stay byte-identical to their
-  // historical rendering (report.test.js:189-199 pins the judge case exactly).
-  // Object.create(null): a plain `{...}` literal inherits Object.prototype, so a role
-  // literally named 'constructor'/'toString'/etc would resolve to an inherited (truthy)
-  // function via bracket lookup instead of `undefined` — silently corrupting that row's
-  // rendered model label. A null-prototype object has no inherited keys to collide with.
-  const ROLE_SUFFIX = Object.create(null);
-  ROLE_SUFFIX.judge = 'judge';
-  ROLE_SUFFIX['chair-attempt'] = 'chair-attempt';
-  ROLE_SUFFIX.repair = 'repair';
-  ROLE_SUFFIX.superseded = 'superseded';
-  // v4.8 PR5a T5: name the row by its SEAT when it has one. On a twin bench the four
-  // seat/judge rows were previously indistinguishable. Depends on T4 — with T5 alone only
-  // the two seat rows separate, because judge rows carried no seat until then.
-  // ⚠️ Only seat and judge rows carry one: repair, superseded and debate rows still
-  // collapse on a twin, and the chair row is not a bench seat at all. Disclosed, not fixed.
-  const costRows = runStats.map(r => ({
-    model: ROLE_SUFFIX[r.role] ? `${r.seat || r.model} (${ROLE_SUFFIX[r.role]})` : (r.seat || r.model),
-    status: r.status, durationMs: r.durationMs,
-    cost: r.usage && r.usage.cost ? r.usage.cost : null,
-  }));
-  const total = (wave && wave.usage && wave.usage.cost) ? wave.usage.cost : sumWaveUsage(runStats).cost;
+  // v4.9 W8 T-A: ONE read of the run's intent, TWO consumers below — the model's
+  // own `intent` (both renderers fork the spec §5.4 concurrence qualifier on it)
+  // and the header WORD. `=== 'task'` fails everything else CLOSED to review, the
+  // same direction `verdict.js :: buildVerdict` points: it emits the key ONLY as
+  // the literal 'task', so every pre-v4.9 and every review verdict takes this
+  // default and renders byte-identically to HEAD.
+  const intent = verdict.intent === 'task' ? 'task' : 'review';
   return {
     header: {
-      runType: verdict.runType || 'review', runId: verdict.runId, date: verdict.date,
+      // The header WORD, not the key: `runType` is meta's free-form transport
+      // string ('headless' on every wired path), which on a task run names how the
+      // wave ran and not what it was — and the title is the first thing a reader
+      // sees. Forking the VALUE here forks both renderers, which print `h.runType`;
+      // renaming the key would edit two files to say the same thing.
+      runType: intent === 'task' ? 'task' : (verdict.runType || 'review'),
+      runId: verdict.runId, date: verdict.date,
       chair: verdict.chair, council, claudeInCouncil: verdict.claudeInCouncil === true,
     },
+    intent,
     tierCounts: verdict.tierCounts || { Confirmed: 0, Contested: 0, Singleton: 0, Disputed: 0 },
     judges, findings, debate,
     streetCred: verdict.streetCred || [],
     // v4.6 Plan 2: additive and OPTIONAL on the verdict (verdict.js only sets
     // it when the run actually degraded), so a clean verdict's model — and
     // therefore its rendered report — is byte-for-byte unchanged.
-    // Plan 2 final review F2: LOSSES ONLY — a heal is announced on stderr/run.json but
-    // is not a loss (spec D4, §8), so it must never render under "What was
-    // lost". deriveSeatLoss (verdict.js) applies the same kind !== 'heal' filter.
-    degrades: (verdict.degrades || []).filter(d => d.kind !== 'heal'),
-    cost: { rows: costRows, total },
+    // Plan 2 final review F2 + v4.9 W8 T-A: LOSSES ONLY. A heal is announced on stderr/run.json
+    // but is not a loss (spec D4, §8), and neither is v4.9's kind:'info' — `ledger-skipped` says
+    // a task run wrote no reliability rows, which is speech, not damage. Info records ride
+    // `notes`, which both renderers list APART from "What was lost".
+    // ⚠️ NOT the positive `kind === 'degrade'`, and the difference is measured: a record with NO
+    // kind key — hand-written, or parsed off a verdict older than kinds, which
+    // `utils/degrade.js :: formatDegrade` still deliberately serves as 'Notice' — is a loss at
+    // HEAD, and the positive spelling drops it from BOTH lists. Pinned in report-intent.test.js
+    // (named mutant LEGACYDROP, measured).
+    // ⚠️ The other three consumers of this rule AGREE with the line above about kind-less records
+    // as of the v4.9 W9 fix round (council C4): `verdict-seat-loss.js :: deriveSeatLoss` and both
+    // Workspace renderers went from the positive `kind === 'degrade'` — which W9 shipped, and
+    // which silently dropped every pre-kind record — to `kind === undefined || kind ===
+    // 'degrade'`, citing THIS lesson by name. Their kind LISTS still differ from this one's, and
+    // deliberately (over there the question is narrower: which announcements imply a LOST SEAT).
+    // Align the treatment of an ABSENT kind; never the lists.
+    degrades: (verdict.degrades || []).filter(d => d.kind !== 'heal' && d.kind !== 'info'),
+    notes: (verdict.degrades || []).filter(d => d.kind === 'info'),
+    cost: buildCostModel(verdict.runStats || [], wave),
   };
 }