amicus 4.8.1 → 4.9.1

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

@@ -36,23 +36,31 @@ function waveStillDeadNote(w, unit) {
     why: `${w.reason || 'no reason recorded'}; the once-only retry wave also produced no legs`,
     effect: 'Those seats are NOT in this council. The run continues with the bench that did '
       + 'launch and will exit degraded (2)',
-    // `seat` rides ONLY on the partial shape: adding it unconditionally breaks
-    // degrade-channels.test.js's exact toEqual on a real dead wave. It stays the
-    // ALIAS because verdict.js:72 compares data.seat against o.critic, an alias,
-    // and because it is the same key the dead-leg shape uses — one vocabulary
-    // for one field. ⚠️ It is NOT read by the Workspace today: the kind/channel filters in
-    // live-dead-seats.js (deadSeats) and workspace-seats.js (retriedSeats), and verdict.js's
-    // own two, all admit only dead-leg/dead-wave — so nothing consumes `seat-unbound` yet.
-    // Cited by SYMBOL, not line: these three references rotted twice during v4.8 PR5c alone.
+    // `seat`/`seatId` ride ONLY on the partial shape: adding either unconditionally breaks
+    // degrade-channels.test.js's exact toEqual on a real dead wave. `seat` stays the
+    // ALIAS because verdict-seat-loss.js :: deriveSeatLoss compares data.seat against o.critic,
+    // an alias, and because it is the same key the dead-leg shape uses — one vocabulary
+    // for one field. ⚠️ It IS read by the Workspace as of v4.9 W9: all three consumers
+    // (live-dead-seats.js :: deadSeats, workspace-seats.js :: retriedSeats,
+    // verdict-seat-loss.js :: deriveSeatLoss) now admit `seat-unbound` — GATED on the retry-family
+    // fields below, because orphan-leg and re-vote notes share this channel and are not
+    // seat losses. Cited by SYMBOL, not line: these three references rotted twice during
+    // v4.8 PR5c alone.
     data: { waveId: w.waveId, models: w.models, reason: w.reason, retryWaveId: unit.waveId,
       // v4.8 PR5c: seat identity, index-parallel with `models`, on the dead-wave arm only
-      // (the partial arm names ONE seat and rides `seat` above; `seat-unbound` has no
-      // consumer, so an array there would be unpinned surface for no gain).
+      // (the partial arm names ONE seat, so it carries the SCALAR `seatId` below instead —
+      // the reason given here for emitting nothing at all, that `seat-unbound` had no
+      // consumer, stopped being true in v4.9 W9, which gave it three).
       // ⚠️ An unidentified slot emits `null`, NEVER the alias. Collapsing it onto the alias
       // makes it indistinguishable from a second reference to that alias, and no consumer
       // can recover the difference — deadSeats has no per-alias seat count. That collapse
       // is what made two distinct dead twins render as a single row.
-      ...(partial ? { seat: (w.models || [])[0] } : {
+      // v4.9 W9 P1: the fifth arm's seat identity. A SCALAR `seatId`, matching the two leg
+      // arms' vocabulary — this arm names exactly ONE seat, so the dead-wave arm's parallel
+      // ARRAY would be a second spelling of the same fact. Same null discipline as that
+      // array: an unidentified slot emits `null`, never the alias.
+      ...(partial ? { seat: (w.models || [])[0],
+        seatId: ((w.seats || [])[0] && (w.seats || [])[0].id) || null } : {
         seats: (w.models || []).map((m, i) => {
           const so = (w.seats || [])[i];
           return so ? so.id : null;
@@ -60,13 +68,61 @@ function waveStillDeadNote(w, unit) {
       }) } };
 }
 
+/**
+ * The retry pass never ATTEMPTED this wave (run-retry.js's two `skipped` arms: an unmappable
+ * or zero-model unit, or `ctx.overBudget()`). Lifted out of run-stages.js's emit loop in the
+ * v4.9 W9 fix round so it sits beside `waveStillDeadNote`, whose partial arm it mirrors: two
+ * spellings of ONE record shape in two files is what let them drift apart in the first place.
+ *
+ * ⚠️ Carries NO `retryWaveId`, and must not: no retry wave was ever launched, so naming one
+ * would be a false statement about spend, and the two Workspace renderers read exactly that
+ * field to decide the 'retried once' phrasing.
+ *
+ * v4.9 W9 fix round 1 (council A1/C1). The partial arm previously carried `{waveId, models,
+ * reason, seat}` and no retry-family field at all, so all three W9 consumers
+ * (`live-dead-seats.js :: isSeatLoss`, `workspace-seats.js :: retriedSeats`,
+ * `verdict-seat-loss.js :: deriveSeatLoss`) dropped a genuinely dead seat — residual R-W9a,
+ * pinned known-wrong and escalated. It now emits the two facts it has ALREADY:
+ *   `seatId`  — from the record's own `seats[0]` (stage1-bind.js :: missingSeatDeadWave carries
+ *               it), same null discipline as the arms above: an unidentified slot emits `null`,
+ *               NEVER the alias.
+ *   `firstFailure` — the canonical `run-retry-group.js :: recordFailure` shape for a partial
+ *               wave (`class: 'missing'`, the record's own waveId/reason). It restates this
+ *               record's first-pass loss and claims nothing about a retry, which is what opens
+ *               the consumers' retry-family gate WITHOUT loosening it: orphan-leg, re-vote and
+ *               Stage-2 judge notes still carry neither field and stay excluded.
+ */
+function skippedWaveNote(d) {
+  const partial = !!d.partial;
+  const alias = (d.models || [])[0];
+  return {
+    channel: partial ? 'seat-unbound' : 'dead-wave',
+    // A `partial` record is one seat of a wave that DID produce legs, so the plain dead-wave
+    // sentence would be false. Everything below `models` rides on that shape ONLY: adding any
+    // of it unconditionally breaks an exact toEqual on a real dead wave.
+    what: partial
+      ? `seat ${alias} did not review`
+      : `Stage-1 wave ${d.waveId} (${d.models.join(', ') || 'no models'}) produced NO legs`,
+    why: d.reason,
+    effect: 'Those seats are NOT in this council. The run continues with the bench that did '
+      + 'launch and will exit degraded (2)',
+    data: { waveId: d.waveId, models: d.models, reason: d.reason,
+      ...(partial ? { seat: alias,
+        seatId: ((d.seats || [])[0] && (d.seats || [])[0].id) || null,
+        firstFailure: { seat: alias, class: 'missing', waveId: d.waveId, reason: d.reason },
+      } : {}) },
+  };
+}
+
 /**
  * Leg-origin, retry wave died wholesale (bench-batch case).
  *
  * v4.8 PR5c: `seatId` is the caller's Stage-1 leg->seat binding, or null when the leg was
- * never bound. It is a SEPARATE key from `seat`, which stays the ALIAS — verdict.js:72
- * compares `data.seat` against `o.critic`, an alias, so re-pointing it breaks critic-loss
- * detection. Add a key; never repurpose that one.
+ * never bound. It is a SEPARATE key from `seat`, which stays the ALIAS —
+ * `verdict-seat-loss.js :: deriveSeatLoss`'s `criticLeg` lookup compares `data.seat` against
+ * `o.critic`, an alias, so re-pointing it breaks critic-loss detection. Cited by SYMBOL, not
+ * line: the old `verdict.js:72` had already slid one line off that comparison, and the
+ * function has since left verdict.js entirely. Add a key; never repurpose that one.
  */
 function srcLegStillDeadNote(leg, unit, counts, seatId = null) {
   const seat = leg.modelInput || leg.model;
@@ -123,4 +179,5 @@ function missingLegStillDeadNote(seat, ff, unit, counts) {
     data: { seat, status: null, reason: null, firstFailure: ff, retryWaveId: unit.waveId } };
 }
 
-module.exports = { waveStillDeadNote, srcLegStillDeadNote, retryLegStillDeadNote, missingLegStillDeadNote };
+module.exports = { waveStillDeadNote, skippedWaveNote, srcLegStillDeadNote,
+  retryLegStillDeadNote, missingLegStillDeadNote };

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

@@ -14,7 +14,7 @@ const { buildSeats } = require('./seats');
 /** Launch all Stage-1 legs (wave + critic/lens solos), collect run docs. */
 async function launchStage1(ctx) {
   const { o, launchers } = ctx;
-  // Seat identity for THIS launch. run.js:133 sets o.seats from asm.preflightSeats;
+  // Seat identity for THIS launch. run.js:142 sets o.seats from asm.preflightSeats;
   // buildSeats is pure and total, so a direct require() caller or a legacy run dir
   // reconstructs the same table rather than binding nothing (spec §4.3).
   const seats = Array.isArray(o.seats) && o.seats.length > 0
@@ -47,7 +47,7 @@ async function launchStage1(ctx) {
       seated.push({ waveId, models: [m], roster: seats.slice(i, i + 1) });
       launches.push(launchers.launchSolo({
         ...common, model: m, waveId, seats: seated[seated.length - 1].roster,
-        prompt: briefings.buildLensBriefing({ lens: o.lenses[i], briefing: o.briefing, date: o.date }),
+        prompt: briefings.stage1LensBriefing(o.intent, { lens: o.lenses[i], briefing: o.briefing, date: o.date }),
       }));
     });
   } else {
@@ -61,7 +61,7 @@ async function launchStage1(ctx) {
         roster: seats.filter(s => s.alias !== o.critic) });
       launches.push(launchers.launchWave({
         ...common, models: seats1, waveId: `${o.runId}-s1`, seats: seated[seated.length - 1].roster,
-        prompt: briefings.buildSeatBriefing({ briefing: o.briefing, date: o.date }),
+        prompt: briefings.stage1SeatBriefing(o.intent, { briefing: o.briefing, date: o.date }),
       }));
     }
     if (o.critic) {
@@ -70,7 +70,7 @@ async function launchStage1(ctx) {
         roster: seats.filter(s => s.alias === o.critic).slice(0, 1) });
       launches.push(launchers.launchSolo({
         ...common, model: o.critic, waveId: `${o.runId}-c1`, seats: seated[seated.length - 1].roster,
-        prompt: briefings.buildCriticBriefing({ briefing: o.briefing, date: o.date }),
+        prompt: briefings.stage1CriticBriefing(o.intent, { briefing: o.briefing, date: o.date }),
       }));
     }
   }

