amicus 4.7.1 → 4.8.1

package/src/council/briefings-chair.js

@@ -0,0 +1,272 @@
+// src/council/briefings-chair.js
+'use strict';
+// Chair briefing surface: packet, repair prompt, verdict scale, task
+// templates, no-tools preamble. Moved verbatim from briefings-stage2.js
+// (chunks :16-20 and :154-279 at e8406db; v4.8 PR0 size-gate split, zero
+// behavior). dateLine lives HERE (not required back from stage2) because
+// stage2 requires this module — a back-require would be a cycle that
+// resolves dateLine to undefined at load. briefings-stage2.js re-exports
+// every public name below so existing import paths stay stable.
+//
+// ./seats is the ONLY require here, and it is cycle-free by construction: that
+// module deliberately requires nothing (seats.js header), so the load-order
+// hazard above does not apply to it. Do NOT require ./briefings-stage2.
+const { displayName } = require('./seats');
+
+const CHAIR_NO_TOOLS_PREAMBLE =
+  'Do NOT use any tools or read any files; everything is in this message; ' +
+  'begin immediately with the verdict.';
+
+const CHAIR_VERDICT_VALUES = ['Ship it', 'Fix these first', 'Fundamental rethink'];
+
+/** Shared date line (spec §4.3) — prepended to every model-facing briefing. */
+function dateLine(date) { return `Today's date is ${date}.`; }
+
+/** Verdict-scale addendum (SEAT-BRIEFS.md § Chair verdict-scale addendum; always on headless). */
+const VERDICT_SCALE_ADDENDUM = [
+  'After your synthesis, add two closing sections:',
+  '',
+  '1. HARD QUESTIONS — three to five questions the material\'s author has probably not',
+  '   asked themselves, chosen so that an unanswerable question reveals a structural gap',
+  '   (not gotchas — questions whose answers should exist).',
+  '2. A final line, alone on the last line, containing ONLY the phrase — no rationale, no',
+  '   dash, no trailing text of any kind — exactly one of:',
+  '',
+  '   VERDICT: Ship it',
+  '   VERDICT: Fix these first',
+  '   VERDICT: Fundamental rethink',
+  '',
+  '   Pick one. "Ship it" = solid, nothing blocking. "Fix these first" = specific gaps',
+  '   must be resolved first. "Fundamental rethink" = structural problems that cannot be',
+  '   patched. Name the gaps or the structural problems in the synthesis ABOVE, not on the',
+  '   VERDICT line itself — that line carries the phrase and nothing else.',
+].join('\n');
+
+/** The chair's opening instruction when there is something to weigh (the ordinary case). */
+const CHAIR_TASK =
+  'You are the council chair. Write the synthesized verdict across the reviews, ' +
+  'rankings, and adjudications below. Weigh each reviewer\'s findings by their ' +
+  'peer-validated standing (rank position and adjudication pattern), distinguish ' +
+  'findings the bench broadly endorsed from contested or singleton claims, and ' +
+  'arrive at an overall assessment of the material.';
+
+/**
+ * The chair's opening instruction when the bench raised nothing at all (LC-10
+ * fast-follow, review minor M2).
+ *
+ * Task 3 fixed this by keeping CHAIR_TASK unchanged and appending a correcting note
+ * — asymmetric with buildJudgeBundle, which swaps JUDGE_TASK_B for
+ * JUDGE_TASK_B_NO_FINDINGS outright. The un-swapped CHAIR_TASK asks the chair to
+ * "distinguish findings the bench broadly endorsed from contested or singleton
+ * claims" over an empty tier table and two bare section headings — an instruction
+ * whose only satisfiable reading is to invent material — and the chair reads that
+ * unfollowable directive FIRST, the correction second. This constant replaces
+ * CHAIR_TASK entirely on a clean bench instead: it never asks for a distinction
+ * that cannot exist, and the clean-bench framing (still stated, not just implied)
+ * is now the only instruction the chair sees, not an amendment to a bad one.
+ */
+const CHAIR_TASK_NO_FINDINGS =
+  'You are the council chair. Write the synthesized verdict across the reviews and ' +
+  'rankings below. Weigh each reviewer\'s standing by rank position, and arrive at ' +
+  'an overall assessment of the material. NOTE: this bench raised NO findings. ' +
+  'Every reviewer read the material and reported nothing to fix, which is a valid ' +
+  'outcome — not a failed run. Synthesize on that basis: say what the reviews ' +
+  'actually establish and where the bench\'s agreement is thin, and do not ' +
+  'manufacture concerns to fill the sections below.';
+
+/** A section body, or an explicit reason it is empty — never a heading over nothing. */
+function orNone(text, none) {
+  return (typeof text === 'string' && text.trim()) ? text : none;
+}
+
+/**
+ * Site (3)'s per-slot zip (v4.8 SI-25, ruling R25-3). `order` and `orderSeats`
+ * are PARALLEL per-slot arrays minted together by
+ * `anonymize.js :: rankingToOrder`, and a slot is either a scalar or an array
+ * (a tie group) — hence the two arms.
+ *
+ * EVERY read is a fallback, because `orderSeats` is a PARITY SHAPE, not a
+ * presence: its `seatOne` returns `(seatMap && seatMap[label]) || null`, and
+ * `run-assemble.js :: buildTallyInput` ships the array whenever ANY entry is
+ * truthy — so a MIXED array of seat ids and `null`s is a normal shipping shape.
+ * No `null` may reach the rendered JSON: this is the one artifact a paid chair
+ * reads as authoritative. An absent `orderSeats` returns `order` untouched
+ * (spec §4.2's byte-identity promise). ⚠️ That promise is UNCONDITIONAL as of
+ * the SHAPESWAP fix — it holds even when the two arrays DISAGREE on a slot's
+ * structure (scalar vs array), which no producer here can emit but which two
+ * independent reviewers reached for. A disagreeing slot falls back to `order`'s
+ * own value and NEVER changes that slot's shape.
+ *
+ * ⚠️ The SHORT-array arm is DEFENSIVE, and this docblock does not claim
+ * otherwise: `rankingToOrder` mints both arrays from one `slots.map`, so no
+ * producer in this tree can emit an `orderSeats` shorter than its `order`
+ * (measured — 0 mismatches over 24 ranking × seatMap shapes). The arm and its
+ * pin guard hand-assembled input, which is why they stay.
+ *
+ * ⚠️ `||`, deliberately, NOT `??`. `anonymize.js :: rankingToOrder`'s `seatOne`
+ * returns `(seatMap && seatMap[label]) || null`, so every entry this array can
+ * hold is already truthy-or-null and the two operators are behaviourally
+ * identical on it. Where they differ — a falsy-but-present id — `||` falls back
+ * to the alias and `??` would render the empty string into the packet, so `||`
+ * is never worse and sometimes safer. It is also this spine's convention
+ * (`seat || alias` at every other site). PR #189's council raised the swap as
+ * A1 (solid); declined on that measurement, and recorded here so the next
+ * reader does not re-propose it as a tidy-up.
+ *
+ * Two named mutants guard the two arms — NULLLEAK the scalar fallback, FLATTIE
+ * the tie arm — with their measured red sets in
+ * tests/council/chair-packet-seat-mutants.js :: NULLLEAK. Re-run them, never
+ * renumber, if this expression or its pins change.
+ */
+function seatKeyedOrder(order, orderSeats) {
+  if (!Array.isArray(order) || !Array.isArray(orderSeats)) { return order; }
+  return order.map((slot, i) => {
+    const seats = orderSeats[i];
+    return Array.isArray(slot)
+      ? slot.map((alias, k) => (Array.isArray(seats) ? seats[k] : null) || alias)
+      // ⚠️ `Array.isArray(seats)` here, NOT just `seats || slot`: a scalar `order`
+      // slot against an ARRAY `orderSeats` slot returned the seats array RAW, which
+      // both changed the slot's shape and could render `[null,null]` — breaking the
+      // no-null promise above for the one input class this arm exists to defend.
+      // Named mutant SHAPESWAP (drop this guard) in
+      // tests/council/chair-packet-seat-mutants.js :: SHAPESWAP.
+      : (Array.isArray(seats) ? slot : (seats || slot));
+  });
+}
+
+/**
+ * De-anonymized chair packet (spec §5/§6: the chair sees identities).
+ *
+ * ⚠️ `seat` is an OBJECT on `reviews[]` and a STRING on `rankings[]` and
+ * `adjudications[]`. Deliberate, and declared as such in the @param below.
+ * Reviews carry the object because `seats.js :: displayName` is the naming seam
+ * (v4.8 SI-25 / R25-4); the other two carry `j.seat.id` because
+ * `run-assemble.js :: buildTallyInput` has emitted a string there since PR4c and
+ * changing it would move a shipped tally schema. These are three arrays each
+ * with one consistently-typed field, not one polymorphic field. PR #189's
+ * council raised it as D1 (major, CONTESTED a1/d1/n1); declined on that reading.
+ * @param {{reviews: Array<{model: string, text: string, seat?: ?object}>,
+ *   rankings: Array<{judge: string, seat?: ?string, order: Array<string|string[]>,
+ *     orderSeats?: ?Array<?string|Array<?string>>}>,
+ *   adjudications: Array<{findingId: string, judge: string, seat?: ?string, verdict: string}>,
+ *   tierCounts: object}} args
+ *   `rankings` and `adjudications` may both be empty — an all-clean bench (LC-10)
+ *   has nothing to adjudicate, and a Stage 2 whose judges all died has nothing to
+ *   rank. Each empty section says WHICH of those it is rather than rendering blank.
+ */
+function buildChairPacket({ reviews, rankings, adjudications, tierCounts, date, findings }) {
+  // ⚠️ v4.8 SI-25: all three rendering sites below are SEAT-KEYED with an ALIAS
+  // FALLBACK. Alias-keyed, a twin bench handed the chair "tier counts:
+  // {Confirmed: 1}" beside two identical `A1 — deepseek:` lines, with nothing in
+  // the packet able to reconcile them; PR4c seat-keyed the report and the
+  // Workspace matrix but not this packet, so the human-facing artifact and the
+  // model-facing one disagreed.
+  // ⚠️ THIS PACKET IS PROSE, NEVER A LAUNCH ARGUMENT — that boundary is what
+  // makes seat ids safe here. A seat id in a model-carrying LAUNCH argument is a
+  // non-routable model name and a real paid failure, which is why `order`,
+  // `orderSeats`, `tallyInput`, verdict.json, the report and every launcher
+  // option stay alias-valued and untouched (run-debate.test.js's parity pin
+  // guards that boundary). Nothing routes on this artifact.
+  // The fallbacks are load-bearing, not defensive — named mutants ALIASBACK and
+  // SEATONLY, with their measured red sets, in
+  // tests/council/chair-packet-seat-mutants.js :: ALIASBACK. On a unique-alias
+  // bench the seat channel is ABSENT at every site (spec §4.2's
+  // emit-when-DIFFERENT rule), so the rendering is byte-identical there by
+  // construction — and the review projection that feeds site (1) applies that
+  // same rule for a reason its own comment gives.
+  const reviewBlocks = reviews
+    .map(r => `--- Review by ${displayName(r.seat) || r.model} ---\n${r.text}`).join('\n\n');
+  const rankingLines = (rankings || [])
+    .map(r => `${r.seat || r.judge}: ${JSON.stringify(seatKeyedOrder(r.order, r.orderSeats))}`)
+    .join('\n');
+  const adjLines = (adjudications || [])
+    .map(a => `${a.findingId} — ${a.seat || a.judge}: ${a.verdict}`)
+    .join('\n');
+  // ⚠️ v4.8 PR5a T7 (R5-3): surface R8. tally.js has stamped sameModelCorroboration since
+  // PR4c and it reached verdict.json — and stopped. Spec §4.6 says the chair packet is
+  // REQUIRED to surface it; measured, nothing did. A Confirmed reached only via the
+  // raiser's own twin read to the chair exactly like independent corroboration, which is
+  // the overstatement R8 was chosen over model-exact exclusion to prevent.
+  // Emit-when-present, so a bench that raised none is byte-identical.
+  const corroborated = (findings || [])
+    // ⚠️ `&& f.id` (council-3 C3, as corrected by measurement): the reported symptom —
+    // 'undefined' in the prose — does NOT occur, because Array#join renders undefined as ''.
+    // What DID render is worse in kind: "…corroborated only by a same-model seat: ." — the R8
+    // caveat firing while naming nobody, in the one artifact a paid chair reads as
+    // authoritative. Unnameable findings are dropped, and the emit-when-present guard below
+    // then suppresses the section entirely rather than showing an empty list.
+    .filter(f => f && f.sameModelCorroboration && f.id)
+    .map(f => f.id);
+  // Every finding lands in exactly one tier (tally.js countTiers), so the tier
+  // counts sum to the record's finding count — which is how an all-clean bench is
+  // told apart from a bench whose judges simply never voted.
+  const raisedCount = Object.values(tierCounts || {})
+    .reduce((s, n) => s + (typeof n === 'number' ? n : 0), 0);
+  const tiers = JSON.stringify(tierCounts);
+  const parts = [CHAIR_NO_TOOLS_PREAMBLE];
+  if (date) { parts.push(dateLine(date)); }
+  parts.push(raisedCount === 0 ? CHAIR_TASK_NO_FINDINGS : CHAIR_TASK);
+  parts.push(
+    `Deterministic tier counts (peers-only cascade): ${tiers}`,
+    '--- STAGE-1 REVIEWS (de-anonymized) ---',
+    reviewBlocks,
+    '--- PEER RANKINGS (judge: order, best first) ---',
+    orNone(rankingLines, '(none — no judge produced a usable ranking)'),
+    '--- PER-FINDING ADJUDICATIONS ---',
+    orNone(adjLines, raisedCount === 0
+      ? '(none — the bench raised no findings, so there was nothing to adjudicate)'
+      : '(none — no judge produced a usable adjudication)'),
+  );
+  // Placed AFTER the adjudications it qualifies and BEFORE the verdict scale, so the chair
+  // reads the caveat while the votes are still in view rather than after being told how to
+  // score them.
+  if (corroborated.length) {
+    parts.push(
+      '--- SAME-MODEL CORROBORATION (R8) ---',
+      `These findings were agreed only by a seat running the SAME model as the raiser: ${corroborated.join(', ')}.`
+      + ' Their tier reflects concurrence between two generations of one model, not independent support.'
+      + ' Weigh them accordingly.',
+    );
+  }
+  parts.push(VERDICT_SCALE_ADDENDUM);
+  return parts.join('\n\n');
+}
+
+/**
+ * One-shot chair repair: the VERDICT line was missing (spec §5 chair contract).
+ *
+ * ⚠️ LC-12: this builder took NO arguments at all, so the repair solo — a fresh
+ * session — was asked for a verdict on a synthesis it could not see. The chair's
+ * synthesis WAS received; it is the verdict line that is missing. Handing back the
+ * synthesis lets the chair pick the verdict its own prose supports instead of
+ * re-deriving one from nothing.
+ * @param {{synthesis?: string}} [args]
+ */
+function buildChairRepairPrompt({ synthesis } = {}) {
+  const text = typeof synthesis === 'string' ? synthesis.trim() : '';
+  const prior = text
+    ? ['--- YOUR SYNTHESIS (verbatim — verdict on THIS) ---', text,
+      '--- END OF YOUR SYNTHESIS ---'].join('\n')
+    : null;
+  return [
+    'Do NOT use any tools or read any files; everything is in this message; begin '
+    + 'immediately with the VERDICT line.',
+    ...(prior ? [prior] : []),
+    'Your synthesis was received, but the final parseable line was missing. Emit ONLY '
+    + 'one line, exactly one of:',
+    'VERDICT: Ship it',
+    'VERDICT: Fix these first',
+    'VERDICT: Fundamental rethink',
+  ].join('\n\n');
+}
+
+module.exports = {
+  dateLine,
+  CHAIR_NO_TOOLS_PREAMBLE,
+  CHAIR_VERDICT_VALUES,
+  VERDICT_SCALE_ADDENDUM,
+  CHAIR_TASK,
+  CHAIR_TASK_NO_FINDINGS,
+  buildChairPacket,
+  buildChairRepairPrompt,
+};

