amicus 4.8.1 → 4.9.0

package/src/council/run-assemble.js

@@ -102,10 +102,17 @@ function labelClaudeReview(claudeReview, labels) {
 /**
  * The synthesized runStats row for a review that never ran a leg (v4.1 §4.4).
  * durationMs/usage are null per the never-invent rule — nothing was launched.
+ *
+ * v4.9 W11 (PR1F-2): folded onto buildRunStatsEntry, byte-for-byte (pin G3,
+ * tests/council/runstats-byte-order.test.js). The one-key stand-in leg is the
+ * whole trick: this review COMPLETED (a file the orchestrator authored), so
+ * `status: 'complete'` is a fact, not an invention — and a leg carrying only a
+ * status leaves every other entry field on its never-invent default
+ * (durationMs/usage null, no waveId, no resolvedModel). Passing `leg: null`
+ * instead would emit `status: 'error'` and call a valid review dead.
  */
 function claudeRunStatsRow() {
-  return { model: CLAUDE_SEAT, role: CLAUDE_SEAT, wasChair: false, conformance: 'clean',
-    status: 'complete', durationMs: null, usage: null };
+  return buildRunStatsEntry({ leg: { status: 'complete' }, model: CLAUDE_SEAT, role: CLAUDE_SEAT });
 }
 
 /**
@@ -136,7 +143,7 @@ function buildTallyInput({ runId, date, bench, chair, reviews, judgeResults, cha
     // ONLY when the bench repeats an alias — the one case where the `alias#N`
     // seat ids on findings[].raiserSeat, adjudications[].seat and runStats[].seat
     // resolve to nothing else in the document (meta.models is the ALIAS list).
-    // ⚠️ `seats ?` alone would be VACUOUS: run.js:133 sets o.seats unconditionally
+    // ⚠️ `seats ?` alone would be VACUOUS: run.js:142 sets o.seats unconditionally
     // past the preflight and buildSeats always returns an ARRAY ([] is still
     // truthy), so that spelling writes a full table into tally-input.json,
     // tally.json AND verdict.json on every unique-alias bench.
@@ -152,7 +159,7 @@ function buildTallyInput({ runId, date, bench, chair, reviews, judgeResults, cha
     // joined positionally to meta.models (`claude` is pushed onto that inside
     // run-assemble.js :: buildTallyInput) or to streetCred[].
     // .slice() is defence-in-depth only: the array is shared with
-    // runState.checkpoint (run.js:135) and with both tally inputs. Nothing
+    // runState.checkpoint (run.js:144) and with both tally inputs. Nothing
     // mutates meta.seats — unlike models, which meta.models.push mutates below —
     // so no test can distinguish the copy from the reference.
     ...(Array.isArray(seats) && seats.some(s => s.id !== s.alias) ? { seats: seats.slice() } : {}),
@@ -207,8 +214,10 @@ function buildTallyInput({ runId, date, bench, chair, reviews, judgeResults, cha
   // a repair solo's — run-stage2.js mirrors Stage-1's convention there); a judge
   // whose wave leg died still gets an honest error row.
   // v4.8 PR5a T4 (R5-8): the judge row carries its SEAT. PR4c withheld it because
-  // `joinsLedger` has no 'judge' member, so nothing consumed it; report.js's cost
-  // table does now, and without it a twin bench's two judge rows are identical.
+  // `joinsLedger` has no 'judge' member, so nothing consumed it;
+  // `report-cost.js :: buildCostModel` (the report's cost table, extracted from
+  // report.js in v4.9 W8) does now, and without it a twin bench's two judge rows
+  // are identical.
   // `buildRunStatsEntry` (run-stats-entry.js :: buildRunStatsEntry) applies the
   // shared emit-when-DIFFERENT predicate, so a unique bench stays byte-identical
   // and no new predicate enters the tree.
@@ -261,6 +270,12 @@ function buildChairPacketFile({ runDir, reviews, claudeReview, tallyInput, recor
     // line here and keeps every rendering decision in briefings-chair.js.
     findings: record.findings,
     tierCounts: record.tierCounts, date,
+    // v4.9 W7: the chair's intent is READ OFF the tallied record's meta rather than
+    // added to this signature — run.js already stamps meta.intent emit-when-'task'
+    // (run.js :: runCouncil's mkInput), and both the provisional and the debated
+    // record inherit it by spread. A record with no meta at all (hand-assembled
+    // input, and every pre-W7 caller) composes the review packet.
+    ...(record.meta && record.meta.intent === 'task' ? { intent: 'task' } : {}),
   }) + (debateOutcomes ? '\n\n' + buildDebateAddendum({ outcomes: debateOutcomes }) : '');
   fs.writeFileSync(path.join(runDir, 'chair-packet.md'), packet, { mode: 0o600 });
   return packet;

package/src/council/run-chair.js

@@ -3,7 +3,7 @@
 
 /**
  * @module council/run-chair
- * Chair synthesis + VERDICT-line repair for the headless council driver,
+ * Chair synthesis + terminal-line repair (VERDICT | task ANSWER) for the driver,
  * lifted VERBATIM out of run.js for the 300-line gate (v4.1 Task 0.5). Pure
  * refactor: same launches, same waveIds, same run.json checkpoints, same
  * degradation rules. Launchers come in through `ctx` exactly as run-stages.js
@@ -16,96 +16,18 @@
  */
 
 const stage2 = require('./briefings-stage2');
-const { parseChairVerdict } = require('./parse-stage2');
+const { parseChairTerminal } = require('./parse-stage2');
 const runState = require('./run-state');
 const { isAbortExit } = require('./run-stages');
 const { emitStageStarted, emitStageTerminal } = require('../observe/events');
 const { buildRunStatsEntry } = require('./run-assemble');
-
-/**
- * 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) };
-}
+// v4.9 W4: pickFallbackChair + classifyChairAttempt moved to chair-fallback.js
+// (size-gate split); re-exported below so no caller changes.
+const { pickFallbackChair, classifyChairAttempt } = require('./chair-fallback');
 
 /**
  * Chair chain (attempt → retry → ledger-promoted fallback → give up) plus the
- * single VERDICT-line repair re-prompt.
+ * single terminal-line repair re-prompt (VERDICT, or ANSWER when o.intent is 'task').
  * @param {object} ctx run.js's {o, launchers, addWave, overBudget, scratchDir}
  * @param {{packet: string, degrade: {note: Function}, statsFn: Function,
  *   isSignalled: function(): (number|null)}} args
@@ -126,7 +48,7 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
     const solo = await launchers.launchSolo({
       model, prompt: packet, project: o.runDir, waveId,
       timeout: o.timeout, gateway: o.gateway, noValidateModel: o.noValidateModel,
-      // v4.1 §4.5d: the chair chain (ch1/ch2/ch3) and the ch4 VERDICT repair
+      // v4.1 §4.5d: the chair chain (ch1/ch2/ch3) and the ch4 terminal repair
       // below are the launches a re-armed price gate would refuse LAST, after
       // the whole bench has already been paid for.
       noCostGate: o.noCostGate,
@@ -203,6 +125,27 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
     }
     if (attempt.leg) { actualChair = o.chair; }
     else if (!overBudget()) {
+      // v4.9 W5.4 (V5): the promotion below draws on the reliability ledger,
+      // which task runs never feed (run-finish.js gate 1) — announced once,
+      // kind 'info' (speech, not loss: the sink never flips `degraded` on it).
+      // ⚠️ PR #200 round-3 finding A2 read "announced once" as a promise a flag
+      // had to keep, and reported the note firing once per FAILED ATTEMPT.
+      // MEASURED and refuted: "once" here is STRUCTURAL. This is the
+      // else-arm of the whole fallback walk — ch1 and ch2 have already resolved
+      // above — so it is reached at most once per runChair, which is called
+      // exactly once per run (run.js :: runCouncil). A walk with ch1, ch2 AND
+      // ch3 all failing emits exactly ONE note; pinned in run-chair.test.js
+      // ("task run reaching the promotion step emits EXACTLY ONE info note").
+      // No flag: a flag would only be able to make a once-reached branch fire
+      // less than once.
+      if (o.intent === 'task') {
+        degrade.note({
+          kind: 'info', channel: 'ledger-skipped',
+          what: 'task runs write no reliability rows',
+          why: 'ledger-driven chair promotion draws only on review-run history — task rankings measure concurrence, never defect confirmation',
+          effect: 'fallback candidates come from review runs only; a task-only install has none',
+        });
+      }
       let statsRows = [];
       try { statsRows = statsFn(); } catch { /* no ledger yet */ }
       const fallback = pickFallbackChair(statsRows, o.models, o.chair);