package/src/council/run-stage1-rows.js

@@ -1,7 +1,7 @@
 // src/council/run-stage1-rows.js
 'use strict';
 // Superseded-seat rows + primary-error dead-seat rows (v4.7 D2/E4), moved
-// verbatim from run-stages.js:230-279 (v4.8 PR0 size-gate split, zero
+// verbatim from run-stages.js:218-267 (v4.8 PR0 size-gate split, zero
 // behavior). The code ran inline in runStage1; it is now a function.
 // roleFor and seatOf are PARAMETERS, not requires — requiring them back from
 // run-stages would recreate the parent-child cycle that file's tail comment
@@ -10,8 +10,8 @@ const { buildRunStatsEntry } = require('./run-assemble');
 // The one keyspace. It lives in ./run-retry-keys (v4.8 Phase 2 T-A1), which IS require-free;
 // run-retry-group.js re-exports it and requires nothing else, so this import's closure
 // terminates at a leaf and cannot re-create the parent-child cycle the header above
-// documents eliminating.
-const { twinAliases, legLossKey } = require('./run-retry-group');
+// documents eliminating. (v4.9 W3, SI-DUP b: `seatKey` joined this destructure — see keyOf.)
+const { seatKey, twinAliases, legLossKey } = require('./run-retry-group');
 // v4.8 T-A6 size-gate split: the SUPERSEDED half of these rows moved to
 // ./run-stage1-superseded, taking `../utils/degrade` and the default stderr sink with it.
 // `degrade` is still a parameter HERE, forwarded unchanged, so a caller that omits it still
