amicus 4.0.1 → 4.1.0

package/src/cli-handlers-council-run.js

@@ -148,6 +148,15 @@ async function handleCouncilRun(args) {
     gateway: resolveGatewayMode(args.gateway),
     noValidateModel: !!args['no-validate-model'],
     date: new Date().toISOString().slice(0, 10),
+    // v4.1 §4.5b/§4.5d. `--claude-review` is resolved here but VALIDATED by the
+    // engine's preflightClaudeReview (run-assemble.js): the reserved-seat and
+    // 'claude may not chair' guards live there on purpose so MCP, the GitHub
+    // Action and direct `require('./council/run')` callers hit the same rule and
+    // the same COUNCIL_CLAUDE_REVIEW_INVALID code. Re-checking them here would
+    // give the identical mistake two different error codes by entry point.
+    debate: !!args.debate,
+    claudeReviewFile: args['claude-review'] ? path.resolve(args['claude-review']) : null,
+    noCostGate: !!args['no-cost-gate'],
   });
 
   if (useJson) {

package/src/cli-handlers-council.js

@@ -1,13 +1,14 @@
 // src/cli-handlers-council.js
 'use strict';
 const fs = require('fs');
+const path = require('path');
 const { tally } = require('./council/tally');
 const { deriveReliability, appendRun, buildStatsDoc } = require('./council/ledger');
 const { sumWaveUsage, formatCost } = require('./utils/pricing');
 const { failJson, ERROR_CODES } = require('./utils/error-doc');
 const { buildReport } = require('./council/report');
 const { validateFindings, buildValidateDoc } = require('./council/findings');
-const { buildVerdict, writeVerdictAtomic } = require('./council/verdict');
+const { buildVerdict, readOverallVerdict, writeVerdictAtomic } = require('./council/verdict');
 const {
   runSave: runCouncilSave,
   runList: runCouncilList,
@@ -163,12 +164,29 @@ function runVerdict(args, useJson) {
   }
   const outPath = args.out || './verdict.json';
   let verdict;
-  try { verdict = buildVerdict(record, decisions); }
+  try {
+    // The Stage-5 replacement overwrites the engine's verdict.json, which is
+    // one of only two homes of the chair's synthesis (the other is
+    // chair-output.md); tally.json carries no copy. Recover it from the RUN
+    // folder — the tally's own directory, not `-o` — before rebuilding.
+    const overallVerdict = readOverallVerdict(path.dirname(path.resolve(tallyPath)), record.meta.runId);
+    verdict = buildVerdict(record, decisions, { overallVerdict });
+  }
   catch (e) {
     return failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: `cannot build verdict: ${e.message}`,
       hint: 'either tally.json needs meta, findings[], streetCred[], runStats, tierCounts, or decisions.json must be a JSON array of {id, decision, …} objects' });
   }
   writeVerdictAtomic(outPath, verdict);
+  if (args.render) {
+    // v4.1 §4.5c: refresh report.html next to the decided verdict.
+    try {
+      const html = buildReport({ verdict }, { format: 'html' });
+      fs.writeFileSync(path.join(path.dirname(outPath), 'report.html'), html);
+    } catch (e) {
+      return failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: `verdict written but render failed: ${e.message}`,
+        hint: 'the verdict.json is valid; re-run `amicus council report <verdict.json> --html` manually' });
+    }
+  }
   process.stdout.write(useJson ? JSON.stringify(verdict, null, 2) + '\n' : renderVerdict(verdict, outPath));
   return 0;
 }

package/src/cli.js

@@ -134,11 +134,13 @@ function isBooleanFlag(key) {
      'no-validate-model',
      'remove',               // used by 'key' command only; other handlers ignore it
      'no-cost-gate',         // disable the budget gate for this run
+     'debate',               // council run: enable the Stage-2.5 rebuttal round
      'no-ledger',            // council tally: compute the record without appending to the reliability ledger
      'html',                 // council report: emit a self-contained HTML page
      'md',                   // council report: emit Markdown (default)
      'fix',                  // doctor: self-heal fixable checks in place (#56)
      'strict',               // models --check: exit non-zero on curated per-gateway drift (#gwid Task 6)
+     'render',               // council verdict: also refresh report.html next to the decided verdict
    ];
   return booleanFlags.includes(key);
 }
@@ -508,13 +510,19 @@ Subcommands for 'council':
     --decisions <d.json>       Optional. Stage-4 decisions array (default [])
     -o, --out <out.json>       Output path (default ./verdict.json)
     --json                     Print the full verdict document