@@ -228,16 +171,16 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
   const chairText = chairLeg ? chairLeg.summary : null;
   let chairConformance = 'clean';
 
-  // ---- Chair VERDICT line (one repair re-prompt, spec §5) ----
-  let overallVerdict = chairText ? parseChairVerdict(chairText) : null;
+  // ---- Chair terminal line — VERDICT, or ANSWER on a task run (v4.9 W7) ----
+  let overallVerdict = chairText ? parseChairTerminal(chairText, o.intent) : null;
   if (chairText && !overallVerdict && !overBudget()) {
     const waveId4 = `${o.runId}-ch4`;
     runState.appendStageWave(o.runDir, 'chair', waveId4);
     const repair = await launchers.launchSolo({
       // ⚠️ LC-12: the synthesis rides along. The chair leg SUCCEEDED — only the
-      // VERDICT line is missing — so a fresh repair session that cannot see the
+      // terminal line is missing — so a fresh repair session that cannot see the
       // synthesis is picking a verdict on an artifact it has never read.
-      model: actualChair, prompt: stage2.buildChairRepairPrompt({ synthesis: chairText }),
+      model: actualChair, prompt: stage2.chairRepairPromptFor(o.intent, { synthesis: chairText }),
       project: o.runDir, waveId: waveId4,
       timeout: o.timeout, gateway: o.gateway, noValidateModel: o.noValidateModel,
       noCostGate: o.noCostGate,
@@ -255,15 +198,17 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
     // (repair.leg)` guard below is therefore load-bearing on that exact
     // distinction: a launched ch4 (a leg document exists, whatever its
     // status) gets its own row so the repair's spend is attributed even when
-    // it never supplies a VERDICT; a ch4 that never even launched gets no
-    // row at all, because there is nothing billed to attribute.
+    // it never supplies a terminal line; a ch4 that never launched gets no
+    // row at all, because there is nothing billed to attribute. The push sits
+    // AFTER the verdict parse so it stamps the ch4 leg's own measured outcome (PR 199 D1).
+    overallVerdict = parseChairTerminal((repair.leg && repair.leg.summary) || '', o.intent);
+    chairConformance = overallVerdict ? 'repaired' : 'unstructured';
     if (repair.leg) {
       chairRows.push(buildRunStatsEntry({
         leg: repair.leg, model: actualChair, role: 'repair', wasChair: false,
+        conformance: overallVerdict ? 'clean' : 'unstructured',
       }));
     }
-    overallVerdict = parseChairVerdict((repair.leg && repair.leg.summary) || '');
-    chairConformance = overallVerdict ? 'repaired' : 'unstructured';
   }
   // A completed chair whose verdict never parsed is 'unstructured' even when
   // the repair was skipped (e.g. the chair leg itself tripped --max-cost).
@@ -273,10 +218,14 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
       channel: 'chair-failed',
       what: 'the council has no chair synthesis',
       why: chairLeg
-        ? 'the chair ran but its output carried no parseable VERDICT: line'
+        ? `the chair ran but its output carried no parseable ${o.intent === 'task' ? 'ANSWER' : 'VERDICT'}: line`
         : `no chair leg completed after the fallback walk — ${chairAttempts.map(a =>
           `${a.waveId.split('-').pop()} ${a.model}: ${a.reason || a.outcome}`).join(' · ')}`,
-      effect: 'the verdict is written with overallVerdict null; will exit degraded (2)',
+      // v4.9 W12 (PR #200 tail C4): the noun forks the way `why` above already
+      // does — a task run is told its ANSWER was lost, not its verdict. The
+      // `overallVerdict` KEY does not fork (verdict.js emits it on both scales),
+      // and `what` above is intent-neutral, so this is the only word that moves.
+      effect: `the ${o.intent === 'task' ? 'answer' : 'verdict'} is written with overallVerdict null; will exit degraded (2)`,
     });
   }
 