package/src/council/briefings-stage2.js

@@ -9,19 +9,16 @@
  * seat/lens/critic information or model names (skill §5.1 / Stage-2 rule).
  */
 
+// Chair surface lives in ./briefings-chair (v4.8 PR0 size-gate split).
+// Every chair name is re-exported below — run-chair.js, run-assemble.js,
+// briefings-debate.js and the briefings tests import them from here.
+const chair = require('./briefings-chair');
+const { dateLine } = chair;
+
 const JUDGE_NO_TOOLS_PREAMBLE =
   'Do NOT use any tools or read any files; everything is in this message; ' +
   'begin immediately with A1:';
 
-const CHAIR_NO_TOOLS_PREAMBLE =
-  'Do NOT use any tools or read any files; everything is in this message; ' +
-  'begin immediately with the verdict.';
-
-const CHAIR_VERDICT_VALUES = ['Ship it', 'Fix these first', 'Fundamental rethink'];
-
-/** Shared date line (spec §4.3) — prepended to every model-facing briefing. */
-function dateLine(date) { return `Today's date is ${date}.`; }
-
 /**
  * Stage-2 headless output contract (spec §5, embedded in the judge bundle).
  *
@@ -151,137 +148,12 @@ function buildJudgeRepairPrompt({ errors, judgement }) {
   ].join('\n\n');
 }
 
-/** Verdict-scale addendum (SEAT-BRIEFS.md § Chair verdict-scale addendum; always on headless). */
-const VERDICT_SCALE_ADDENDUM = [
-  'After your synthesis, add two closing sections:',
-  '',
-  '1. HARD QUESTIONS — three to five questions the material\'s author has probably not',
-  '   asked themselves, chosen so that an unanswerable question reveals a structural gap',
-  '   (not gotchas — questions whose answers should exist).',
-  '2. A final line, alone on the last line, containing ONLY the phrase — no rationale, no',
-  '   dash, no trailing text of any kind — exactly one of:',
-  '',
-  '   VERDICT: Ship it',
-  '   VERDICT: Fix these first',
-  '   VERDICT: Fundamental rethink',
-  '',
-  '   Pick one. "Ship it" = solid, nothing blocking. "Fix these first" = specific gaps',
-  '   must be resolved first. "Fundamental rethink" = structural problems that cannot be',
-  '   patched. Name the gaps or the structural problems in the synthesis ABOVE, not on the',
-  '   VERDICT line itself — that line carries the phrase and nothing else.',
-].join('\n');
-
-/** The chair's opening instruction when there is something to weigh (the ordinary case). */
-const CHAIR_TASK =
-  'You are the council chair. Write the synthesized verdict across the reviews, ' +
-  'rankings, and adjudications below. Weigh each reviewer\'s findings by their ' +
-  'peer-validated standing (rank position and adjudication pattern), distinguish ' +
-  'findings the bench broadly endorsed from contested or singleton claims, and ' +
-  'arrive at an overall assessment of the material.';
-
-/**
- * The chair's opening instruction when the bench raised nothing at all (LC-10
- * fast-follow, review minor M2).
- *
- * Task 3 fixed this by keeping CHAIR_TASK unchanged and appending a correcting note
- * — asymmetric with buildJudgeBundle, which swaps JUDGE_TASK_B for
- * JUDGE_TASK_B_NO_FINDINGS outright. The un-swapped CHAIR_TASK asks the chair to
- * "distinguish findings the bench broadly endorsed from contested or singleton
- * claims" over an empty tier table and two bare section headings — an instruction
- * whose only satisfiable reading is to invent material — and the chair reads that
- * unfollowable directive FIRST, the correction second. This constant replaces
- * CHAIR_TASK entirely on a clean bench instead: it never asks for a distinction
- * that cannot exist, and the clean-bench framing (still stated, not just implied)
- * is now the only instruction the chair sees, not an amendment to a bad one.
- */
-const CHAIR_TASK_NO_FINDINGS =
-  'You are the council chair. Write the synthesized verdict across the reviews and ' +
-  'rankings below. Weigh each reviewer\'s standing by rank position, and arrive at ' +
-  'an overall assessment of the material. NOTE: this bench raised NO findings. ' +
-  'Every reviewer read the material and reported nothing to fix, which is a valid ' +
-  'outcome — not a failed run. Synthesize on that basis: say what the reviews ' +
-  'actually establish and where the bench\'s agreement is thin, and do not ' +
-  'manufacture concerns to fill the sections below.';
-
-/** A section body, or an explicit reason it is empty — never a heading over nothing. */
-function orNone(text, none) {
-  return (typeof text === 'string' && text.trim()) ? text : none;
-}
-
-/**
- * De-anonymized chair packet (spec §5/§6: the chair sees identities).
- * @param {{reviews: Array<{model: string, text: string}>,
- *   rankings: Array<{judge: string, order: Array<string|string[]>}>,
- *   adjudications: Array<{findingId: string, judge: string, verdict: string}>,
- *   tierCounts: object}} args
- *   `rankings` and `adjudications` may both be empty — an all-clean bench (LC-10)
- *   has nothing to adjudicate, and a Stage 2 whose judges all died has nothing to
- *   rank. Each empty section says WHICH of those it is rather than rendering blank.
- */
-function buildChairPacket({ reviews, rankings, adjudications, tierCounts, date }) {
-  const reviewBlocks = reviews.map(r => `--- Review by ${r.model} ---\n${r.text}`).join('\n\n');
-  const rankingLines = (rankings || [])
-    .map(r => `${r.judge}: ${JSON.stringify(r.order)}`)
-    .join('\n');
-  const adjLines = (adjudications || [])
-    .map(a => `${a.findingId} — ${a.judge}: ${a.verdict}`)
-    .join('\n');
-  // Every finding lands in exactly one tier (tally.js countTiers), so the tier
-  // counts sum to the record's finding count — which is how an all-clean bench is
-  // told apart from a bench whose judges simply never voted.
-  const raisedCount = Object.values(tierCounts || {})
-    .reduce((s, n) => s + (typeof n === 'number' ? n : 0), 0);
-  const tiers = JSON.stringify(tierCounts);
-  const parts = [CHAIR_NO_TOOLS_PREAMBLE];
-  if (date) { parts.push(dateLine(date)); }
-  parts.push(raisedCount === 0 ? CHAIR_TASK_NO_FINDINGS : CHAIR_TASK);
-  parts.push(
-    `Deterministic tier counts (peers-only cascade): ${tiers}`,
-    '--- STAGE-1 REVIEWS (de-anonymized) ---',
-    reviewBlocks,
-    '--- PEER RANKINGS (judge: order, best first) ---',
-    orNone(rankingLines, '(none — no judge produced a usable ranking)'),
-    '--- PER-FINDING ADJUDICATIONS ---',
-    orNone(adjLines, raisedCount === 0
-      ? '(none — the bench raised no findings, so there was nothing to adjudicate)'
-      : '(none — no judge produced a usable adjudication)'),
-    VERDICT_SCALE_ADDENDUM,
-  );
-  return parts.join('\n\n');
-}
-
-/**
- * One-shot chair repair: the VERDICT line was missing (spec §5 chair contract).
- *
- * ⚠️ LC-12: this builder took NO arguments at all, so the repair solo — a fresh
- * session — was asked for a verdict on a synthesis it could not see. The chair's
- * synthesis WAS received; it is the verdict line that is missing. Handing back the
- * synthesis lets the chair pick the verdict its own prose supports instead of
- * re-deriving one from nothing.
- * @param {{synthesis?: string}} [args]
- */
-function buildChairRepairPrompt({ synthesis } = {}) {
-  const text = typeof synthesis === 'string' ? synthesis.trim() : '';
-  const prior = text
-    ? ['--- YOUR SYNTHESIS (verbatim — verdict on THIS) ---', text,
-      '--- END OF YOUR SYNTHESIS ---'].join('\n')
-    : null;
-  return [
-    'Do NOT use any tools or read any files; everything is in this message; begin '
-    + 'immediately with the VERDICT line.',
-    ...(prior ? [prior] : []),
-    'Your synthesis was received, but the final parseable line was missing. Emit ONLY '
-    + 'one line, exactly one of:',
-    'VERDICT: Ship it',
-    'VERDICT: Fix these first',
-    'VERDICT: Fundamental rethink',
-  ].join('\n\n');
-}
-
 module.exports = {
-  JUDGE_NO_TOOLS_PREAMBLE, CHAIR_NO_TOOLS_PREAMBLE, CHAIR_VERDICT_VALUES,
-  JUDGE_OUTPUT_CONTRACT, VERDICT_SCALE_ADDENDUM, dateLine,
+  JUDGE_NO_TOOLS_PREAMBLE, CHAIR_NO_TOOLS_PREAMBLE: chair.CHAIR_NO_TOOLS_PREAMBLE,
+  CHAIR_VERDICT_VALUES: chair.CHAIR_VERDICT_VALUES,
+  JUDGE_OUTPUT_CONTRACT, VERDICT_SCALE_ADDENDUM: chair.VERDICT_SCALE_ADDENDUM, dateLine,
   JUDGE_TASK_B, JUDGE_TASK_B_NO_FINDINGS, NO_FINDINGS_INDEX,
-  CHAIR_TASK, CHAIR_TASK_NO_FINDINGS,
-  buildJudgeBundle, buildJudgeRepairPrompt, buildChairPacket, buildChairRepairPrompt,
+  CHAIR_TASK: chair.CHAIR_TASK, CHAIR_TASK_NO_FINDINGS: chair.CHAIR_TASK_NO_FINDINGS,
+  buildJudgeBundle, buildJudgeRepairPrompt,
+  buildChairPacket: chair.buildChairPacket, buildChairRepairPrompt: chair.buildChairRepairPrompt,
 };

