amicus 4.6.2 → 4.7.0

package/src/council/run-chair.js

@@ -20,6 +20,7 @@ const { parseChairVerdict } = 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
@@ -31,15 +32,33 @@ const { emitStageStarted, emitStageTerminal } = require('../observe/events');
  * 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);
   const candidates = (statsRows || [])
-    .filter(r => r.model !== 'claude' && !benchSet.has(r.model) && r.model !== failedChair
-      && typeof r.avgStreetCredPeersOnly === 'number')
+    .filter(r => !excluded(r) && typeof r.avgStreetCredPeersOnly === 'number')
     .sort((a, b) => a.avgStreetCredPeersOnly - b.avgStreetCredPeersOnly);
-  return candidates.length ? candidates[0].model : null;
+  if (!candidates.length) { return null; }
+  const top = candidates[0];
+  return (Array.isArray(top.aliases) && top.aliases.length) ? top.aliases[0] : top.model;
 }
 
 /**
@@ -98,6 +117,7 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
       // v4.3 Task 3 (spec §7.2 named defect): without this, chair spend is
       // ledgered with councilRunId:null and is unattributable.
       councilRunId: o.runId, councilName: o.councilName,
+      tag: o.tag, // v4.7 F8 D16: rides the same forward as councilRunId/councilName.
     });
     addWave(solo.wave);
     const ok = solo.leg && solo.leg.status === 'complete'
@@ -117,12 +137,24 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
   // cost-skipped chair (the `if` branch) simply never calls recordAttempt —
   // chairAttempts is never checkpointed and the key stays absent on run.json.
   const chairAttempts = [];
+  // v4.7 D2 (spec "the count is the count"): a non-primary row per launch so
+  // spend is fully attributable — one 'chair-attempt' row per FAILED attempt
+  // that produced a rawLeg (null rawLeg = no wave = no money = no row), plus
+  // one 'repair' row for a launched ch4 (pushed below, after the ch4 block).
+  // The eventual SUCCESSFUL attempt's leg is never pushed here — it becomes
+  // the primary 'chair' row (wasChair:true) via run.js's own chairStats.
+  const chairRows = [];
   const recordAttempt = (attempt, waveId, model) => {
     const cls = classifyChairAttempt(attempt.rawLeg, attempt.errorDoc);
     chairAttempts.push({ waveId, model, outcome: cls.outcome, reason: cls.reason });
     // Checkpointed HERE, before the caller's own isAbortExit bail — a mid-walk
     // kill must not lose the attempts already resolved (spec §8 kill-mid-walk).
     runState.checkpoint(o.runDir, { chairAttempts });
+    if (!attempt.leg && attempt.rawLeg) {
+      chairRows.push(buildRunStatsEntry({
+        leg: attempt.rawLeg, model, role: 'chair-attempt', wasChair: false,
+      }));
+    }
   };
   if (overBudget()) {
     // Ceiling hit after the tally is computable: skip the chair, write the
@@ -143,12 +175,14 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
     emitStageStarted(o.runDir, o.runId, 'chair', null, o.follow);
     // Fallback chain (spec §4): retry same chair once → promote best
     // non-bench model from the ledger → give up (no Claude fallback headless).
-    let attempt = await attemptChair(o.chair, `${o.runId}-ch1`);
-    recordAttempt(attempt, `${o.runId}-ch1`, o.chair);
+    const waveId1 = `${o.runId}-ch1`;
+    let attempt = await attemptChair(o.chair, waveId1);
+    recordAttempt(attempt, waveId1, o.chair);
     if (isAbortExit(attempt.exitCode) || isSignalled()) { return bail(attempt.exitCode || isSignalled()); }
     if (!attempt.leg && !overBudget()) {
-      attempt = await attemptChair(o.chair, `${o.runId}-ch2`);
-      recordAttempt(attempt, `${o.runId}-ch2`, o.chair);
+      const waveId2 = `${o.runId}-ch2`;
+      attempt = await attemptChair(o.chair, waveId2);
+      recordAttempt(attempt, waveId2, o.chair);
       if (isAbortExit(attempt.exitCode) || isSignalled()) { return bail(attempt.exitCode || isSignalled()); }
     }
     if (attempt.leg) { actualChair = o.chair; }
@@ -157,8 +191,9 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
       try { statsRows = statsFn(); } catch { /* no ledger yet */ }
       const fallback = pickFallbackChair(statsRows, o.models, o.chair);
       if (fallback) {
-        attempt = await attemptChair(fallback, `${o.runId}-ch3`);
-        recordAttempt(attempt, `${o.runId}-ch3`, fallback);
+        const waveId3 = `${o.runId}-ch3`;
+        attempt = await attemptChair(fallback, waveId3);
+        recordAttempt(attempt, waveId3, fallback);
         if (isAbortExit(attempt.exitCode) || isSignalled()) { return bail(attempt.exitCode || isSignalled()); }
         if (attempt.leg) { actualChair = fallback; }
       }