+    --render                   Also refresh report.html next to the decided verdict
   run --prompt-file <briefing.md> (--models a,b,c | --council <name>)
       [--chair <model>] [--critic <model>] [--lenses s1,s2,...]
       [--out-dir <dir>] [--json] [--max-cost <usd>] [--timeout <min>]
       [--gateway auto|direct|openrouter] [--no-validate-model]
+      [--debate] [--claude-review <file>] [--no-cost-gate]
                                 Run the full headless council engine (v4.0).
                                 Chair default: deepseek (must NOT be a bench seat).
                                 --critic and --lenses are mutually exclusive.
+                                --debate adds a Stage-2.5 rebuttal round.
+                                --claude-review <file> enters Claude's own review as
+                                a judged entry; --no-cost-gate disables the per-leg
+                                price gate for the whole run (repairs + chair).
                                 Exit: 0 full run, 2 degraded, 1 quorum/cost/validation.
   save <name> --models a,b,c    Save a named council preset (>=2 resolvable members)
     --json                     Machine-readable output

package/src/council/briefings-debate.js

@@ -0,0 +1,158 @@
+// src/council/briefings-debate.js
+'use strict';
+
+/**
+ * @module council/briefings-debate
+ * Pure Stage-2.5 (debate) template builders for the headless council engine
+ * (spec §5.3). Adapted from skills/second-opinion/SEAT-BRIEFS.md § Rebuttal-round
+ * templates, hardened from the line-based contract to the v4.0 Stage-2
+ * trailing-JSON style (prose first, one fenced ```json block last, nothing
+ * after it). Every brief opens with the no-tools preamble and the date stamp
+ * (spec §4.3). No IO, no model calls.
+ */
+
+const { dateLine } = require('./briefings-stage2');
+
+const DEBATE_NO_TOOLS_PREAMBLE =
+  'Do NOT use any tools or read any files; everything is in this message; ' +
+  'begin immediately with the JSON block.';
+
+/** Defense trailing-JSON contract (spec §5.3a). */
+const DEFENSE_CONTRACT = [
+  'End your response with a fenced ```json block, with no text after it:',
+  '',
+  '```json',
+  '{',
+  '  "responses": [',
+  '    { "id": "A1", "action": "defend", "argument": "<strongest evidence-based defense, one paragraph max>" },',
+  '    { "id": "A3", "action": "amend", "claim": "<full corrected replacement claim>", "argument": "<why, one sentence>" },',
+  '    { "id": "B2", "action": "withdraw" }',
+  '  ]',
+  '}',
+  '```',
+  '',
+  'Every listed finding id must appear exactly once. `defend` requires `argument`; ' +
+  '`amend` requires `claim`; `withdraw` requires neither.',
+].join('\n');
+
+/** Re-vote trailing-JSON contract (spec §5.3b). */
+const REVOTE_CONTRACT = [
+  'End your response with a fenced ```json block, with no text after it:',
+  '',
+  '```json',
+  '{',
+  '  "revotes": [',
+  '    { "id": "A1", "verdict": "agree", "reason": "<one line>" },',
+  '    { "id": "A3", "verdict": "dispute", "reason": "<one line>" }',
+  '  ]',
+  '}',
+  '```',
+  '',
+  '`verdict` is one of agree | dispute | neutral. Every listed finding id must ' +
+  'appear exactly once.',
+].join('\n');
+
+/** Count the anonymized peer verdicts carried on a finding. */
+function verdictCounts(list) {
+  const c = { dispute: 0, agree: 0, neutral: 0 };
+  for (const v of list || []) { if (c[v] !== undefined) { c[v] += 1; } }
+  return c;
+}
+
+function findingBlockDefense(f) {
+  const c = verdictCounts(f.peerVerdicts);
+  const reasons = (f.disputeReasons || []).filter(Boolean);
+  const loc = f.location ? ` @ ${f.location}` : '';
+  // Stage-2's adjudication JSON has no `reason` field, so written reasons are usually
+  // absent. Report the REAL anonymized peer split instead of inventing a reason string.
+  const why = reasons.length
+    ? `  Peers disputed it for:\n${reasons.map(r => `    - ${r}`).join('\n')}`
+    : '  No written dispute reasons were captured.';
+  return `- ${f.id} [${f.severity}]${loc}: ${f.claim}\n`
+    + `  Peer verdicts (anonymized): ${c.dispute} dispute, ${c.agree} agree, ${c.neutral} neutral.\n`
+    + why;
+}
+
+function findingBlockRevote(f) {
+  const mark = f.amended ? ' **AMENDED**' : '';
+  return `- ${f.id} [${f.severity}]${mark}: ${f.claim}\n  Raiser's response: ${f.argument}`;
+}
+
+/** One defense solo per raiser (spec §5.3a). */
+function buildDefenseBrief({ findings, date }) {
+  const parts = [DEBATE_NO_TOOLS_PREAMBLE];
+  if (date) { parts.push(dateLine(date)); }
+  parts.push(
+    'You reviewed an artifact and raised the findings below. Peer reviewers ' +
+    '(anonymous) disputed them for the stated reasons. For EACH finding decide: ' +
+    'DEFEND it with evidence, AMEND it with corrected replacement text, or WITHDRAW ' +
+    'it. Withdraw anything you cannot defend with evidence — an unsupported repeat ' +
+    'of the original claim is weaker than a withdrawal.',
+    findings.map(findingBlockDefense).join('\n\n'),
+    DEFENSE_CONTRACT,
+  );
+  return parts.join('\n\n');
+}
+
+/** One shared re-vote bundle, fanned out to disputing judges (spec §5.3b). */
+function buildRevoteBundle({ findings, date }) {
+  const parts = [DEBATE_NO_TOOLS_PREAMBLE];
+  if (date) { parts.push(dateLine(date)); }
+  parts.push(
+    'You previously adjudicated findings on this artifact and disputed at least ' +
+    'one of those below. The (anonymous) raiser has now responded. Re-adjudicate ' +
+    'ONLY the findings listed, in light of each response. Changing your verdict ' +
+    'when the defense is convincing is good judging, not weakness; so is holding ' +
+    'your dispute when it isn\'t.',
+    findings.map(findingBlockRevote).join('\n\n'),
+    REVOTE_CONTRACT,
+  );
+  return parts.join('\n\n');
+}
+
+function repair(kind, contract, errors) {
+  const lines = (errors || []).map(e => `- ${e.code}: ${e.detail}`).join('\n');
+  return [
+    'Do NOT use any tools or read any files; everything is in this message; begin ' +
+    'immediately with the JSON block.',
+    `Your previous ${kind} response's trailing JSON failed validation with these errors:`,
+    lines,
+    'Re-emit ONLY the corrected JSON block as a single fenced ```json block:',
+    contract,
+  ].join('\n\n');
+}
+
+function buildDefenseRepairPrompt({ errors }) { return repair('defense', DEFENSE_CONTRACT, errors); }
+function buildRevoteRepairPrompt({ errors }) { return repair('re-vote', REVOTE_CONTRACT, errors); }
+
+/**
+ * Chair-packet "Debate round outcomes" section (spec §5.3c). De-anonymized —
+ * built by run.js from debate.json + both tally records. `priorVerdicts` is the
+ * finding's ACTUAL Stage-2 adjudication map from the provisional tally record and
+ * `revotes` the map of judges who re-voted; `before` is derived here so no caller
+ * can assume it. A re-vote recipient qualified by disputing SOME bundled finding,
+ * so its prior verdict on THIS finding is often 'agree' or 'neutral'.
+ * @param {{outcomes: Array<{id, originalClaim, action, amendedClaim,
+ *   priorVerdicts: Object<string,string>, revotes: Object<string,string>}>}} args
+ */
+function buildDebateAddendum({ outcomes }) {
+  const blocks = outcomes.map(o => {
+    const head = `- ${o.id}: "${o.originalClaim}" → ${o.action}`;
+    const amended = o.action === 'amended' && o.amendedClaim ? `\n  Amended claim: "${o.amendedClaim}"` : '';
+    const prior = o.priorVerdicts || {};
+    const revotes = o.revotes || {};
+    const judges = Object.keys(revotes);
+    const changes = judges.length
+      ? '\n  Re-vote changes: ' + judges.map(
+        j => `${j}: ${prior[j] || 'no prior verdict'} → ${revotes[j]}`).join('; ')
+      : '\n  Re-vote changes: none';
+    return head + amended + changes;
+  }).join('\n');
+  return ['--- Debate round outcomes ---', blocks].join('\n\n');
+}
+
+module.exports = {
+  DEBATE_NO_TOOLS_PREAMBLE, DEFENSE_CONTRACT, REVOTE_CONTRACT,
+  buildDefenseBrief, buildRevoteBundle,
+  buildDefenseRepairPrompt, buildRevoteRepairPrompt, buildDebateAddendum,
+};