package/src/council/debate.js

@@ -11,7 +11,17 @@
  * Also holds the pure pre-debate helpers (target selection, dispute detection, re-vote bundling) moved from run-debate.js (v4.7 PR0).
  */
 
-const PAST_TENSE = { defend: 'defended', amend: 'amended', withdraw: 'withdrawn', 'no-response': 'no-response' };
+const { peersOf, unattributedPeerDrops } = require('./peer-split');
+
+// __proto__: null — an inherited/unknown action (e.g. "toString") must fall
+// through the `|| 'no-response'` guards below and in run-debate.js, never
+// resolve off Object.prototype: a function value there survives in memory
+// but JSON.stringify drops it, silently deleting `action` from the finding.
+// Defense-in-depth: `parse-stage2.js :: parseDebateDefense` is an
+// allowlist that normalises every foreign action to `'no-response'`
+// before this table is consulted — no real run reaches it with a
+// foreign key. See `run-debate.test.js :: DOUBLEBREACH`.
+const PAST_TENSE = { __proto__: null, defend: 'defended', amend: 'amended', withdraw: 'withdrawn', 'no-response': 'no-response' };
 
 // The debate-role vocabulary: a debate leg is an extra leg by an already-benched model,
 // never an extra ledger row and never that model's ledger identity. Through v4.6 this Set