package/src/council/run-debate-revote.js

@@ -3,19 +3,22 @@
 
 /**
  * @module council/run-debate-revote
- * v4.8 PR3 Task 1: `legOpts`, `legRow`, and `runRevoteWave` extracted verbatim
- * out of run-debate.js (283/300 — the 300-line-per-file gate) with NO
- * behaviour change. run-debate.js requires all three back; runDebate still
- * calls runRevoteWave for the re-vote mini-wave (spec §5.1).
+ * v4.8 PR3 Task 1: `legOpts`, `legRow`, and `runRevoteWave` extracted verbatim out of
+ * run-debate.js (283/300 — the 300-line-per-file gate) with NO behaviour change.
+ * run-debate.js requires all three back; runDebate still calls runRevoteWave for the
+ * re-vote mini-wave (spec §5.1).
  *
- * That "verbatim" claim held for all three only through Task 1. `legOpts` and
- * `legRow` are still byte-identical to the extraction. `runRevoteWave` is NOT:
- * PR3 Task 6 gave it real seat-binding behaviour — the padded roster + bind
- * (`stage1-bind.js :: bindPaddedWave` since v4.8 SI-27; an inline `bindSeats`
- * call before it), the seat-keyed `byJudge`, the `sanitizeName`'d per-seat
- * repair id, and the `seat` field on the pushed legs (see the function's own
- * docblock below). Do not treat `runRevoteWave` as a behaviour-neutral mirror
- * of the old run-debate.js code — only `legOpts`/`legRow` still are.
+ * That "verbatim" claim held for all three only through Task 1 and now holds for
+ * `legOpts` ALONE: v4.9 W11 (PR1F-2) folded `legRow`'s body onto `buildRunStatsEntry`
+ * (its own docblock points at the diff), so it is no longer byte-identical either.
+ * `runRevoteWave` diverged first — PR3 Task 6 gave it real seat-binding behaviour:
+ * the padded roster + bind (`stage1-bind.js :: bindPaddedWave` since v4.8 SI-27;
+ * an inline `bindSeats` call before it), the seat-keyed `byJudge`, the
+ * `sanitizeName`'d per-seat repair id, and the `seat` field on the pushed legs
+ * (see the function's own docblock below). Do not treat `runRevoteWave` as a
+ * behaviour-neutral mirror of the old run-debate.js code. Since v4.9 W2 (SI-16)
+ * the one-bounded-repair block lives in the in-file `repairRevoteLeg`, called from
+ * runRevoteWave's leg loop — a structural split only, no behaviour change.
  *
  * `isAbortExit` comes from ./run-launch, NEVER from ./run-stages: run-stage2.js:12
  * records that taking it from run-launch.js "is what dissolved the old cycle
@@ -38,6 +41,15 @@ const { sanitizeName } = require('./seats');
 // ./seats, so this leaf stays cycle-free (see the module docblock's cycle-class
 // paragraph above — named, not line-numbered, so it cannot rot).
 const { bindPaddedWave } = require('./stage1-bind');
+// v4.9 W3 (SI-DUP disposition b): the wave's join key for one leg — the bound
+// seat's id, else the bare alias. Was a local `function seatKey` here; now the
+// run-retry-keys.js export (same rule, one home). ./run-retry-keys is
+// REQUIRE-FREE by design (its own docblock), so this leaf stays cycle-free.
+const { seatKey } = require('./run-retry-keys');
+// v4.9 W11 (PR1F-2): the ONE runStats row builder. ./run-stats-entry is REQUIRE-FREE
+// by design, so this leaf stays cycle-free — taking the same function off
+// ./run-assemble would drag that module's whole graph in.
+const { buildRunStatsEntry } = require('./run-stats-entry');
 
 /** Common launch options for every debate leg (judge-isolated `_scratch` cwd). */
 function legOpts(ctx, waveId) {
@@ -50,24 +62,21 @@ function legOpts(ctx, waveId) {
 
 /**
  * v4.7 D2/E4: normalize a raw (possibly leg-absent) leg into the shape
- * debateRunStatsRows' superseded/repair lists expect. Same never-invent-a-waveId
- * discipline as buildRunStatsEntry (run-assemble.js) — only spread `waveId` when
- * the leg genuinely carries one — but keyed on an explicit `model` (the raiser or
- * judge identity), since a leg-absent attempt has no `.model` of its own to read.
- * Threads resolvedModel (the raw leg's .model, the executable id) emit-only-when-set — v4.7 GOA-7 D8.
+ * debateRunStatsRows' superseded/repair lists expect — keyed on an explicit `model` (the
+ * raiser or judge identity), since a leg-absent attempt has no `.model` of its own to
+ * read, and threading resolvedModel emit-only-when-set (v4.7 GOA-7 D8).
+ *
+ * v4.9 W11 (PR1F-2): the never-invent-a-waveId / never-invent-a-duration discipline
+ * this restated is now INHERITED — this is a call to buildRunStatsEntry, whose `leg`
+ * contract this argument already satisfies exactly (a raw leg doc: `.model` IS the
+ * resolved id, `model` here IS the alias). `role` is deliberately not passed: which
+ * role this is depends on which list the caller pushes it onto, and `debate.js :: mk`
+ * stamps it. Its byte diff + the pin that all of it is invisible to `mk`: "FOLD DIFF #2" and G6, tests/council/runstats-byte-order.test.js.
  */
 function legRow(model, leg, conformance) {
-  return leg
-    ? { model, status: leg.status, durationMs: typeof leg.durationMs === 'number' ? leg.durationMs : null,
-        usage: leg.usage || null, conformance, summary: leg.summary || '',
-        ...(leg.waveId ? { waveId: leg.waveId } : {}),
-        ...(leg.model ? { resolvedModel: leg.model } : {}) }
-    : { model, status: 'error', durationMs: null, usage: null, conformance, summary: '' };
+  return buildRunStatsEntry({ leg, model, conformance, summary: leg && leg.summary });
 }
 
-/** The wave's join key for one leg: the bound seat's id, else the bare alias. */
-function seatKey(seat, alias) { return seat ? seat.id : alias; }
-
 /**
  * T5.1 (owner ruling R8), narrowed by T5.5: announce a re-vote leg whose key
  * this wave cannot account for — its key names none of the judges this wave
@@ -132,6 +141,46 @@ function reVoteUnboundNote(waveId, judge, key, leg) {
   };
 }
 
+/**
+ * v4.9 W2 (SI-16): the one bounded repair for an ALIVE-but-unparseable re-vote
+ * leg (spec §5.7 — only ONE repair is spent), split out of runRevoteWave's leg
+ * loop. The CALLER owns the `alive && !parsed.ok` gate; this function always
+ * launches exactly one repair solo. It returns the post-repair view the caller
+ * records from there on — `parsed`, `conformance`, `outLeg` (the repaired leg
+ * when the repair completed, else the original) — plus exactly one non-null
+ * row: `supersededRow` (completed repair — the pre-repair leg's row) or
+ * `repairRow` (dead repair — the failed attempt's own row), for the caller to
+ * push. A user abort mid-repair returns `{ aborted: <exitCode> }` alone, which
+ * the caller propagates as its own return.
+ */
+async function repairRevoteLeg(ctx, { waveId, key, judge, leg, parsed, expectedIds }) {
+  // One repair, solo, to that judge. The id is built from the SEAT key so
+  // two twins never share one repair id (and one never overwrites the
+  // other's run-state entry). ⚠️ The trailing `r` is load-bearing: it is what
+  // stops bindSeats' `/^(.*)-(\d+)$/` matching a repair id whose judge alias
+  // is a bare number (`r1-rv-2r` does not match; `r1-rv-2` would). Dropping
+  // it re-arms a collision. sanitizeName also fixes the pre-existing slash
+  // bug (D4) — `r1-rv-openrouter/deepseek/deepseek-chatr` stops nesting
+  // three directory levels — and is a no-op for every plain alias.
+  const repairId = `${waveId}-${sanitizeName(key)}r`;
+  runState.appendStageWave(ctx.o.runDir, 'debate-revote', repairId);
+  const r2 = await ctx.launchers.launchSolo({ ...legOpts(ctx, repairId), model: judge,
+    // ⚠️ LC-12: ditto — the re-vote output being repaired rides with its errors.
+    prompt: dbrief.buildRevoteRepairPrompt({ errors: parsed.errors, revote: leg.summary }) });
+  ctx.addWave(r2.wave);
+  if (isAbortExit(r2.exitCode)) { return { aborted: r2.exitCode }; }
+  const leg2 = r2.leg && r2.leg.status === 'complete' ? r2.leg : null;
+  parsed = leg2 ? parseRevote(leg2.summary, expectedIds) : parsed;
+  const conformance = parsed.ok ? 'repaired' : 'unstructured';
+  // Symmetric with runDefenseSolo's `if (leg2) { leg = leg2; }` — otherwise
+  // revote-<model>.md and the runStats row keep the PRE-repair output.
+  return leg2
+    ? { aborted: null, parsed, conformance, outLeg: leg2,
+        supersededRow: legRow(judge, leg, 'unstructured'), repairRow: null }
+    : { aborted: null, parsed, conformance, outLeg: leg,
+        supersededRow: null, repairRow: legRow(judge, r2.leg, 'unstructured') };
+}
+
 /**
  * The re-vote mini-wave (spec §5.1).
  *
@@ -151,7 +200,7 @@ function reVoteUnboundNote(waveId, judge, key, leg) {
  * @param {function(string): string} aliasOf seat id → bench alias
  */
 async function runRevoteWave(ctx, judgeKeys, bundleFindings, judgeSeats, aliasOf) {
-  const bundle = dbrief.buildRevoteBundle({ findings: bundleFindings, date: ctx.o.date });
+  const bundle = dbrief.buildRevoteBundle({ findings: bundleFindings, date: ctx.o.date, intent: ctx.o.intent });
   // spec §5.1 names `revote-bundle.md` a run-dir artifact: the shared re-vote prompt goes to
   // disk exactly like Stage 2's bundle-stage2.md, so the round's model-facing input is
   // auditable alongside briefing-stage1.md and chair-packet.md.
@@ -194,28 +243,11 @@ async function runRevoteWave(ctx, judgeKeys, bundleFindings, judgeSeats, aliasOf
       : { ok: false, byId: {}, errors: [{ code: 'DEAD_LEG', detail: 'no summary' }] };
     let conformance = alive ? 'clean' : 'unstructured';
     if (alive && !parsed.ok) {
-      // One repair, solo, to that judge. The id is built from the SEAT key so
-      // two twins never share one repair id (and one never overwrites the
-      // other's run-state entry). ⚠️ The trailing `r` is load-bearing: it is what
-      // stops bindSeats' `/^(.*)-(\d+)$/` matching a repair id whose judge alias
-      // is a bare number (`r1-rv-2r` does not match; `r1-rv-2` would). Dropping
-      // it re-arms a collision. sanitizeName also fixes the pre-existing slash
-      // bug (D4) — `r1-rv-openrouter/deepseek/deepseek-chatr` stops nesting
-      // three directory levels — and is a no-op for every plain alias.
-      const repairId = `${waveId}-${sanitizeName(key)}r`;
-      runState.appendStageWave(ctx.o.runDir, 'debate-revote', repairId);
-      const r2 = await ctx.launchers.launchSolo({ ...legOpts(ctx, repairId), model: judge,
-        // ⚠️ LC-12: ditto — the re-vote output being repaired rides with its errors.
-        prompt: dbrief.buildRevoteRepairPrompt({ errors: parsed.errors, revote: leg.summary }) });
-      ctx.addWave(r2.wave);
-      if (isAbortExit(r2.exitCode)) { return { aborted: r2.exitCode }; }
-      const leg2 = r2.leg && r2.leg.status === 'complete' ? r2.leg : null;
-      parsed = leg2 ? parseRevote(leg2.summary, expectedIds) : parsed;
-      conformance = parsed.ok ? 'repaired' : 'unstructured';
-      // Symmetric with runDefenseSolo's `if (leg2) { leg = leg2; }` — otherwise
-      // revote-<model>.md and the runStats row keep the PRE-repair output.
-      if (leg2) { supersededLegs.push(legRow(judge, leg, 'unstructured')); outLeg = leg2; }
-      else { repairLegs.push(legRow(judge, r2.leg, 'unstructured')); }
+      const rep = await repairRevoteLeg(ctx, { waveId, key, judge, leg, parsed, expectedIds });
+      if (rep.aborted) { return { aborted: rep.aborted }; }
+      ({ parsed, conformance, outLeg } = rep);
+      if (rep.supersededRow) { supersededLegs.push(rep.supersededRow); }
+      if (rep.repairRow) { repairLegs.push(rep.repairRow); }
     }
     // ⚠️ Two DIFFERENT values on the same iteration: `byJudge`'s key is the SEAT
     // (applyDebate joins it against `(a.seat || a.judge)`), while the leg's

package/src/council/run-debate.js

@@ -35,7 +35,7 @@ const { legOpts, legRow, runRevoteWave } = require('./run-debate-revote');
  * `raiserKey` survives in exactly two places here: the returned `{raiser}` (which
  * becomes defenseByRaiser's key — §3.3: that MUST stay seat-keyed, because
  * re-keying it to the alias is last-wins and silently drops one twin's entire
- * debate row plus its amended claim) and the `seat` runDebate derives from it.
+ * debate row plus its amended claim) and the `seat` runDefenseWave derives from it.
  * Everything else — both launch sites, both legRow calls, the stub and the
  * returned leg's `model` — is `raiserAlias`.
  *
@@ -47,7 +47,7 @@ const { legOpts, legRow, runRevoteWave } = require('./run-debate-revote');
  */
 async function runDefenseSolo(ctx, raiserKey, findings, idx, aliasOf) {
   const raiserAlias = aliasOf(raiserKey);
-  const brief = dbrief.buildDefenseBrief({ findings, date: ctx.o.date });
+  const brief = dbrief.buildDefenseBrief({ findings, date: ctx.o.date, intent: ctx.o.intent });
   const waveId = `${ctx.o.runId}-d${idx + 1}`;
   const expectedIds = findings.map(f => f.id);
   // Record the sub-wave BEFORE launching: `amicus abort` cascades over stages[].waveIds
@@ -97,6 +97,51 @@ async function runDefenseSolo(ctx, raiserKey, findings, idx, aliasOf) {
     supersededLeg, repairLeg };
 }
 
+/**
+ * Defense mini-wave: ONE CONCURRENT solo per raiser (spec §5.1).
+ *
+ * Concurrent, not sequential: every raiser gets its OWN briefing, so this is N independent
+ * solos rather than one fanout wave. No per-leg budget check interleaves between them — the
+ * cost ceiling is a WHOLE-ROUND gate run.js applies BEFORE calling runDebate
+ * ('skipped-cost-ceiling' is a round-level outcome in spec §5.1's enum, not a per-leg one).
+ * `appendStageWave` is sync fs and each solo registers its waveId before its first await,
+ * so concurrency cannot interleave a read-modify-write of run.json.
+ * v4.1 §4.4: the reserved seat 'claude' is a FILE-sourced review with no leg to
+ * launch, so it is never asked to defend — its contested findings simply stand
+ * (the same "originals stand" outcome as a no-response).
+ *
+ * @param {object} ctx run.js's {o, launchers, addWave, overBudget, scratchDir}
+ * @param {{byRaiser: object, aliasOf: function(string): string, seatById: Map<string, object>}} args
+ * @returns {Promise<{aborted: (number|null), defenseResults: Array<object>, defenseByRaiser: (object|null)}>}
+ *   `aborted` is an abort exit code (defenseByRaiser is null then) or null on a full wave.
+ */
+async function runDefenseWave(ctx, { byRaiser, aliasOf, seatById }) {
+  const raisers = Object.keys(byRaiser).filter(m => m !== 'claude');
+  const defenseResults = await Promise.all(
+    raisers.map((raiserKey, i) => runDefenseSolo(ctx, raiserKey, byRaiser[raiserKey], i, aliasOf)));
+  // A signal during the defense wave aborts the whole finalization (spec §5.7): return the
+  // abort code — runDebate maps it onto its own abort return — so run.js finalizes
+  // 'aborted' with NO tally-final / NO ledger.
+  const abortedDefense = defenseResults.find(d => d.aborted);
+  if (abortedDefense) { return { aborted: abortedDefense.aborted, defenseResults, defenseByRaiser: null }; }
+  // ⚠️ This literal lives in runDefenseWave, where `raiserAlias` does not exist — the
+  // projection is `aliasOf(d.raiser)`. `model` must stay ALIAS-valued (R3-1);
+  // `seat` is what gives two twins two files instead of one clobbered one (R3-3).
+  materializeDebate(ctx.o.runDir, defenseResults.map(d => ({ model: aliasOf(d.raiser),
+    summary: d.leg.summary, seat: seatById.get(d.raiser) || null })), 'rebuttal');
+
+  const defenseByRaiser = {};
+  for (const dr of defenseResults) { defenseByRaiser[dr.raiser] = { ...dr.byId }; }
+  // v4.1 §4.4: claude never gets a defense leg (raisers filter above), but its
+  // contested/disputed findings still need an audit trail — the SAME spec §5.7
+  // "originals stand" fallback a dead/unrepaired defense leg gets. Seeded into
+  // defenseByRaiser ONLY (never defenseResults, which feeds runDebate's `bad(l)`
+  // degraded check — a claude entry there would wrongly flip a clean run to
+  // degraded/exit 2).
+  if (byRaiser.claude) { defenseByRaiser.claude = allNoResponse(byRaiser.claude.map(f => f.id)); }
+  return { aborted: null, defenseResults, defenseByRaiser };
+}
+
 /**
  * Full Stage-2.5 sequence (spec §5.1). Returns everything run.js needs. Cost gate: run.js
  * checks overBudget before invoking; this checks again before the re-vote wave (spec §5.7).
@@ -128,38 +173,10 @@ async function runDebate(ctx, { provisionalRecord, tallyInput }) {
   const seatById = new Map(seatTable.map(s => [s.id, s]));
   const aliasOf = (key) => { const s = seatById.get(key); return s ? s.alias : key; };
 
-  // ---- Defense mini-wave: ONE CONCURRENT solo per raiser (spec §5.1) ----
-  // Concurrent, not sequential: every raiser gets its OWN briefing, so this is N independent
-  // solos rather than one fanout wave. No per-leg budget check interleaves between them — the
-  // cost ceiling is a WHOLE-ROUND gate run.js applies BEFORE calling runDebate
-  // ('skipped-cost-ceiling' is a round-level outcome in spec §5.1's enum, not a per-leg one).
-  // `appendStageWave` is sync fs and each solo registers its waveId before its first await,
-  // so concurrency cannot interleave a read-modify-write of run.json.
-  // v4.1 §4.4: the reserved seat 'claude' is a FILE-sourced review with no leg to
-  // launch, so it is never asked to defend — its contested findings simply stand
-  // (the same "originals stand" outcome as a no-response).
-  const raisers = Object.keys(byRaiser).filter(m => m !== 'claude');
-  const defenseResults = await Promise.all(
-    raisers.map((raiserKey, i) => runDefenseSolo(ctx, raiserKey, byRaiser[raiserKey], i, aliasOf)));
-  // A signal during the defense wave aborts the whole finalization (spec §5.7):
-  // return the abort code so run.js finalizes 'aborted' with NO tally-final / NO ledger.
-  const abortedDefense = defenseResults.find(d => d.aborted);
-  if (abortedDefense) { return { aborted: abortedDefense.aborted, contested, disputed }; }
-  // ⚠️ This literal lives in runDebate, where `raiserAlias` does not exist — the
-  // projection is `aliasOf(d.raiser)`. `model` must stay ALIAS-valued (R3-1);
-  // `seat` is what gives two twins two files instead of one clobbered one (R3-3).
-  materializeDebate(ctx.o.runDir, defenseResults.map(d => ({ model: aliasOf(d.raiser),
-    summary: d.leg.summary, seat: seatById.get(d.raiser) || null })), 'rebuttal');
-
-  const defenseByRaiser = {};
-  for (const dr of defenseResults) { defenseByRaiser[dr.raiser] = { ...dr.byId }; }
-  // v4.1 §4.4: claude never gets a defense leg (raisers filter above), but its
-  // contested/disputed findings still need an audit trail — the SAME spec §5.7
-  // "originals stand" fallback a dead/unrepaired defense leg gets. Seeded into
-  // defenseByRaiser ONLY (never defenseResults, which feeds the `bad(l)`
-  // degraded check below — a claude entry there would wrongly flip a clean run
-  // to degraded/exit 2).
-  if (byRaiser.claude) { defenseByRaiser.claude = allNoResponse(byRaiser.claude.map(f => f.id)); }
+  // ---- Defense mini-wave (runDefenseWave): abort short-circuits the round (spec §5.7) ----
+  const dw = await runDefenseWave(ctx, { byRaiser, aliasOf, seatById });
+  if (dw.aborted) { return { aborted: dw.aborted, contested, disputed }; }
+  const { defenseResults, defenseByRaiser } = dw;
   // Stamp previousTier onto the tally input: applyDebate reads it off tallyInput.findings[]
   // (it ignores the provisional record), so without this every row's previousTier is null.
   const stampedInput = { ...tallyInput, findings: tallyInput.findings.map(f => ({ ...f, previousTier: previousTier[f.id] })) };

package/src/council/run-finish.js

@@ -4,7 +4,7 @@
 // Moved verbatim from run.js@6b0c3b6b:242-288 (v4.8 PR0 size-gate split, zero
 // behavior). NOT run-finalize.js — that sibling owns exit codes and the
 // terminal write; this module builds the final tally, appends the run
-// record to the ledger (skipped for lens runs), and writes the
+// record to the ledger (skipped for lens runs and task runs), and writes the
 // tally/verdict artifact files + their stage events.
 const { tally } = require('./tally');
 const { decorateRecord } = require('./debate');
@@ -48,8 +48,10 @@ function finishRun({ o, chairRes, debatedInput, debateFindings, appendRunFn, deg
   ];
   const record = tally(finalInput);
   if (debateFindings) { decorateRecord(record, debateFindings); }
-  if (!o.lenses) {
-    // Lens runs never feed cross-run reliability stats (spec §4 / skill rule).
+  if (!o.lenses && o.intent !== 'task') {
+    // Lens runs never feed cross-run reliability stats (spec §4 / skill rule);
+    // task runs neither (v4.9 W5.4 gate 1 — task rankings measure concurrence,
+    // never defect confirmation, so a task row would poison chair promotion).
     try { appendRunFn(record); }
     catch (e) { process.stderr.write(`Notice: council ledger append failed: ${e.message}\n`); }
   }

package/src/council/run-retry-keys.js

@@ -7,10 +7,10 @@
 // run-retry-group.js re-exports all four, so no import path in the tree moved.
 
 /**
- * The one seat-key rule: a seat's id when it was identified, its alias otherwise.
- * Exported so `run-retry-group.js :: recordFailure` and run-retry.js both consume it
- * rather than re-spelling it — two readers of one rule that drift apart is how the
- * alias/seat-id keyspace splits in the first place.
+ * The one seat-key rule: a seat's id when it was identified, its alias otherwise. Exported
+ * so `run-retry-group.js :: recordFailure`, run-retry.js and — since v4.9 W3 (SI-DUP
+ * disposition b) — run.js, run-debate-revote.js and run-stage1-rows.js all consume it
+ * rather than re-spelling it: readers of one rule that drift apart is how it splits.
  */
 const seatKey = (s, alias) => (s ? s.id : alias);
 

package/src/council/run-retry-launch.js

@@ -15,13 +15,13 @@
 const briefings = require('./briefings');
 const { bindPaddedWave } = require('./stage1-bind');
 
-/** The briefing a retry unit re-issues — same builders Stage 1 used. */
+/** The briefing a retry unit re-issues — same intent-aware dispatchers Stage 1 used (v4.9 W6). */
 function briefingFor(o, unit) {
-  if (unit.unit === 'critic') { return briefings.buildCriticBriefing({ briefing: o.briefing, date: o.date }); }
+  if (unit.unit === 'critic') { return briefings.stage1CriticBriefing(o.intent, { briefing: o.briefing, date: o.date }); }
   if (unit.unit === 'lens') {
-    return briefings.buildLensBriefing({ lens: o.lenses[unit.lensIndex - 1], briefing: o.briefing, date: o.date });
+    return briefings.stage1LensBriefing(o.intent, { lens: o.lenses[unit.lensIndex - 1], briefing: o.briefing, date: o.date });
   }
-  return briefings.buildSeatBriefing({ briefing: o.briefing, date: o.date });
+  return briefings.stage1SeatBriefing(o.intent, { briefing: o.briefing, date: o.date });
 }
 
 /**