package/src/council/briefings-stage2.js

@@ -19,6 +19,9 @@ const CHAIR_NO_TOOLS_PREAMBLE =
 
 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). */
 const JUDGE_OUTPUT_CONTRACT = [
   'End your response with a trailing fenced ```json block — no text after it — in',
@@ -45,13 +48,14 @@ const JUDGE_OUTPUT_CONTRACT = [
  * @param {{reviews: Array<{label: string, text: string}>,
  *   findings: Array<{id: string, severity: string, claim: string}>}} args
  */
-function buildJudgeBundle({ reviews, findings }) {
+function buildJudgeBundle({ reviews, findings, date }) {
   const findingLines = findings.map(f => `${f.id} [${f.severity}] ${f.claim}`).join('\n');
   const reviewBlocks = reviews
     .map(r => `--- ${r.label} ---\n${r.text}`)
     .join('\n\n');
-  return [
-    JUDGE_NO_TOOLS_PREAMBLE,
+  const parts = [JUDGE_NO_TOOLS_PREAMBLE];
+  if (date) { parts.push(dateLine(date)); }
+  parts.push(
     'You are judging the anonymized peer reviews below. Do two things:',
     'Task A — Rank: order the reviews from most to least accurate and insightful.',
     'Task B — Adjudicate: for EVERY finding id listed below, state agree, dispute, or ' +
@@ -60,7 +64,8 @@ function buildJudgeBundle({ reviews, findings }) {
     '--- FINDINGS INDEX (run-global ids) ---',
     findingLines,
     reviewBlocks,
-  ].join('\n\n');
+  );
+  return parts.join('\n\n');
 }
 
 /** Bounded judge-repair re-prompt (solo; ≤ 2 per judge — spec §5). */
@@ -103,7 +108,7 @@ const VERDICT_SCALE_ADDENDUM = [
  *   adjudications: Array<{findingId: string, judge: string, verdict: string}>,
  *   tierCounts: object}} args
  */
-function buildChairPacket({ reviews, rankings, adjudications, tierCounts }) {
+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)}`)
@@ -112,8 +117,9 @@ function buildChairPacket({ reviews, rankings, adjudications, tierCounts }) {
     .map(a => `${a.findingId} — ${a.judge}: ${a.verdict}`)
     .join('\n');
   const tiers = JSON.stringify(tierCounts);
-  return [
-    CHAIR_NO_TOOLS_PREAMBLE,
+  const parts = [CHAIR_NO_TOOLS_PREAMBLE];
+  if (date) { parts.push(dateLine(date)); }
+  parts.push(
     '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 ' +
@@ -127,7 +133,8 @@ function buildChairPacket({ reviews, rankings, adjudications, tierCounts }) {
     '--- PER-FINDING ADJUDICATIONS ---',
     adjLines,
     VERDICT_SCALE_ADDENDUM,
-  ].join('\n\n');
+  );
+  return parts.join('\n\n');
 }
 
 /** One-shot chair repair: the VERDICT line was missing (spec §5 chair contract). */
@@ -145,6 +152,6 @@ function buildChairRepairPrompt() {
 
 module.exports = {
   JUDGE_NO_TOOLS_PREAMBLE, CHAIR_NO_TOOLS_PREAMBLE, CHAIR_VERDICT_VALUES,
-  JUDGE_OUTPUT_CONTRACT, VERDICT_SCALE_ADDENDUM,
+  JUDGE_OUTPUT_CONTRACT, VERDICT_SCALE_ADDENDUM, dateLine,
   buildJudgeBundle, buildJudgeRepairPrompt, buildChairPacket, buildChairRepairPrompt,
 };

package/src/council/debate.js

@@ -0,0 +1,98 @@
+// src/council/debate.js
+'use strict';
+
+/**
+ * @module council/debate
+ * PURE final-tally reassembly for headless debate mode (spec §5.5). DI-free —
+ * takes the provisional tally input + parsed defense/re-vote maps and returns a
+ * new tally input plus the debate.json findings rows. run.js then re-runs
+ * tally() on the returned input and decorates the record. Keeps run.js under the
+ * line gate.
+ */
+
+const PAST_TENSE = { defend: 'defended', amend: 'amended', withdraw: 'withdrawn', 'no-response': 'no-response' };
+
+// runStats roles the ledger join must skip (ledger.js): a debate leg is an extra leg by an
+// already-benched model, never an extra ledger row and never that model's ledger identity.
+const DEBATE_ROLES = new Set(['rebuttal', 'revote']);
+
+/**
+ * Reassemble the tally input after the debate round.
+ * @param {{tallyInput: object, provisionalRecord: object|null,
+ *   defenseByRaiser: Object<string, Object<string, object>>,
+ *   revoteByJudge: Object<string, Object<string, {verdict, reason?}>>}} args
+ * @returns {{input: object, debateFindings: Array}}
+ */
+function applyDebate({ tallyInput, defenseByRaiser, revoteByJudge }) {
+  // Deep-ish clone the mutable arrays we touch (findings + adjudications).
+  const findings = tallyInput.findings.map(f => ({ ...f }));
+  const adjudications = tallyInput.adjudications.map(a => ({ ...a }));
+
+  // Flatten the per-raiser defense map to a per-id lookup + debate.json rows.
+  const byId = {};
+  const debateFindings = [];
+  for (const [raiser, perId] of Object.entries(defenseByRaiser || {})) {
+    for (const [id, resp] of Object.entries(perId)) {
+      byId[id] = resp;
+      const src = findings.find(f => f.id === id) || {};
+      const row = { id, raiser, action: resp.action, previousTier: src.previousTier || null };
+      if (resp.argument) { row.argument = resp.argument; }
+      if (resp.claim) { row.claim = resp.claim; }
+      debateFindings.push(row);
+    }
+  }
+
+  // Amend: swap claim text in place. Withdraw/defend/no-response: findings[] unchanged.
+  for (const f of findings) {
+    const resp = byId[f.id];
+    if (resp && resp.action === 'amend' && typeof resp.claim === 'string') { f.claim = resp.claim; }
+    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 || {})) {
+    for (const [id, rv] of Object.entries(perId)) {
+      const entry = adjudications.find(a => a.findingId === id && a.judge === judge);
+      if (entry) { entry.verdict = rv.verdict; }
+      else { adjudications.push({ findingId: id, judge, verdict: rv.verdict }); }
+    }
+  }
+
+  return { input: { ...tallyInput, findings, adjudications }, debateFindings };
+}
+
+/**
+ * Inject the additive past-tense debate decoration onto the tally record's
+ * findings (spec §5.6). Mutates + returns the record.
+ * @param {object} record tally() output
+ * @param {Array<{id, action, previousTier}>} debateFindings
+ * @returns {object} record
+ */
+function decorateRecord(record, debateFindings) {
+  const byId = new Map((debateFindings || []).map(d => [d.id, d]));
+  for (const f of record.findings) {
+    const d = byId.get(f.id);
+    if (d) { f.debate = { action: PAST_TENSE[d.action] || 'no-response', previousTier: d.previousTier }; }
+  }
+  return record;
+}
+
+/**
+ * runStats rows for the debate legs (spec §5.5). role is 'rebuttal' | 'revote';
+ * these legs never enter meta.models, so the ledger stays one row per (run×model),
+ * and ledger.js skips DEBATE_ROLES when joining runStats so a debate leg cannot
+ * overwrite the bench row's role/wasChair/conformance on that model's ledger row.
+ * @param {{defenseLegs: Array, revoteLegs: Array}} args leg metadata
+ * @returns {Array<object>}
+ */
+function debateRunStatsRows({ defenseLegs, revoteLegs }) {
+  const mk = (role) => (l) => ({
+    model: l.model, role, wasChair: false, conformance: l.conformance || 'clean',
+    status: l.status || 'unknown',
+    durationMs: typeof l.durationMs === 'number' ? l.durationMs : null,
+    usage: l.usage || null,
+  });
+  return [...(defenseLegs || []).map(mk('rebuttal')), ...(revoteLegs || []).map(mk('revote'))];
+}
+
+module.exports = { applyDebate, decorateRecord, debateRunStatsRows, PAST_TENSE, DEBATE_ROLES };

package/src/council/ledger.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const { getConfigDir } = require('../utils/config');
+const { DEBATE_ROLES } = require('./debate');
 
 const LEDGER_SCHEMA_VERSION = 1;
 const LEDGER_FILE = 'council-ledger.jsonl';
@@ -17,7 +18,7 @@ function countSeverity(findings) {
 function buildLedgerRows(record) {
   const { meta, findings, streetCred, runStats, judged } = record;
   const sc = new Map(streetCred.map(s => [s.model, s]));
-  const rs = new Map(runStats.map(r => [r.model, r]));
+  const rs = new Map(runStats.filter(r => !DEBATE_ROLES.has(r.role)).map(r => [r.model, r]));
   return meta.models.map(model => {
     const raised = findings.filter(f => f.raiser === model);
     const s = sc.get(model) || {};

package/src/council/parse-stage2.js

@@ -100,4 +100,86 @@ function parseChairVerdict(text) {
   return found;
 }
 
-module.exports = { parseJudgeOutput, parseChairVerdict, CHAIR_VERDICTS, JUDGE_VERDICTS };
+const DEBATE_ACTIONS = ['defend', 'amend', 'withdraw'];
+const REVOTE_VERDICTS = ['agree', 'dispute', 'neutral'];
+
+/**
+ * Parse a debate defense solo (spec §5.4). Every expected id ends up in byId:
+ * a present-and-valid entry keeps its action/argument/claim; anything absent or
+ * individually invalid becomes {action:'no-response'} (the spec-mandated
+ * "original stands" fallback). A block-level failure sets ok:false so the
+ * caller issues exactly ONE repair; after that, every id is 'no-response'.
+ * @param {string} text raw defense output (prose + trailing ```json block)
+ * @param {string[]} expectedIds run-global ids sent to this raiser
+ * @returns {{byId: Object, ok: boolean, errors: Array<{code, detail}>}}
+ */
+function parseDebateDefense(text, expectedIds) {
+  const allNoResponse = () => {
+    const byId = {};
+    for (const id of expectedIds) { byId[id] = { action: 'no-response' }; }
+    return byId;
+  };
+  const body = lastJsonBlock(text || '');
+  if (body === null) {
+    return { byId: allNoResponse(), ok: false, errors: [{ code: 'NO_FENCED_BLOCK', detail: 'no ```json block found' }] };
+  }
+  let parsed;
+  try { parsed = JSON.parse(body); }
+  catch (e) { return { byId: allNoResponse(), ok: false, errors: [{ code: 'NOT_PARSEABLE', detail: e.message }] }; }
+  if (!parsed || !Array.isArray(parsed.responses)) {
+    return { byId: allNoResponse(), ok: false, errors: [{ code: 'BAD_RESPONSES', detail: 'responses must be an array' }] };
+  }
+  const expected = new Set(expectedIds);
+  const byId = allNoResponse();
+  for (const r of parsed.responses) {
+    const id = r && r.id;
+    if (!expected.has(id)) { continue; }                 // unknown id ignored
+    if (r.action === 'defend' && typeof r.argument === 'string' && r.argument.trim()) {
+      byId[id] = { action: 'defend', argument: r.argument };
+    } else if (r.action === 'amend' && typeof r.claim === 'string' && r.claim.trim()) {
+      const entry = { action: 'amend', claim: r.claim };
+      if (typeof r.argument === 'string' && r.argument.trim()) { entry.argument = r.argument; }
+      byId[id] = entry;
+    } else if (r.action === 'withdraw') {
+      byId[id] = { action: 'withdraw' };
+    } // else leave as no-response
+  }
+  return { byId, ok: true, errors: [] };
+}
+
+/**
+ * Parse a re-vote leg (spec §5.4). byId holds ONLY present-and-valid ids; an
+ * absent or invalid entry is omitted so the judge's original verdict stands.
+ * Block-level failure sets ok:false (caller issues one repair, then originals
+ * stand for all bundled ids).
+ * @param {string} text raw re-vote output
+ * @param {string[]} expectedIds bundled run-global ids
+ * @returns {{byId: Object, ok: boolean, errors: Array<{code, detail}>}}
+ */
+function parseRevote(text, expectedIds) {
+  const body = lastJsonBlock(text || '');
+  if (body === null) {
+    return { byId: {}, ok: false, errors: [{ code: 'NO_FENCED_BLOCK', detail: 'no ```json block found' }] };
+  }
+  let parsed;
+  try { parsed = JSON.parse(body); }
+  catch (e) { return { byId: {}, ok: false, errors: [{ code: 'NOT_PARSEABLE', detail: e.message }] }; }
+  if (!parsed || !Array.isArray(parsed.revotes)) {
+    return { byId: {}, ok: false, errors: [{ code: 'BAD_REVOTES', detail: 'revotes must be an array' }] };
+  }
+  const expected = new Set(expectedIds);
+  const byId = {};
+  for (const r of parsed.revotes) {
+    const id = r && r.id;
+    if (!expected.has(id) || !REVOTE_VERDICTS.includes(r.verdict)) { continue; }
+    const entry = { verdict: r.verdict };
+    if (typeof r.reason === 'string' && r.reason.trim()) { entry.reason = r.reason; }
+    byId[id] = entry;
+  }
+  return { byId, ok: true, errors: [] };
+}
+
+module.exports = {
+  parseJudgeOutput, parseChairVerdict, CHAIR_VERDICTS, JUDGE_VERDICTS,
+  parseDebateDefense, parseRevote, DEBATE_ACTIONS, REVOTE_VERDICTS,
+};

package/src/council/report-html.js

@@ -55,6 +55,33 @@ function renderHtml(m) {
   const meta = [h.date, h.chair ? `chair: ${h.chair}` : null, `council: ${h.council.join(', ')}`,
     h.claudeInCouncil ? 'Claude in council' : null].filter(Boolean).map(esc).join(' · ');
 
+  // m.debate is absent on hand-built models (tests/council/report.test.js calls
+  // renderHtml directly with no debate key) — the guard must tolerate that, and
+  // absent/empty ⇒ no section at all so a no-debate report stays byte-identical
+  // to v4.0's HTML output. no-response findings get their own list (same
+  // reasoning as report.js's renderMd) so the heading never dangles over
+  // nothing when a run's only debating raiser never responded.
+  let debateSection = '';
+  if (m.debate && m.debate.present) {
+    const withdrawnItems = (m.debate.withdrawn || []).map((w) => {
+      const arrow = w.previousTier && w.previousTier !== w.tier ? `${esc(w.previousTier)} → ${esc(w.tier)}` : esc(w.previousTier || w.tier);
+      return `<li>${esc(w.id)}: ${arrow} (withdrawn — no longer live)</li>`;
+    }).join('');
+    const movementItems = (m.debate.movements || []).map(mv =>
+      `<li>${esc(mv.id)}: ${esc(mv.previousTier)} → ${esc(mv.tier)} (${esc(mv.action)})</li>`).join('');
+    const noResponseItems = (m.debate.noResponse || []).map((nr) => {
+      const arrow = nr.previousTier && nr.previousTier !== nr.tier ? `${esc(nr.previousTier)} → ${esc(nr.tier)}` : esc(nr.previousTier || nr.tier);
+      return `<li>${esc(nr.id)}: ${arrow} (no response — original stands)</li>`;
+    }).join('');
+    // Defensive: never emit the heading unless at least one grouping has content.
+    if (withdrawnItems || movementItems || noResponseItems) {
+      debateSection = '\n<h2>Debate round</h2>' +
+        (withdrawnItems ? `<p><strong>Withdrawn by raiser:</strong></p><ul>${withdrawnItems}</ul>` : '') +
+        (movementItems ? `<p><strong>Tier movements after re-vote:</strong></p><ul>${movementItems}</ul>` : '') +
+        (noResponseItems ? `<p><strong>No response (raiser did not defend):</strong></p><ul>${noResponseItems}</ul>` : '');
+    }
+  }
+
   return `<!DOCTYPE html>
 <html lang="en"><head><meta charset="utf-8">
 <title>Council Report — ${esc(h.runId)}</title>
@@ -91,7 +118,7 @@ td.c { text-align: center; }
 <table><tr><th>Finding</th><th>Sev</th><th>Raiser</th>${judgeHead}<th>Tier</th><th>Decision</th></tr>${matrixRows}</table>
 <p class="legend">✓ agree · ✗ dispute · – neutral · <sup>*</sup> raiser's own vote</p>
 <h2>Street-cred <span class="meta">(peers-only; lower = better)</span></h2>
-<table><tr><th>Model</th><th>peers-only</th><th>with-self</th></tr>${credRows}</table>
+<table><tr><th>Model</th><th>peers-only</th><th>with-self</th></tr>${credRows}</table>${debateSection}
 <h2>Cost</h2>
 <table><tr><th>Model</th><th>Status</th><th>Duration</th><th>Cost</th></tr>${costRows}
 <tr><td><strong>Wave total</strong></td><td></td><td></td><td>${esc(formatCost(m.cost.total))}</td></tr></table>

package/src/council/report.js

@@ -28,9 +28,30 @@ function toModel(verdict, wave) {
     return {
       id: f.id, severity: f.severity, raiser: f.raiser, tier: f.tier,
       basis: f.basis || { a: 0, d: 0, n: 0 }, decision: f.decision || null,
-      applied: f.applied === true, byJudge,
+      applied: f.applied === true, byJudge, debate: f.debate || null,
     };
   });
+  // 'movements' is deliberately re-vote-only (defended/amended): a withdrawn or
+  // no-response finding is never bundled into the re-vote (run-debate.js's
+  // bundleFor()), so its tier — even if it happens to differ from previousTier —
+  // was never "moved after re-vote". Listing it there would read as "still live,
+  // just downgraded" when it was actually retracted; withdrawn findings get their
+  // own list below so a reader can tell the two apart.
+  // no-response findings (spec §5.7: a dead defense leg, or one still
+  // unstructured after its single repair, makes that raiser's bundled
+  // findings all 'no-response') get their own list, same idiom as withdrawn —
+  // silently dropping them would leave a "## Debate round" heading with
+  // nothing beneath it whenever a run's only debating raiser never responded.
+  const debate = {
+    present: findings.some(f => f.debate) === true,
+    withdrawn: verdict.findings.filter(f => f.debate && f.debate.action === 'withdrawn')
+      .map(f => ({ id: f.id, previousTier: f.debate.previousTier, tier: f.tier })),
+    movements: verdict.findings.filter(f => f.debate && f.debate.action !== 'withdrawn' && f.debate.action !== 'no-response'
+        && f.debate.previousTier && f.debate.previousTier !== f.tier)
+      .map(f => ({ id: f.id, action: f.debate.action, previousTier: f.debate.previousTier, tier: f.tier })),
+    noResponse: verdict.findings.filter(f => f.debate && f.debate.action === 'no-response')
+      .map(f => ({ id: f.id, previousTier: f.debate.previousTier, tier: f.tier })),
+  };
   const runStats = verdict.runStats || [];
   const costRows = runStats.map(r => ({
     model: r.model, status: r.status, durationMs: r.durationMs,
@@ -43,7 +64,7 @@ function toModel(verdict, wave) {
       chair: verdict.chair, council: judges, claudeInCouncil: verdict.claudeInCouncil === true,
     },
     tierCounts: verdict.tierCounts || { Confirmed: 0, Contested: 0, Singleton: 0, Disputed: 0 },
-    judges, findings,
+    judges, findings, debate,
     streetCred: verdict.streetCred || [],
     cost: { rows: costRows, total },
   };
@@ -92,6 +113,33 @@ function renderMd(m) {
     out.push('');
   }
 
+  // Defensive: never emit the heading unless at least one grouping has
+  // content — a heading over nothing is worse than no heading.
+  if (m.debate.present && (m.debate.withdrawn.length || m.debate.movements.length || m.debate.noResponse.length)) {
+    out.push('\n## Debate round\n');
+    if (m.debate.withdrawn.length) {
+      out.push('**Withdrawn by raiser:**');
+      for (const w of m.debate.withdrawn) {
+        const arrow = w.previousTier && w.previousTier !== w.tier ? `${w.previousTier} → ${w.tier}` : (w.previousTier || w.tier);
+        out.push(`- ${w.id}: ${arrow} (withdrawn — no longer live)`);
+      }
+      out.push('');
+    }
+    if (m.debate.movements.length) {
+      out.push('**Tier movements after re-vote:**');
+      for (const mv of m.debate.movements) { out.push(`- ${mv.id}: ${mv.previousTier} → ${mv.tier} (${mv.action})`); }
+      out.push('');
+    }
+    if (m.debate.noResponse.length) {
+      out.push('**No response (raiser did not defend):**');
+      for (const nr of m.debate.noResponse) {
+        const arrow = nr.previousTier && nr.previousTier !== nr.tier ? `${nr.previousTier} → ${nr.tier}` : (nr.previousTier || nr.tier);
+        out.push(`- ${nr.id}: ${arrow} (no response — original stands)`);
+      }
+      out.push('');
+    }
+  }
+
   out.push('## Cost\n');
   out.push('| Model | Status | Duration | Cost |\n|---|---|---|---|');
   for (const r of m.cost.rows) { out.push(`| ${r.model} | ${r.status} | ${fmtDur(r.durationMs)} | ${formatCost(r.cost)} |`); }