@@ -23,12 +33,44 @@ const DEBATE_ROLES = new Set(['rebuttal', 'revote']);
 
 /**
  * Reassemble the tally input after the debate round.
- * @param {{tallyInput: object, provisionalRecord: object|null,
+ *
+ * v4.8 PR3 Task 6 (spec §4.5): `defenseByRaiser` and `revoteByJudge` are keyed
+ * on the SEAT (`seat.id`), which equals the alias for every bench without a
+ * repeated entry. `aliasOf` is the ONE seat→alias projection run-debate.js
+ * builds from `o.seats`; it is the identity for any key that is not a known
+ * seat id, so a direct-require caller with no seats and the reserved 'claude'
+ * key both behave exactly as before.
+ *
+ * ⚠️ SI-13: when `aliasOf` is omitted, the fail-open push below uses the raw
+ * key unchanged (`alias = key`), leaving the SEAT id in the alias-space
+ * `judge` field instead of projecting it to its alias. `judge` must stay
+ * alias-space: via `peer-split.js :: peersOf`'s `v.judge !== f.raiser`, a
+ * seat id there can silently retier a finding. `report.js :: toModel` never
+ * retiers — it copies `f.tier`, never recomputes it — but the same seat id
+ * still reaches its `columnFor` join as an out-of-contract `judge`.
+ * `applyDebate` has no seat roster of its own, so building that projection
+ * stays the caller's obligation.
+ *
+ * The gap needs a caller that both omits `aliasOf` and hits a repeated alias,
+ * and none exists today: the sole non-test caller, `run-debate.js`, always
+ * supplies `aliasOf` (see the warning comment at its call site), and
+ * `package.json`'s `exports` map publishes only `./opencode-client`, blocking
+ * a deep import of `amicus/src/council/debate` from outside this package.
+ *
+ * ⚠️ This block used to declare a `provisionalRecord` param the destructure has
+ * never taken (pre-existing doc rot). Callers still pass one and it is still
+ * ignored — the DOC is what was wrong, so only the doc was fixed. Deliberately
+ * not wired up: applyDebate reads `previousTier` off `tallyInput.findings[]`,
+ * which run-debate.js stamps, and a second source of that fact is how it
+ * silently read null before.
+ *
+ * @param {{tallyInput: object,
  *   defenseByRaiser: Object<string, Object<string, object>>,
- *   revoteByJudge: Object<string, Object<string, {verdict, reason?}>>}} args
+ *   revoteByJudge: Object<string, Object<string, {verdict, reason?}>>,
+ *   aliasOf?: function(string): string}} args
  * @returns {{input: object, debateFindings: Array}}
  */