@@ -180,19 +215,37 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
   // ---- Chair VERDICT line (one repair re-prompt, spec §5) ----
   let overallVerdict = chairText ? parseChairVerdict(chairText) : null;
   if (chairText && !overallVerdict && !overBudget()) {
-    runState.appendStageWave(o.runDir, 'chair', `${o.runId}-ch4`);
+    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
       // synthesis is picking a verdict on an artifact it has never read.
       model: actualChair, prompt: stage2.buildChairRepairPrompt({ synthesis: chairText }),
-      project: o.runDir, waveId: `${o.runId}-ch4`,
+      project: o.runDir, waveId: waveId4,
       timeout: o.timeout, gateway: o.gateway, noValidateModel: o.noValidateModel,
       noCostGate: o.noCostGate,
       councilRunId: o.runId, councilName: o.councilName,
+      tag: o.tag, // v4.7 F8 D16: rides the same forward as councilRunId/councilName.
     });
     addWave(repair.wave);
     if (isAbortExit(repair.exitCode) || isSignalled()) { return bail(repair.exitCode || isSignalled()); }
+    // repair.leg is the raw leg document — launchSolo DOES null it, but only
+    // on a wave-less failure (a pre-flight refusal with no wave launched at
+    // all: run-launch.js's launchSolo derives `leg` from `wave.legs[0]`, so
+    // no wave means no leg, no waveId, no money spent — the errata E3 "no
+    // leg = no wave = no money = no row" case). A wave that DID launch
+    // always yields a leg document, whatever its status. The `if
+    // (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.
+    if (repair.leg) {
+      chairRows.push(buildRunStatsEntry({
+        leg: repair.leg, model: actualChair, role: 'repair', wasChair: false,
+      }));
+    }
     overallVerdict = parseChairVerdict((repair.leg && repair.leg.summary) || '');
     chairConformance = overallVerdict ? 'repaired' : 'unstructured';
   }
@@ -213,6 +266,12 @@ async function runChair(ctx, { packet, degrade, statsFn, isSignalled }) {
 
   return {
     aborted: null, chairLeg, actualChair, chairText, chairConformance, overallVerdict,
+    // Additive (v4.7 D2): chairRows holds the non-primary rows (attempts +
+    // repair); chairAttempts is handed back too so run.js can key the
+    // give-up row on "the walk actually happened" without re-reading disk —
+    // NOT on chairRows, since attempts that die pre-wave record an outcome
+    // but produce no row (errata E3: no wave = no money = no row).
+    chairRows, chairAttempts,
   };
 }
 

package/src/council/run-debate.js

@@ -13,62 +13,38 @@ const fs = require('fs');
 const path = require('path');
 const dbrief = require('./briefings-debate');
 const { parseDebateDefense, parseRevote } = require('./parse-stage2');