@@ -63,8 +63,11 @@ const { supersededRows } = require('./run-stage1-superseded');
 function pushDeadSeatRows({ o, retry, deadLegs0, stillDeadLegs, stillDeadWaves, extraRows,
   roleFor, seatOf, degrade, twins = twinAliases(o.seats) }) {
   // A leg's join key: its bound seat's id, else its alias — the same fallback
-  // `run-retry-keys.js :: seatKey` (imported by run-retry.js since v4.8 T-A1) uses
-  // for a roster slot it could not identify, so both sides of every lookup agree.
+  // `run-retry-keys.js :: seatKey` (imported by run-retry.js since v4.8 T-A1, and by
+  // this file since v4.9 W3 for the dead-wave slot join below) uses for a roster slot
+  // it could not identify, so both sides of every lookup agree. keyOf itself stays
+  // hand-written on purpose: its else branch is `l.modelInput || l.model`, a LEG read
+  // with no bare alias in scope — a sibling form, not a re-spelling of that rule.
   const keyOf = (leg) => { const s = seatOf.get(leg); return s ? s.id : (leg.modelInput || leg.model); };
   // v4.8 T2.2 ruling R2, the LEG arms' MINT branch: on an alias the roster repeats, an
   // unbound leg's `keyOf` names BOTH twins, so N dead legs collapsed into ONE row.
@@ -139,7 +142,7 @@ function pushDeadSeatRows({ o, retry, deadLegs0, stillDeadLegs, stillDeadWaves,
     // reconcile, so index-zipping them is safe here and nowhere else.
     (w.models || []).forEach((alias, i) => {
       const s = (w.seats || [])[i] || null;
-      const join = s ? s.id : alias;
+      const join = seatKey(s, alias);
       // R2's MARK branch. This arm has no leg to mint from, and `(waveId, i)` is
       // measurably NOT unique — missingSeatDeadWave emits several records under one
       // waveId each with i === 0, and run-retry.js re-indexes when it narrows a

package/src/council/run-stage2.js

@@ -30,6 +30,63 @@ const { buildRunStatsEntry } = require('./run-assemble');
 const { artifactName } = require('./seats');
 const { orphanLegNote, bindPaddedWave } = require('./stage1-bind');
 
+/**
+ * Bind the -s2 wave's legs to the seats `reviews[]` holds and note the two
+ * unbindable shapes (orphan legs, unbound seats) on ctx.degrade. Lifted
+ * verbatim out of `runStage2` below (v4.9 W2, the SI-16 function-length
+ * split); the caller reads back only `judgeSeatOf` — `s2WaveId` rides along
+ * in the return for the seam's shape, nothing downstream consumes it.
+ * @param {object} ctx
+ * @param {{reviews: Array, judges: Array<string>, s2Legs: Array<object>,
+ *   runId: string}} args — `s2Legs` arrives pre-guarded
+ *   (`(wave && wave.legs) || []`): the wave-null guard stays at the call
+ *   site, beside the leg loop that shares it.
+ * @returns {{s2WaveId: string, judgeSeatOf: Map<object, object>}}
+ */
+function bindStage2Seats(ctx, { reviews, judges, s2Legs, runId }) {
+  // v4.8 PR3 Task 4: bind the -s2 wave's legs to the SAME seats reviews[] holds,
+  // in `reviews` order — judges is built from that same array by the same
+  // `.map`, and real fanout stamps `${waveId}-${i+1}` off that same index
+  // (sidecar/leg-ids.js), so this holds even after an SL-2 heal (recovered legs
+  // are appended, run-stages.js:141, so `reviews` order is no longer seat order
+  // — both arrays still derive from the same `reviews`).
+  // §3.4's padding pattern now lives in `stage1-bind.js :: bindPaddedWave`
+  // (v4.8 SI-27) — why the roster is padded rather than filtered, and why
+  // placeholders are tracked by IDENTITY rather than an id-name prefix test,
+  // are in that function's docblock. Only this site's TAIL stays here.
+  const s2WaveId = `${runId}-s2`;
+  const { seatOf: judgeSeatOf, bindRes, placeholders } =
+    bindPaddedWave(s2WaveId, reviews.map(r => r.seat), i => judges[i], s2Legs);
+  // An orphan leg (a judge DID land, but no roster slot claims it) gets the
+  // same shape as Stage 1's orphanLegNote — `data.legId` present.
+  for (const leg of bindRes.orphanLegs) { ctx.degrade.note(orphanLegNote(s2WaveId, leg)); }
+  // review F(important): mirrors stage1-bind.js:40's suppression rule
+  // verbatim. A wave that returned ZERO legs is already announced on a louder
+  // channel (thin-cross-review, or this refusal itself) — there is no
+  // "missing seat" fact this adds. An orphan leg means a judge DID land for
+  // SOME seat we could not name — reporting the roster's other unbound seats
+  // as "missing" would double-count that one failure as two, on a channel
+  // whose whole contract is "nothing was guessed": the stray leg might BE the
+  // seat this loop would otherwise call missing.
+  if (s2Legs.length > 0 && bindRes.orphanLegs.length === 0) {
+    for (const seat of bindRes.unbound) {
+      if (placeholders.has(seat)) { continue; }
+      ctx.degrade.note({
+        channel: 'seat-unbound',
+        what: `leg for seat ${seat.alias} in wave ${s2WaveId} never returned`,
+        // R27-5: `reviews.length` IS the padded roster's length — bindPaddedWave
+        // maps 1:1 over the source array, and `Array.prototype.map` preserves
+        // length. Pinned (`ROSTERLEN`) in run-stages.test.js, because a
+        // substitution into unpinned prose is how a true sentence goes quietly false.
+        why: `the wave returned fewer judge legs than its roster of ${reviews.length}`,
+        effect: 'That seat did not judge; nothing was guessed and nothing was dropped',
+        data: { waveId: s2WaveId, seat: seat.alias },
+      });
+    }
+  }
+  return { s2WaveId, judgeSeatOf };
+}
+
 /**
  * Stage 2: shared anonymized bundle → judge wave in _scratch → parse + repair.
  * @param {object} ctx
@@ -54,7 +111,14 @@ async function runStage2(ctx, { reviews, labels, globalFindings, extraLabeled =
   const labeled = reviews
     .map((r, i) => ({ label: labels.entries[i].label, text: r.text }))
     .concat(extraLabeled);
-  const bundle = stage2.buildJudgeBundle({ reviews: labeled, findings: globalFindings, date: o.date });
+  // v4.9 W7: one dispatch, both intents (briefings-stage2.js :: judgeBundleFor —
+  // 'task' | absent, fail-closed). `briefing` is the EXTRA argument the task
+  // bundle needs and the review bundle ignores: task judges rank "which response
+  // best does the work the briefing asked for", which is unanswerable without the
+  // ask (spec §5.4). It rides `o.briefing` — the same field the Stage-1
+  // dispatchers compose from — so the text is never re-read off disk.
+  const bundle = stage2.judgeBundleFor(o.intent,
+    { reviews: labeled, findings: globalFindings, date: o.date, briefing: o.briefing });
   fs.writeFileSync(path.join(o.runDir, 'bundle-stage2.md'), bundle, { mode: 0o600 });
 
   // ROSTER, not bundle: derived ONLY from legs that actually ran, so a file-sourced
@@ -76,58 +140,23 @@ async function runStage2(ctx, { reviews, labels, globalFindings, extraLabeled =
   ctx.addWave(wave);
   if (isAbortExit(exitCode)) { return { aborted: exitCode, judgeResults: [], extraRows: [] }; }
 
-  // v4.8 PR3 Task 4: bind the -s2 wave's legs to the SAME seats reviews[] holds,
-  // in `reviews` order — judges is built from that same array by the same
-  // `.map`, and real fanout stamps `${waveId}-${i+1}` off that same index
-  // (sidecar/leg-ids.js), so this holds even after an SL-2 heal (recovered legs
-  // are appended, run-stages.js:153, so `reviews` order is no longer seat order
-  // — both arrays still derive from the same `reviews`).
-  // §3.4's padding pattern now lives in `stage1-bind.js :: bindPaddedWave`
-  // (v4.8 SI-27) — why the roster is padded rather than filtered, and why
-  // placeholders are tracked by IDENTITY rather than an id-name prefix test,
-  // are in that function's docblock. Only this site's TAIL stays here.
-  const s2WaveId = `${o.runId}-s2`;
+  // Seat binding (v4.8 PR3 Task 4) lives in bindStage2Seats above (v4.9 W2).
   // review F(critical): `wave` is legitimately null — a budget/args refusal
   // (run-budget.js failPre) returns `{wave: null, exitCode: 1}`, which
   // isAbortExit does NOT catch (only 130/143), so execution reaches here.
   // Guarded exactly like the leg loop below (`(wave && wave.legs) || []`) —
   // this is the only OTHER dereference of wave.legs in the file.
   const s2Legs = (wave && wave.legs) || [];
-  const { seatOf: judgeSeatOf, bindRes, placeholders } =
-    bindPaddedWave(s2WaveId, reviews.map(r => r.seat), i => judges[i], s2Legs);
-  // An orphan leg (a judge DID land, but no roster slot claims it) gets the
-  // same shape as Stage 1's orphanLegNote — `data.legId` present.
-  for (const leg of bindRes.orphanLegs) { ctx.degrade.note(orphanLegNote(s2WaveId, leg)); }
-  // review F(important): mirrors stage1-bind.js:40's suppression rule
-  // verbatim. A wave that returned ZERO legs is already announced on a louder
-  // channel (thin-cross-review, or this refusal itself) — there is no
-  // "missing seat" fact this adds. An orphan leg means a judge DID land for
-  // SOME seat we could not name — reporting the roster's other unbound seats
-  // as "missing" would double-count that one failure as two, on a channel
-  // whose whole contract is "nothing was guessed": the stray leg might BE the
-  // seat this loop would otherwise call missing.
-  if (s2Legs.length > 0 && bindRes.orphanLegs.length === 0) {
-    for (const seat of bindRes.unbound) {
-      if (placeholders.has(seat)) { continue; }
-      ctx.degrade.note({
-        channel: 'seat-unbound',
-        what: `leg for seat ${seat.alias} in wave ${s2WaveId} never returned`,
-        // R27-5: `reviews.length` IS the padded roster's length — bindPaddedWave
-        // maps 1:1 over the source array, and `Array.prototype.map` preserves
-        // length. Pinned (`ROSTERLEN`) in run-stages.test.js, because a
-        // substitution into unpinned prose is how a true sentence goes quietly false.
-        why: `the wave returned fewer judge legs than its roster of ${reviews.length}`,
-        effect: 'That seat did not judge; nothing was guessed and nothing was dropped',
-        data: { waveId: s2WaveId, seat: seat.alias },
-      });
-    }
-  }
+  const { judgeSeatOf } = bindStage2Seats(ctx, { reviews, judges, s2Legs, runId: o.runId });
 
   const judgeResults = [];
   // v4.7 D2: every judge-repair launch is a billed leg of its own, distinct from
   // the judge's original Stage-2 wave leg it is trying to fix — it gets its own
   // row so its cost is never folded into, or lost from, the judge's row (mirrors
-  // runStage1's -p<N> extraRows, ./run-stages.js:117-120).
+  // runStage1's -p<N> extraRows, run-stages.js :: runStage1). ⚠️ Cited by LINE until the v4.9 W9
+  // fix round re-opened it: run-stages.js@5830ece3:117-120 was the skipped-wave note's `what`
+  // arm, not extraRows at all, and it has since moved to run-retry-notes.js :: skippedWaveNote.
+  // Anchored by symbol now, per the anti-rot rule.
   const extraRows = [];
   let repairSeq = 0;
   for (const leg of (wave && wave.legs) || []) {
@@ -159,7 +188,12 @@ async function runStage2(ctx, { reviews, labels, globalFindings, extraLabeled =
       runState.appendStageWave(o.runDir, 'stage2', waveId);
       const solo = await ctx.launchers.launchSolo({
         model: judge,
-        prompt: stage2.buildJudgeRepairPrompt({ errors: parsed.errors, judgement: judging }),
+        // v4.9 W7 fix round (F1): the SAME intent channel the bundle dispatch
+        // above rides. A judge briefed on the task contract must be repaired
+        // against the task contract — a repair solo is a fresh session, so the
+        // contract embedded here is the only output shape it ever sees.
+        prompt: stage2.judgeRepairPromptFor(o.intent,
+          { errors: parsed.errors, judgement: judging }),
         project: ctx.scratchDir, waveId, timeout: o.timeout,
         gateway: o.gateway, noValidateModel: o.noValidateModel, noCostGate: o.noCostGate,
         councilRunId: o.runId, councilName: o.councilName,
@@ -172,13 +206,13 @@ async function runStage2(ctx, { reviews, labels, globalFindings, extraLabeled =
         // is returned only for shape consistency, never read past this point.
         return { aborted: solo.exitCode, judgeResults, extraRows };
       }
-      // Every -q<N> launch gets a row — INCLUDING a repair that failed: the
-      // error status rides naturally off solo.leg (null/'error'-status leg ⇒
-      // buildRunStatsEntry's own never-invent defaults), no special-casing needed.
-      extraRows.push(buildRunStatsEntry({ leg: solo.leg, model: judge, role: 'repair', wasChair: false }));
       const out = (solo.leg && solo.leg.summary) || '';
       if (out.trim()) { judging = out; }
       parsed = parseJudgeOutput(out, parseCtx);
+      // Every -q<N> launch gets a row — INCLUDING a failed repair (null/'error' leg ⇒ never-invent
+      // defaults); pushed AFTER the re-parse to stamp the repair LEG's own measured outcome (PR 199 D1, v4.9 V18 refined).
+      extraRows.push(buildRunStatsEntry({ leg: solo.leg, model: judge, role: 'repair',
+        wasChair: false, conformance: parsed.ok ? 'clean' : 'unstructured' }));
       if (parsed.ok) { conformance = 'repaired'; }
     }
     if (!parsed.ok) {

package/src/council/run-stages.js

@@ -27,6 +27,7 @@ const { launchStage1 } = require('./run-stage1-launch');
 const { buildRunStatsEntry } = require('./run-assemble');
 const { pushDeadSeatRows } = require('./run-stage1-rows');
 const { bindStage1Waves, orphanLegNote, missingSeatDeadWave } = require('./stage1-bind');
+const { skippedWaveNote } = require('./run-retry-notes');
 // slug lives in ./seats (v4.8 PR1) so that module can stay require-free;
 // re-exported below — run-stages.test.js imports it from here.
 const { slug } = require('./seats');
@@ -108,22 +109,9 @@ async function runStage1(ctx) {
       }).filter(w => w.models.length > 0) };
   }
 
-  for (const d of retry.skippedDeadWaves) {
-    // A `partial` record is one seat of a wave that DID produce legs, so the
-    // plain dead-wave sentence would be false. `seat` rides only on that shape:
-    // adding it unconditionally breaks an exact toEqual on a real dead wave.
-    ctx.degrade.note({
-      channel: d.partial ? 'seat-unbound' : 'dead-wave',
-      what: d.partial
-        ? `seat ${(d.models || [])[0]} did not review`
-        : `Stage-1 wave ${d.waveId} (${d.models.join(', ') || 'no models'}) produced NO legs`,
-      why: d.reason,
-      effect: 'Those seats are NOT in this council. The run continues with the bench that did '
-        + 'launch and will exit degraded (2)',
-      data: { waveId: d.waveId, models: d.models, reason: d.reason,
-        ...(d.partial ? { seat: (d.models || [])[0] } : {}) },
-    });
-  }
+  // Same shape as `stillDeadNotes` below: the builder lives in run-retry-notes.js (v4.9 W9
+  // fix round), beside `waveStillDeadNote` whose partial arm it mirrors; this file EMITS.
+  for (const d of retry.skippedDeadWaves) { ctx.degrade.note(skippedWaveNote(d)); }
   for (const leg of retry.skippedDeadLegs) {
     ctx.degrade.note({
       channel: 'dead-leg',
@@ -197,7 +185,7 @@ async function runStage1(ctx) {
       runState.appendStageWave(o.runDir, 'stage1', waveId);
       const solo = await ctx.launchers.launchSolo({
         model: m.modelInput,
-        prompt: briefings.buildFindingsRepairPrompt({ errors: res.errors, review: repairing }),
+        prompt: briefings.stage1RepairPrompt(o.intent, { errors: res.errors, review: repairing }),
         project: o.runDir, waveId, timeout: o.timeout,
         gateway: o.gateway, noValidateModel: o.noValidateModel, noCostGate: o.noCostGate,
         councilRunId: o.runId, councilName: o.councilName,
@@ -216,13 +204,13 @@ async function runStage1(ctx) {
         return { aborted: solo.exitCode, reviews, deadLegs: stillDeadLegs, deadWaves: stillDeadWaves,
           degraded: false, extraRows };
       }
-      // Every -p<N> launch gets a row — INCLUDING a repair that failed: the
-      // error status rides naturally off solo.leg (null/'error'-status leg ⇒
-      // buildRunStatsEntry's own never-invent defaults), no special-casing needed.
-      extraRows.push(buildRunStatsEntry({ leg: solo.leg, model: m.modelInput, role: 'repair', wasChair: false }));
       const repaired = (solo.leg && solo.leg.summary) || '';
       if (repaired.trim()) { repairing = repaired; }
       res = validateFindings(repaired);
+      // Every -p<N> launch gets a row — INCLUDING a failed repair (null/'error' leg ⇒ never-invent
+      // defaults); pushed AFTER re-validation to stamp the repair LEG's own measured outcome (PR 199 D1, v4.9 V18 refined).
+      extraRows.push(buildRunStatsEntry({ leg: solo.leg, model: m.modelInput, role: 'repair',
+        wasChair: false, conformance: res.ok ? 'clean' : 'unstructured' }));
       if (res.ok) { conformance = 'repaired'; }
     }
     if (!res.ok) { conformance = 'unstructured'; }

package/src/council/run-stats-entry.js

@@ -40,9 +40,37 @@
  * `seat` (v4.8 PR4c §3.1) is the seat OBJECT — {id, alias, role, lens, position}
  * or null — never an id string. Callers pass `r.seat` / the dead-seat loop's own
  * `seat` verbatim, so the object IS the contract instead of a prose one.
+ *
+ * `summary` (v4.9 W11 / PR1F-2) is the one field the folded
+ * `run-debate-revote.js :: legRow` needed that this entry did not emit. It is
+ * EXPLICIT-ONLY and emit-when-set: it is deliberately NOT sourced from
+ * `leg.summary`, because that is the model's raw review prose and no runStats
+ * row has ever carried it — a leg-sourced default would push review text into
+ * tally-input.json for every existing caller. It stops there: `tally.js ::
+ * tally`'s re-projection allowlist does not name `summary`, so it reaches
+ * neither tally.json/verdict.json nor the ledger (MEASURED). Passing nothing
+ * leaves every row byte-for-byte unchanged (pins G4a/G4b/G4c,
+ * tests/council/runstats-byte-order.test.js).
+ *
+ * `ttftMs` (v4.9 W13 Task A) is time-to-first-token for this row's leg, read off
+ * the leg document and emitted only when it is a NON-NEGATIVE INTEGER — the
+ * shape council-tally.schema.json declares, and (PR #207 round 3, B3) a stricter
+ * test than the bare type check this used to spell. PROBE ONLY — nothing
+ * derives a backstop, threshold, or routing decision from it yet (ruling R12:
+ * probe first, derive later). Absent means no substantive tick was observed —
+ * or that the only reading taken was not an honest measurement — which is
+ * neither `0` (a real measurement) nor `null`.
  */
 function buildRunStatsEntry({ leg, model, role, wasChair, conformance, findingsUnverified,
-  repairRefused, seat }) {
+  repairRefused, seat, summary }) {
+  // v4.9 W13 Task A: the TTFT probe's last hop, read off the LEG document the
+  // same way `waveId` and `resolvedModel` below are. DEVIATION from the plan's
+  // literal "thread from the leg at the callers": ten call sites across seven
+  // council modules hold a leg, and threading a parameter through each would
+  // (a) reach outside this task's file scope and (b) make a forgotten caller a
+  // SILENT gap. Sourcing it here covers every caller that holds a leg by
+  // construction, and a dead seat (`leg: null`) still carries no key.
+  const ttftMs = leg ? leg.ttftMs : undefined;
   return {
     model: model !== undefined ? model : (leg ? leg.model : null),
     role,
@@ -50,6 +78,7 @@ function buildRunStatsEntry({ leg, model, role, wasChair, conformance, findingsU
     conformance: conformance || 'clean',
     ...(findingsUnverified ? { findingsUnverified: true } : {}),
     ...(repairRefused ? { repairRefused } : {}),
+    ...(summary ? { summary } : {}),
     ...(leg && leg.waveId ? { waveId: leg.waveId } : {}),
     ...(leg && leg.model ? { resolvedModel: leg.model } : {}),
     // v4.8 PR4c §3.1 / R4c-9: emit-when-DIFFERENT, compared against the seat's
@@ -64,6 +93,22 @@ function buildRunStatsEntry({ leg, model, role, wasChair, conformance, findingsU
     ...(seat && seat.id !== seat.alias ? { seat: seat.id } : {}),
     status: leg ? leg.status : 'error',
     durationMs: leg && typeof leg.durationMs === 'number' ? leg.durationMs : null,
+    // Emit-when-set, NOT `durationMs`'s null-coercion one line above: this row
+    // is the C2 derivation's future input, and a null there would be read as a
+    // measurement. Absent means "never observed" and must stay absent.
+    //
+    // PR #207 round 3 (B3): emit-when-VALID too. The shared predicate is
+    // `src/utils/ttft.js :: isMeasuredTtft`, and it is spelled out by HAND here
+    // for one reason only — the module invariant at the top of this file forbids
+    // importing anything, and the pin that enforces it fires on the character
+    // sequence anywhere in the file, comments included. The structural pins that
+    // keep this copy in step with the shared one are in this module's own test
+    // file. Do not "simplify" it back to a bare type test: that admits NaN and
+    // ±Infinity (both of which serialize to `null`), negatives from a backward
+    // wall-clock jump at the probe, and fractions from a hand-edited artifact —
+    // every one of them forbidden by council-tally.schema.json's
+    // `integer, minimum 0`.
+    ...(Number.isInteger(ttftMs) && ttftMs >= 0 ? { ttftMs } : {}),
     usage: (leg && leg.usage) || null,
   };
 }

package/src/council/run.js

@@ -119,6 +119,15 @@ async function runCouncil(options, deps = {}) {
   const ctx = { o, launchers, addWave, overBudget, degrade, scratchDir: path.join(o.runDir, '_scratch') };
 
   try {
+    // v4.9 W5.3: o.intent is 'task' or ABSENT. ⚠️ PR #200 A3 (round-3 ruling): 'review' — the default spelled out loud, which both transports already strip (cli-handlers-council-run.js, mcp-council-run.js) — NORMALIZES to absent here rather than being refused, because runCouncil is a public door too and one input must not mean two things at two doors. `delete`, never `= undefined` (a present-but-undefined key still changes JSON output paths — the T10 lesson). Only a genuinely unknown value is BAD_ARGS. Pinned: tests/council/run-intent.test.js. ⚠️ Round-4 C2 (that this normalization runs AFTER the seed and so materializes intent:'review' on run.json) is REFUTED BY MEASUREMENT, not by argument: the ordering is real — `runState.initCouncilRun` runs ~50 lines above — but that seed literal (`run-state.js :: initCouncilRun`) has no `intent` key to copy, and BOTH run.json writers of it (the checkpoint below, and `cli-handlers-council-run.js`'s) are `=== 'task'` spreads that 'review' cannot pass. Mutant SEEDCOPY (a `...(o.intent ? {intent:o.intent} : {})` added to that seed) reddens exactly the pin, so no reordering is needed here.
+    if (o.intent === 'review') { delete o.intent; } else if (o.intent !== undefined && o.intent !== 'task') {
+      return finalize(1, { code: 'BAD_ARGS',
+        message: `Error: intent must be 'task' or 'review' (omitted means review); got '${o.intent}'` });
+    }
+    if (o.intent === 'task' && o.claudeReviewFile) {   // V12: a file review is REVIEW machinery
+      return finalize(1, { code: 'BAD_ARGS', message:
+        '--claude-review enters a REVIEW as review N+1 and has no task-mode meaning; drop it for a task run' });
+    }
     // v4.1 §4.4: Claude-in-council is a FILE input — validated after initRun (so the
     // error doc lands in a run dir that exists) and before any launch (zero spend).
     const pre = asm.preflightClaudeReview(o);
@@ -132,11 +141,12 @@ async function runCouncil(options, deps = {}) {
     if (seatPre.error) { return finalize(1, seatPre.error); }
     o.seats = seatPre.seats;
     o.criticSeat = seatPre.criticSeat;
-    runState.checkpoint(o.runDir, { seats: o.seats, criticSeat: o.criticSeat });
+    runState.checkpoint(o.runDir, { seats: o.seats, criticSeat: o.criticSeat,
+      ...(o.intent === 'task' ? { intent: 'task' } : {}) });   // v4.9 W5.3: emit-when-'task', never 'review'
 
     // Composed Stage-1 seat briefing persisted for auditability (spec §4 layout).
     fs.writeFileSync(path.join(o.runDir, 'briefing-stage1.md'),
-      briefings.buildSeatBriefing({ briefing: o.briefing, date: o.date }), { mode: 0o600 });
+      briefings.stage1SeatBriefing(o.intent, { briefing: o.briefing, date: o.date }), { mode: 0o600 });
 
     // ---- Stage 1: independent reviews ----
     // Lens mode launches one solo per seat instead of a `-s1` seat wave, so it
@@ -229,7 +239,7 @@ async function runCouncil(options, deps = {}) {
     // falls back to r.model on a miss rather than assuming the two arrays stay
     // symmetric — a naive seatKey on both sides would make that orphan's
     // conformance unreachable instead of merged, a silent total loss.
-    const seatKey = (s, alias) => (s ? s.id : alias);
+    const { seatKey } = require('./run-retry-keys');   // v4.9 W3 (SI-DUP b): the one rule, one home
     const byJudge = new Map(s2.judgeResults.map(j => [seatKey(j.seat, j.judge), j]));
     for (const r of s1.reviews) {
       const j = byJudge.get(r.seat ? r.seat.id : r.model) || byJudge.get(r.model);
@@ -242,16 +252,21 @@ async function runCouncil(options, deps = {}) {
     // buildTallyInput appends after the primary review rows (run-assemble.js
     // docblock). Neither stage invents a second mechanism for the other's kind
     // of row.
-    const mkInput = (chairStats, chairModel) => asm.buildTallyInput({
-      runId: o.runId, date: o.date, bench: o.models.slice(), chair: chairModel,
-      reviews: s1.reviews, judgeResults: s2.judgeResults, chairStats, claudeReview,
-      extraRows: [...s1.extraRows, ...s2.extraRows],
-      // v4.8 PR4c §3.2: the ONLY production caller of buildTallyInput, so this is
-      // the single seam meta.seats enters through. The final input is derived by
-      // SPREAD (run-finish.js:36), not rebuilt, so both the provisional and the
-      // debated input inherit it from here.
-      seats: o.seats,
-    });
+    const mkInput = (chairStats, chairModel) => {
+      const input = asm.buildTallyInput({
+        runId: o.runId, date: o.date, bench: o.models.slice(), chair: chairModel,
+        reviews: s1.reviews, judgeResults: s2.judgeResults, chairStats, claudeReview,
+        extraRows: [...s1.extraRows, ...s2.extraRows],
+        // v4.8 PR4c §3.2: the ONLY production caller of buildTallyInput, so this is
+        // the single seam meta.seats enters through. The final input is derived by
+        // SPREAD (run-finish.js:36), not rebuilt, so both the provisional and the
+        // debated input inherit it from here.
+        seats: o.seats,
+      });
+      // v4.9 W5.3: emit-when-'task' as a pure meta TAIL; review meta stays untouched.
+      if (o.intent === 'task') { input.meta = { ...input.meta, intent: 'task' }; }
+      return input;
+    };
     const provisionalInput = mkInput(null, o.chair);
     const provisional = tally(provisionalInput);
 

package/src/council/seats.js

@@ -33,7 +33,7 @@ function sanitizeName(model) {
  * Roles follow run-stages.js roleFor's PRECEDENCE — under lenses every seat is
  * a lens seat and 'critic' is unreachable — and match it for every bench the
  * CLI can produce (no repeated alias; lenses.length === bench.length, enforced
- * at cli-handlers-council-run.js:161). They DELIBERATELY diverge where roleFor
+ * at cli-handlers-council-run.js:164). They DELIBERATELY diverge where roleFor
  * is wrong: roles here are POSITIONAL, so twins under lenses get their own
  * lens instead of both getting the first twin's (roleFor uses
  * o.models.indexOf). An empty lenses array counts as no lenses (roleFor treats
@@ -73,7 +73,7 @@ function buildSeats(bench, critic, lenses) {
 /**
  * Role of a seat by its id. Returns 'seat' for an unknown id, matching
  * roleFor's fallthrough for any alias that is not the critic. (roleFor returns
- * 'critic' for an OFF-BENCH critic because run-stages.js:40 is not gated on
+ * 'critic' for an OFF-BENCH critic because run-stages.js:41 is not gated on
  * bench membership; buildSeats never mints a seat for one and preflightSeats
  * rejects that state pre-spend, so 'seat' is right for every run v4.8 creates.)
  * @param {?Array<object>} seats

package/src/council/stage1-bind.js

@@ -35,7 +35,7 @@ function bindStage1Waves(waves) {
     // either: an orphan leg is a review that LANDED — materializeReviews writes it
     // under its alias name — for a seat we cannot name. Retrying that seat would
     // buy a SECOND paid leg and put two reviews on one seat, breaking the
-    // invariant run-stages.js:142-151 states. The orphan is already announced on
+    // invariant run-stages.js:130-139 states. The orphan is already announced on
     // `seat-unbound` at bind time (R-B: orphans are not a loss and not retryable).
     if (legs.length === 0 || strays.length > 0) { continue; }
     for (const seat of unbound) {
@@ -90,7 +90,8 @@ function missingSeatDeadWave(m) {
  * and the alias lookup are parameterised — site 2's callback was literally
  * `(r, i) => { if (r.seat) … }`, reading the seat off a review, not off a roster
  * slot. The three sites: `run-retry-launch.js :: bindRetryWave`,
- * `run-stage2.js :: runStage2` and `run-debate-revote.js :: runRevoteWave`.
+ * `run-stage2.js :: bindStage2Seats` (in `runStage2` itself until the v4.9 W2
+ * function-length split) and `run-debate-revote.js :: runRevoteWave`.
  *
  * How this differs from `bindStage1Waves` above: that one takes MANY waves, each
  * with a REAL roster — no padding, no placeholders, and it owns its own missing/