-function applyDebate({ tallyInput, defenseByRaiser, revoteByJudge }) {
+function applyDebate({ tallyInput, defenseByRaiser, revoteByJudge, aliasOf }) {
   // Deep-ish clone the mutable arrays we touch (findings + adjudications).
   const findings = tallyInput.findings.map(f => ({ ...f }));
   const adjudications = tallyInput.adjudications.map(a => ({ ...a }));
@@ -54,12 +96,29 @@ function applyDebate({ tallyInput, defenseByRaiser, revoteByJudge }) {
     delete f.previousTier; // provisional-only scratch field, never written to tally input
   }
 
-  // Re-vote replacement: replace the wave judge's entry on each bundled id.
-  for (const [judge, perId] of Object.entries(revoteByJudge || {})) {
+  // Re-vote replacement: replace the wave SEAT's entry on each bundled id.
+  // `(a.seat || a.judge)` is the seat-space read every consumer uses — `seat` is
+  // emit-when-different (Task 5), so a bench with no repeated alias reduces this
+  // to today's `a.judge === key` exactly. Matching on the alias instead is D5:
+  // two twins share one `judge` value, so the first row wins and the second
+  // twin's re-vote is silently dropped.
+  for (const [key, perId] of Object.entries(revoteByJudge || {})) {
     for (const [id, rv] of Object.entries(perId)) {
-      const entry = adjudications.find(a => a.findingId === id && a.judge === judge);
+      const entry = adjudications.find(a => a.findingId === id && (a.seat || a.judge) === key);
       if (entry) { entry.verdict = rv.verdict; }
-      else { adjudications.push({ findingId: id, judge, verdict: rv.verdict }); }
+      else {
+        // Fail-open push (a stateless leg re-voting an id it never adjudicated).
+        // `judge` MUST stay alias-space: via peer-split.js :: peersOf's
+        // `v.judge !== f.raiser`, a seat id there can silently retier a
+        // finding. report.js :: toModel never retiers — it copies `f.tier`,
+        // never recomputes it — but the same seat id still reaches its
+        // `columnFor` join as an out-of-contract `judge`.
+        // The seat rides beside it, emitted only when it differs — so a unique
+        // bench pushes today's exact row.
+        const alias = aliasOf ? aliasOf(key) : key;
+        adjudications.push({ findingId: id, judge: alias, verdict: rv.verdict,
+          ...(alias !== key ? { seat: key } : {}) });
+      }
     }
   }
 
@@ -88,7 +147,10 @@ function decorateRecord(record, debateFindings) {
  * 'superseded' for an original leg a successful repair replaced, and 'repair' for
  * a repair attempt that itself never became usable (error status rides naturally
  * off the raw leg). The rebuttal/revote legs never enter meta.models, so the
- * ledger stays one row per (run×model). DEBATE_ROLES remains the debate-role
+ * ledger stays one row per (run × model × resolvedModel) pair — a debate round
+ * can never ADD a row (v4.8 PR4b: meta.models is still the row driver, and the
+ * pair fan-out only splits an alias whose own joinable rows resolved
+ * differently). DEBATE_ROLES remains the debate-role
  * vocabulary (rebuttal/revote); the ledger's overwrite protection for ALL FOUR
  * of these row-per-launch roles — rebuttal, revote, superseded AND repair —
  * lives in ledger.js's own LEDGER_JOIN_ROLES allowlist (v4.7 D4, Task 7):
@@ -129,20 +191,52 @@ function nothingToDebate(provisionalRecord) {
   return n === 0;
 }
 
-/** Judges whose provisional adjudications dispute at least one bundled id. */
+/**
+ * Seats whose provisional adjudications dispute at least one bundled id.
+ * v4.8 PR3 Task 6: returns SEAT ids and dedups by seat (D6) — deduping by alias
+ * collapses two disputing bench positions into one re-vote leg, so the twin that
+ * never re-voted keeps a verdict the round meant to replace. run-debate.js
+ * projects these back to aliases for the launcher.
+ */
 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); }
+      if (adj.verdict === 'dispute') { judges.add(adj.seat || adj.judge); }
     }
   }
   return [...judges];
 }
 