-const { applyDebate, debateRunStatsRows, PAST_TENSE } = require('./debate');
+const { applyDebate, debateRunStatsRows, PAST_TENSE,
+  allNoResponse, nothingToDebate, disputingJudges, debateTargets, bundleFor } = require('./debate');
 const { materializeDebate } = require('./run-launch');
 const { tally } = require('./tally');
 const { isAbortExit } = require('./run-stages');
 const runState = require('./run-state');
 const { emitStageStarted } = require('../observe/events');
 
-/** Spec §5.7 fallback: a dead/unparseable defense means every bundled id's original stands. */
-function allNoResponse(ids) {
-  const byId = {};
-  for (const id of ids) { byId[id] = { action: 'no-response' }; }
-  return byId;
-}
-
-/** True when there is nothing to challenge (spec §5.1). */
-function nothingToDebate(provisionalRecord) {
-  if (!provisionalRecord || provisionalRecord.judged === false) { return true; }
-  const n = provisionalRecord.findings.filter(f => f.tier === 'Contested' || f.tier === 'Disputed').length;
-  return n === 0;
-}
-
-/** Judges whose provisional adjudications dispute at least one bundled id. */
-function disputingJudges(provisionalRecord, bundledIds) {
-  const ids = new Set(bundledIds);
-  const judges = new Set();
-  for (const f of provisionalRecord.findings) {
-    if (!ids.has(f.id)) { continue; }
-    for (const adj of f.adjudications || []) {
-      if (adj.verdict === 'dispute') { judges.add(adj.judge); }
-    }
-  }
-  return [...judges];
-}
-
-/** Group Contested+Disputed findings by raiser (defense targets). */
-function debateTargets(provisionalRecord, tallyInput) {
-  const claimById = new Map(tallyInput.findings.map(f => [f.id, f]));
-  const byRaiser = {};
-  const previousTier = {};
-  for (const f of provisionalRecord.findings) {
-    if (f.tier !== 'Contested' && f.tier !== 'Disputed') { continue; }
-    previousTier[f.id] = f.tier;
-    const src = claimById.get(f.id) || {};
-    const peerVerdicts = (f.adjudications || []).filter(a => a.judge !== f.raiser).map(a => a.verdict);
-    (byRaiser[f.raiser] = byRaiser[f.raiser] || []).push({ id: f.id, claim: src.claim,
-      severity: f.severity, location: src.location, peerVerdicts, disputeReasons: [] });
-  }
-  return { byRaiser, previousTier };
-}
-
 /** Common launch options for every debate leg (judge-isolated `_scratch` cwd). */
 function legOpts(ctx, waveId) {
   return { project: ctx.scratchDir, waveId, timeout: ctx.o.timeout, gateway: ctx.o.gateway,
     noValidateModel: ctx.o.noValidateModel, noCostGate: ctx.o.noCostGate,
     // v4.3 Task 3 (spec §7.2): attribution ids for every defense/re-vote leg.
-    councilRunId: ctx.o.runId, councilName: ctx.o.councilName };
+    councilRunId: ctx.o.runId, councilName: ctx.o.councilName,
+    tag: ctx.o.tag }; // v4.7 F8 D16: rides the same forward as councilRunId/councilName.
+}
+
+/**
+ * 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.
+ */
+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: '' };
 }
 
 async function runDefenseSolo(ctx, raiser, findings, idx) {
@@ -90,6 +66,12 @@ async function runDefenseSolo(ctx, raiser, findings, idx) {
   let parsed = leg ? parseDebateDefense(leg.summary, expectedIds)
     : { ok: false, byId: allNoResponse(expectedIds), errors: [{ code: 'DEAD_LEG', detail: 'no summary' }] };
   let conformance = leg ? 'clean' : 'unstructured';
+  // v4.7 D2/E4: the repair's loser leg — the ORIGINAL when the repair produced a
+  // usable (complete) leg (today's leg-swap below is unchanged), or the failed
+  // repair attempt itself when it did not — retained so runDebate can turn it
+  // into an extra debate-defense runStats row. Both stay null when no repair is
+  // attempted at all (today's single-row shape, byte-identical).
+  let supersededLeg = null, repairLeg = null;
   if (leg && !parsed.ok) {
     const repairId = `${waveId}r`;
     runState.appendStageWave(ctx.o.runDir, 'debate-defense', repairId);
@@ -103,13 +85,17 @@ async function runDefenseSolo(ctx, raiser, findings, idx) {
     const leg2 = res2.leg && res2.leg.status === 'complete' ? res2.leg : null;
     parsed = leg2 ? parseDebateDefense(leg2.summary, expectedIds) : parsed;
     conformance = parsed.ok ? 'repaired' : 'unstructured';
-    if (leg2) { leg = leg2; }
+    if (leg2) { supersededLeg = legRow(raiser, leg, 'unstructured'); leg = leg2; }
+    else { repairLeg = legRow(raiser, res2.leg, 'unstructured'); }
   }
   // A dead leg (no complete summary) OR an 'unstructured' conformance after the one
   // repair is a debate degradation (spec §5.7) — surfaced via the returned leg.
   const stub = { model: raiser, status: 'error', durationMs: null, usage: null, conformance: 'unstructured', summary: '' };
   return { raiser, byId: parsed.byId,
-    leg: leg ? { model: raiser, status: leg.status, durationMs: leg.durationMs, usage: leg.usage, conformance, summary: leg.summary } : stub };
+    leg: leg ? { model: raiser, status: leg.status, durationMs: leg.durationMs, usage: leg.usage,
+      conformance, summary: leg.summary, waveId: leg.waveId,
+      ...(leg.model ? { resolvedModel: leg.model } : {}) } : stub,
+    supersededLeg, repairLeg };
 }
 
 async function runRevoteWave(ctx, judges, bundleFindings) {
@@ -131,6 +117,9 @@ async function runRevoteWave(ctx, judges, bundleFindings) {
   ctx.addWave(res.wave);
   if (isAbortExit(res.exitCode)) { return { aborted: res.exitCode }; }
   const byJudge = {}, legs = [];
+  // v4.7 D2/E4: mirrors runDefenseSolo's supersededLeg/repairLeg — one list each,
+  // accumulated across every judge in this wave (most judges contribute neither).
+  const supersededLegs = [], repairLegs = [];
   for (const leg of ((res.wave && res.wave.legs) || [])) {
     // The council ALIAS, not the resolved executable id — runStats rows join
     // meta.models by exact string (run-assemble.js's buildRunStatsEntry).
@@ -154,27 +143,15 @@ async function runRevoteWave(ctx, judges, bundleFindings) {
       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) { outLeg = leg2; }
+      if (leg2) { supersededLegs.push(legRow(judge, leg, 'unstructured')); outLeg = leg2; }
+      else { repairLegs.push(legRow(judge, r2.leg, 'unstructured')); }
     }
     byJudge[judge] = parsed.byId;
-    legs.push({ model: judge, status: outLeg.status, durationMs: outLeg.durationMs, usage: outLeg.usage, conformance, summary: outLeg.summary || '' });
-  }
-  return { byJudge, legs };
-}
-
-/** The re-vote bundle: defended-or-amended findings ONLY (spec §5.1 — withdrawn never appear). */
-function bundleFor(defenseResults, tallyInput) {
-  const out = [];
-  for (const dr of defenseResults) {
-    for (const [id, resp] of Object.entries(dr.byId)) {
-      if (resp.action !== 'defend' && resp.action !== 'amend') { continue; }
-      const src = tallyInput.findings.find(f => f.id === id) || {};
-      out.push({ id, severity: src.severity, amended: resp.action === 'amend',
-        claim: resp.action === 'amend' ? resp.claim : src.claim,
-        argument: resp.argument || 'defended without extra argument' });
-    }
+    legs.push({ model: judge, status: outLeg.status, durationMs: outLeg.durationMs, usage: outLeg.usage,
+      conformance, summary: outLeg.summary || '', waveId: outLeg.waveId,
+      ...(outLeg.model ? { resolvedModel: outLeg.model } : {}) });
   }
-  return out;
+  return { byJudge, legs, supersededLegs, repairLegs };
 }
 
 /**
@@ -221,7 +198,7 @@ async function runDebate(ctx, { provisionalRecord, tallyInput }) {
   const stampedInput = { ...tallyInput, findings: tallyInput.findings.map(f => ({ ...f, previousTier: previousTier[f.id] })) };
 
   // ---- Re-vote mini-wave (disputing judges only) ----
-  let revoteByJudge = {}, revoteLegs = [];
+  let revoteByJudge = {}, revoteLegs = [], revoteSuperseded = [], revoteRepairs = [];
   const defendedOrAmended = bundleFor(defenseResults, tallyInput);
   const judges = disputingJudges(provisionalRecord, defendedOrAmended.map(f => f.id));
   // A re-vote is warranted only when something was defended/amended AND ≥1 judge disputed it.
@@ -238,6 +215,8 @@ async function runDebate(ctx, { provisionalRecord, tallyInput }) {
     if (rv.aborted) { return { aborted: rv.aborted, contested, disputed }; }
     revoteByJudge = rv.byJudge;
     revoteLegs = rv.legs;
+    revoteSuperseded = rv.supersededLegs;
+    revoteRepairs = rv.repairLegs;
     // revote-<model>.md per surviving judge leg, mirroring rebuttal-<model>.md
     // (spec §5.1 'raw outputs revote-<model>.md').
     materializeDebate(ctx.o.runDir, revoteLegs, 'revote');
@@ -247,7 +226,12 @@ async function runDebate(ctx, { provisionalRecord, tallyInput }) {
   const { input: debatedInput, debateFindings } = applyDebate({
     tallyInput: stampedInput, provisionalRecord, defenseByRaiser, revoteByJudge });
   debatedInput.runStats = [...(debatedInput.runStats || []),
-    ...debateRunStatsRows({ defenseLegs: defenseResults.map(d => d.leg), revoteLegs })];
+    ...debateRunStatsRows({ defenseLegs: defenseResults.map(d => d.leg), revoteLegs,
+      // v4.7 D2/E4: the retained loser legs from every raiser's defense repair
+      // plus every judge's re-vote repair — same append, no new channel into
+      // buildTallyInput.
+      supersededLegs: [...defenseResults.map(d => d.supersededLeg).filter(Boolean), ...revoteSuperseded],
+      repairLegs: [...defenseResults.map(d => d.repairLeg).filter(Boolean), ...revoteRepairs] })];
 
   // verdictChanges: findings whose tier moved from provisional to debated.
   const provTierById = new Map(provisionalRecord.findings.map(f => [f.id, f.tier]));

package/src/council/run-launch.js

@@ -63,10 +63,13 @@ function createLaunchers(deps = {}) {
   /**
    * @param {{models: string[], prompt: string, project: string, waveId: string,
    *   timeout?: number, gateway?: string, noValidateModel?: boolean, agent?: string,
-   *   councilRunId?: string, councilName?: string, fallback?: object, catalog?: Array}} opts
+   *   councilRunId?: string, councilName?: string, tag?: string, fallback?: object,
+   *   catalog?: Array}} opts
    *   councilRunId/councilName (v4.3 Task 3, spec §7.2) are additive attribution
    *   ids forwarded verbatim into the runFanout call so it can stamp them onto
-   *   every leg. fallback/catalog (v4.3 Task 18, spec §6.2) are likewise
+   *   every leg. tag (v4.7 F8 D16) rides the same forward — every call site
+   *   below that sets councilRunId/councilName sets `tag: o.tag` alongside it.
+   *   fallback/catalog (v4.3 Task 18, spec §6.2) are likewise
    *   additive/opt-in — omitted by callers that must never substitute (the
    *   chair, debate legs); run-stages.js's Stage-1/Stage-2 launches pass them.
    * @returns {Promise<{wave: object|null, exitCode: number}>}
@@ -111,6 +114,10 @@ function createLaunchers(deps = {}) {
       noValidateModel: opts.noValidateModel,
       councilRunId: opts.councilRunId,
       councilName: opts.councilName,
+      // v4.7 F8 D16: rides the SAME forward as councilRunId/councilName above —
+      // undefined when no --tag, so stampLegAttribution's `if (options.tag)`
+      // guard (fanout-wave-io.js) simply no-ops, byte-identical to today.
+      tag: opts.tag,
       // v4.3 Task 18 (spec §6.2): additive/opt-in. Callers that must never
       // substitute (run-chair.js, run-debate.js) simply omit these — runLeg's
       // fallback path only activates when `fallback.enabled` is true.

package/src/council/run-retry.js

@@ -141,7 +141,8 @@ function briefingFor(o, unit) {
 async function retryStage1Losses(ctx, { deadWaves = [], deadLegs = [], counts = { reviewed: 0, total: 0 } } = {}) {
   const { o, launchers } = ctx;
   const out = { aborted: null, recoveredLegs: [], stillDeadNotes: [],
-    stillDeadWaves: [], stillDeadLegs: [], skippedDeadWaves: [], skippedDeadLegs: [] };
+    stillDeadWaves: [], stillDeadLegs: [], skippedDeadWaves: [], skippedDeadLegs: [],
+    stillDeadRetryLegs: [] };
 
   for (const unit of groupStage1Losses(o, deadWaves, deadLegs)) {
     // Task-4 review hardening: a unit this pass cannot even ATTEMPT — an
@@ -168,6 +169,7 @@ async function retryStage1Losses(ctx, { deadWaves = [], deadLegs = [], counts =
     const common = { project: o.runDir, timeout: o.timeout, gateway: o.gateway,
       noValidateModel: o.noValidateModel, noCostGate: o.noCostGate,
       councilRunId: o.runId, councilName: o.councilName,
+      tag: o.tag, // v4.7 F8 D16: rides the same forward as councilRunId/councilName.
       fallback: o.fallback, catalog: o.catalog,
       waveId: unit.waveId, retryOfWaveId: unit.retryOfWaveId, prompt: briefingFor(o, unit) };
     // Dispatch by UNIT TYPE, not model count (spec §4: bench is always a wave —
@@ -234,6 +236,7 @@ async function retryStage1Losses(ctx, { deadWaves = [], deadLegs = [], counts =
           data: { seat, retryWaveId: unit.waveId, retryOfWaveId: unit.retryOfWaveId, firstFailure: ff } });
       } else {
         out.stillDeadNotes.push(retryLegStillDeadNote(seat, ff, leg, unit, counts));
+        out.stillDeadRetryLegs.push(leg);
         if (ff && ff.class === 'wave') {
           if (!lostWaveSeats.has(ff.waveId)) { lostWaveSeats.set(ff.waveId, []); }
           lostWaveSeats.get(ff.waveId).push(seat);

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

@@ -0,0 +1,94 @@
+/**
+ * Stage-1 launch pass for the council engine.
+ *
+ * launchStage1 moved verbatim from run-stages.js (v4.7 PR1 Task 1) to free
+ * gate headroom before the row-per-launch edits land there.
+ */
+'use strict';
+
+const briefings = require('./briefings');
+const runState = require('./run-state');
+const { isAbortExit } = require('./run-launch');
+
+/** Launch all Stage-1 legs (wave + critic/lens solos), collect run docs. */
+async function launchStage1(ctx) {
+  const { o, launchers } = ctx;
+  // `noCostGate` rides EVERY launch object in this file (here, the findings
+  // repair, the judge wave, the judge repair) — see run-launch.js's fanout call.
+  const common = {
+    project: o.runDir, timeout: o.timeout, gateway: o.gateway,
+    noValidateModel: o.noValidateModel, noCostGate: o.noCostGate,
+    // v4.3 Task 3 (spec §7.2): attribution ids, forwarded verbatim to runFanout
+    // via run-launch.js so every Stage-1 leg's ledger row carries them.
+    councilRunId: o.runId, councilName: o.councilName,
+    tag: o.tag, // v4.7 F8 D16: rides the same forward as councilRunId/councilName.
+    // v4.3 Task 18 (spec §6.2): fallback chains apply to STAGE legs only —
+    // the chair (run-chair.js) and debate legs (run-debate.js) never receive
+    // this, so they never substitute via chains.
+    fallback: o.fallback, catalog: o.catalog,
+  };
+  const launches = [];
+  const seated = []; // parallel to `launches`: what each one was SUPPOSED to seat
+  // Record every sub-wave BEFORE it launches: `amicus abort` cascades over
+  // stages[].waveIds, so an id written after the launch leaves that leg
+  // reachable only by the pid kill (no per-leg abort marker).
+  const record = (waveId) => runState.appendStageWave(o.runDir, 'stage1', waveId);
+  if (o.lenses) {
+    o.models.forEach((m, i) => {
+      const waveId = `${o.runId}-l${i + 1}`;
+      record(waveId);
+      seated.push({ waveId, models: [m] });
+      launches.push(launchers.launchSolo({
+        ...common, model: m, waveId,
+        prompt: briefings.buildLensBriefing({ lens: o.lenses[i], briefing: o.briefing, date: o.date }),
+      }));
+    });
+  } else {
+    const seats = o.models.filter(m => m !== o.critic);
+    if (seats.length > 0) {
+      record(`${o.runId}-s1`);
+      seated.push({ waveId: `${o.runId}-s1`, models: seats.slice() });
+      launches.push(launchers.launchWave({
+        ...common, models: seats, waveId: `${o.runId}-s1`,
+        prompt: briefings.buildSeatBriefing({ briefing: o.briefing, date: o.date }),
+      }));
+    }
+    if (o.critic) {
+      record(`${o.runId}-c1`);
+      seated.push({ waveId: `${o.runId}-c1`, models: [o.critic] });
+      launches.push(launchers.launchSolo({
+        ...common, model: o.critic, waveId: `${o.runId}-c1`,
+        prompt: briefings.buildCriticBriefing({ briefing: o.briefing, date: o.date }),
+      }));
+    }
+  }
+  const results = await Promise.all(launches);
+  let aborted = null;
+  const legs = [];
+  const deadWaves = [];
+  results.forEach((r, i) => {
+    ctx.addWave(r.wave);
+    const abort = isAbortExit(r.exitCode);
+    if (abort) { aborted = r.exitCode; }
+    const got = (r.wave && Array.isArray(r.wave.legs)) ? r.wave.legs : [];
+    legs.push(...got);
+    // ⚠️ Step 10's uncovered half. A wave that died BEFORE its legs (the server
+    // never started; `database is locked`) contributes NOTHING to `legs`, so
+    // deadLegs cannot see it either — which is how run v441plan01 recorded
+    // stage1 'complete' with four seats missing and no trace of them. In lens
+    // mode every seat is its own wave, so a run could lose seats and still exit
+    // 0; the quorum gate only catches the non-lens seat wave. A budget refusal
+    // has its own louder channel already (run-budget.noteBudgetRefusal) and
+    // must not be double-counted here.
+    if (got.length > 0 || abort) { return; }
+    if (r.errorDoc && r.errorDoc.code === 'BUDGET_EXCEEDED') { return; }
+    deadWaves.push({
+      waveId: seated[i].waveId, models: seated[i].models,
+      reason: (r.wave && (r.wave.reason || r.wave.error))
+        || (r.errorDoc && r.errorDoc.message) || 'the wave produced no legs',
+    });
+  });
+  return { aborted, legs, deadWaves };
+}
+
+module.exports = { launchStage1 };

package/src/council/run-stage2.js

@@ -23,6 +23,7 @@ const stage2 = require('./briefings-stage2');
 const { parseJudgeOutput } = require('./parse-stage2');
 const { sanitizeName, isAbortExit } = require('./run-launch');
 const runState = require('./run-state');
+const { buildRunStatsEntry } = require('./run-assemble');
 
 /**
  * Stage 2: shared anonymized bundle → judge wave in _scratch → parse + repair.
@@ -31,7 +32,12 @@ const runState = require('./run-state');
  *   extraLabeled?: Array<{label: string, text: string}>}} args
  *   `extraLabeled` (v4.1 §4.4) are labeled reviews sourced from a FILE rather than
  *   a leg (the Claude review): they join the judged BUNDLE, never the judge ROSTER.
- * @returns {Promise<{aborted: number|null, judgeResults: Array}>}
+ * @returns {Promise<{aborted: number|null, judgeResults: Array, extraRows: Array}>}
+ *   `extraRows` (v4.7 D2, mirroring runStage1's channel) is one `role:'repair'`
+ *   row per `-q<N>` judge-repair solo (error status when the repair itself
+ *   failed) — the judge's own judgeResults entry keeps attributing its ORIGINAL
+ *   Stage-2 wave leg throughout (the #83 comment below), so a repair never
+ *   overwrites the primary judge row; it only adds this separate one.
  */
 async function runStage2(ctx, { reviews, labels, globalFindings, extraLabeled = [] }) {
   const { o } = ctx;
@@ -59,12 +65,18 @@ async function runStage2(ctx, { reviews, labels, globalFindings, extraLabeled =
     timeout: o.timeout, gateway: o.gateway, noValidateModel: o.noValidateModel,
     noCostGate: o.noCostGate,
     councilRunId: o.runId, councilName: o.councilName,
+    tag: o.tag, // v4.7 F8 D16: rides the same forward as councilRunId/councilName.
     fallback: o.fallback, catalog: o.catalog,
   });
   ctx.addWave(wave);
-  if (isAbortExit(exitCode)) { return { aborted: exitCode, judgeResults: [] }; }
+  if (isAbortExit(exitCode)) { return { aborted: exitCode, judgeResults: [], extraRows: [] }; }
 
   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).
+  const extraRows = [];
   let repairSeq = 0;
   for (const leg of (wave && wave.legs) || []) {
     const judge = leg.modelInput || leg.model;
@@ -95,10 +107,19 @@ async function runStage2(ctx, { reviews, labels, globalFindings, extraLabeled =
         project: ctx.scratchDir, waveId, timeout: o.timeout,
         gateway: o.gateway, noValidateModel: o.noValidateModel, noCostGate: o.noCostGate,
         councilRunId: o.runId, councilName: o.councilName,
+        tag: o.tag, // v4.7 F8 D16: rides the same forward as councilRunId/councilName.
         fallback: o.fallback, catalog: o.catalog,
       });
       ctx.addWave(solo.wave);
-      if (isAbortExit(solo.exitCode)) { return { aborted: solo.exitCode, judgeResults }; }
+      if (isAbortExit(solo.exitCode)) {
+        // Abort paths add no rows (aborted runs never reach tally) — extraRows
+        // 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);
@@ -120,7 +141,7 @@ async function runStage2(ctx, { reviews, labels, globalFindings, extraLabeled =
     judgeResults.push({ judge, ok: true, order, adjudications: parsed.adjudications, conformance,
       leg: leg || null });
   }
-  return { aborted: null, judgeResults };
+  return { aborted: null, judgeResults, extraRows };
 }
 
 module.exports = { runStage2 };