-/** Group Contested+Disputed findings by raiser (defense targets). */
+/**
+ * Group Contested+Disputed findings by raiser SEAT (defense targets).
+ * v4.8 PR3 Task 6: keyed on `f.raiserSeat || f.raiser`. Claude's findings carry
+ * no `raiserSeat`, so its key stays the literal 'claude' and run-debate.js's
+ * `.filter(m => m !== 'claude')` / `byRaiser.claude` keep working unchanged.
+ * v4.8 Phase 2 T-B2: `peerVerdicts` below CALLS peer-split.js :: peersOf —
+ * the one predicate tally.js also calls — so the defense brief's peer split and
+ * the tally the chair reads agree by construction rather than by two spellings
+ * kept in step by hand. Until T-B2 this file spelled its own copy with TWO
+ * branches while `peersOf` had THREE: the outer `f.raiser ? … : …` arm was
+ * missing here, so a finding whose raiser is falsy ('' from the MCP path,
+ * `undefined` from the CLI path) was briefed a peer split the tally never
+ * computed. `unattributedPeerDrops` rides beside it under the same emit rule as
+ * tally.js's, so the two documents also carry the same mark.
+ * v4.8 T-B4 then changed what that branch COMPUTES — a falsy raiser no longer
+ * corroborates itself, and the seat compare was lifted ABOVE the raiser test so
+ * the seats decide first whatever `f.raiser` says (P0). Because both documents
+ * read the one function, the brief moved with the tally at no cost here. Two
+ * consequences are visible from this file: the briefed peer split of a
+ * falsy-raiser finding changes, and some such findings no longer reach a brief
+ * at all, because dropping their unattributable votes moves them off
+ * Contested/Disputed and `debateTargets` skips every other tier.
+ * debate.js :: applyDebate reads `(a.seat || a.judge)` and
+ * debate.js :: disputingJudges reads `adj.seat || adj.judge` — both already
+ * seat-space, both read at T-B2 — so this was the last hand-rolled peer filter
+ * left in this file.
+ */
 function debateTargets(provisionalRecord, tallyInput) {
   const claimById = new Map(tallyInput.findings.map(f => [f.id, f]));
   const byRaiser = {};
@@ -151,9 +245,20 @@ function debateTargets(provisionalRecord, tallyInput) {
     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: [] });
+    // ⚠️ The trailing `.map(a => a.verdict)` is load-bearing: briefings-debate's
+    // verdictCounts indexes its counter BY THE ELEMENT, so a list of
+    // adjudication OBJECTS renders "0 dispute, 0 agree, 0 neutral" — a silent
+    // all-zero byte-identical to the no-data case, i.e. a paid brief telling the
+    // model nobody disputed it.
+    const adjs = f.adjudications || [];
+    const peerVerdicts = peersOf(f, adjs).map(a => a.verdict);
+    // Emitted only when > 0, exactly as tally.js emits it, so a run that does
+    // not orphan one side of a twin pair produces a byte-identical row.
+    const drops = unattributedPeerDrops(f, adjs);
+    const raiserKey = f.raiserSeat || f.raiser;
+    (byRaiser[raiserKey] = byRaiser[raiserKey] || []).push({ id: f.id, claim: src.claim,
+      severity: f.severity, location: src.location, peerVerdicts,
+      ...(drops > 0 ? { unattributedPeerDrops: drops } : {}), disputeReasons: [] });
   }
   return { byRaiser, previousTier };
 }