amicus 4.3.0 → 4.4.1

package/src/cli-handlers-watch.js

@@ -29,8 +29,21 @@ function resolveWatchTarget(id, project) {
   const clean = String(id).replace(/^council-/, '');
 
   const { readPointer } = require('./council/run-state');
+  const { containsOnDisk } = require('./utils/path-fence');
   const ptr = readPointer(project, clean);
-  if (ptr) { return { kind: 'council', id: clean, runDir: ptr.runDir }; }
+  // readPointer validates `council-<id>.json`'s {runId, runDir} only for
+  // truthiness (run-state.js:133-139), so a tampered or stale pointer can point
+  // runDir anywhere on disk — and this resolver's runDir is what
+  // observe/watch-render.js opens events.jsonl from. Same realpath-containment
+  // fence the v4.4 workspace reads use (src/utils/path-fence.js); a real
+  // runDir is always nested inside project (src/mcp-council-run.js:109 enforces
+  // it at creation time), so nothing legitimate is refused. An escaping pointer
+  // falls through to the session lookup and then 'unknown' — the same outcome a
+  // missing pointer already produces, so handleWatch's BAD_SESSION contract is
+  // unchanged.
+  if (ptr && containsOnDisk(project, ptr.runDir)) {
+    return { kind: 'council', id: clean, runDir: ptr.runDir };
+  }
 
   // getSessionDir THROWS on a path-traversal id ('..' / separators) — this
   // resolver is exported and docblocked "pure over disk", so it must be
@@ -50,11 +63,44 @@ function resolveWatchTarget(id, project) {
 }
 
 /**
- * `amicus watch <id> [--json|--plain] [--interval <sec>] [--project <p>] [--ui]`
+ * `amicus watch [--ui] <id> [--json|--plain] [--interval <sec>] [--project <p>]`
  * @param {object} args parsed CLI args
  * @returns {Promise<number>} exit code (render loop: Task 12)
  */
 async function handleWatch(args) {
+  // v4.4: `amicus watch [--ui] [runId]` — GUI watch is the same verb (spec
+  // §4.4), not a separate command. Handled at the very top, above id
+  // resolution: unlike the machine-readable path, `--ui` alone (no runId)
+  // is valid and opens the Council Workspace run-list landing, so this
+  // branch must run BEFORE the "id is required" gate below.
+  if (args.ui) {
+    if (args.json) {
+      process.stderr.write('Error: --ui is interactive-only (no --json). Use amicus watch <id> --json for machine output.\n');
+      return 1;
+    }
+    // --project wins over --cwd (same precedence as the non-UI path below) —
+    // DE-ROT F46: `--project` is the documented first-priority option for
+    // `watch`; resolving from --cwd only would silently point the workspace
+    // at the wrong directory when a run was launched elsewhere.
+    const project = args.project || args.cwd || process.cwd();
+    const runId = args._[1] ? String(args._[1]) : '';
+    // ⚠️ v4.4.1 DOC-3: validate HERE, not by moving the branch. The branch's
+    // POSITION above the `id is required` gate is load-bearing (bare `--ui`
+    // opens the run-list landing and must keep working), so the runId check is
+    // pushed inside it and made conditional on a runId actually being supplied.
+    // Without this, `amicus watch <typo> --ui` skipped validateTaskId entirely
+    // and surfaced whatever getRunDetail produced — a vaguer error than the
+    // identical typo gets on the terminal path.
+    if (runId) {
+      const uiCheck = validateTaskId(runId);
+      if (!uiCheck.valid) { process.stderr.write(`${uiCheck.error}\n`); return 1; }
+    }
+    const { launchWorkspaceWindow } = require('./sidecar/workspace-window');
+    const res = await launchWorkspaceWindow({ project, runId });
+    if (res.error) { process.stderr.write(`${res.error}\n`); }
+    return res.code;
+  }
+
   const { failJson, ERROR_CODES } = require('./utils/error-doc');
   const id = args._[1];
   if (!id || id === true) {
@@ -64,14 +110,6 @@ async function handleWatch(args) {
   const check = validateTaskId(String(id));
   if (!check.valid) { process.stderr.write(`${check.error}\n`); return 1; }
 
-  // --ui is registered as the v4.4 Council Workspace seam only; this rev
-  // (v4.3) registers the flag + this fail-fast, the GUI itself is out of
-  // scope. --ui alone is accepted and falls through to the loop.
-  if (args.ui && args.json) {
-    process.stderr.write('Error: --ui is interactive-only and cannot be combined with --json\n');
-    return 1;
-  }
-
   const project = args.project || args.cwd || process.cwd();
   const target = resolveWatchTarget(String(id), project);
   if (target.kind === 'unknown') {

package/src/cli.js

@@ -598,12 +598,14 @@ Options for 'spend':
 `,
   watch: `
 Options for 'watch':
-  <id>                          A fan-out wave id, council run id, or session id
+  <id>                          A fan-out wave id, council run id, or session id.
+                                Optional with --ui: bare 'amicus watch --ui' opens the
+                                project's Council Workspace run list
   --project <path>              Project the run was launched in (default cwd)
   --interval <sec>              Refresh interval (default 2, floor 0.5)
   --plain                       Milestone log lines instead of the refresh table
   --json                        NDJSON: tailed events + composed doc on change + final doc
-  --ui                          Open the Council Workspace window (v4.4; interactive-only)
+  --ui                          Open the Council Workspace window (interactive-only)
 `,
   setup: `
 Options for 'setup':

package/src/council/briefings-debate.js

@@ -110,20 +110,40 @@ function buildRevoteBundle({ findings, date }) {
   return parts.join('\n\n');
 }
 
-function repair(kind, contract, errors) {
+/**
+ * ⚠️ LC-12: same omission as LC-6 one stage earlier — a repair solo is a FRESH
+ * session and cannot see the response it is repairing unless we hand it over.
+ * `prior` is embedded verbatim and uncapped; the absent case is stated rather
+ * than papered over with an empty block, so a model with nothing to correct is
+ * told to say so instead of left to invent a position.
+ * @param {string} kind 'defense' | 're-vote'
+ * @param {string} contract the trailing-JSON contract for that kind
+ * @param {Array<{code:string,detail:string}>} errors
+ * @param {string} [prior] the text that ACTUALLY failed validation
+ */
+function repair(kind, contract, errors, prior) {
   const lines = (errors || []).map(e => `- ${e.code}: ${e.detail}`).join('\n');
+  const text = typeof prior === 'string' ? prior.trim() : '';
+  const block = text
+    ? [`--- YOUR PREVIOUS ${kind.toUpperCase()} (verbatim — this is the text to correct) ---`,
+      text,
+      `--- END OF YOUR PREVIOUS ${kind.toUpperCase()} ---`].join('\n')
+    : `Your previous ${kind} response was empty — there is no prior text to correct. `
+      + 'Do not invent a position to satisfy the schema: say so in your output.';
   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:`,
+    'Do NOT use any tools or read any files; everything is in this message; begin '
+    + 'immediately with the JSON block.',
+    block,
+    `That ${kind} response's trailing JSON failed validation with these errors:`,
     lines,
-    'Re-emit ONLY the corrected JSON block as a single fenced ```json block:',
+    'Re-emit ONLY the corrected JSON block (the same position, fixed — do not change '
+    + 'your votes), 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); }
+function buildDefenseRepairPrompt({ errors, defense }) { return repair('defense', DEFENSE_CONTRACT, errors, defense); }
+function buildRevoteRepairPrompt({ errors, revote }) { return repair('re-vote', REVOTE_CONTRACT, errors, revote); }
 
 /**
  * Chair-packet "Debate round outcomes" section (spec §5.3c). De-anonymized —

package/src/council/briefings-stage2.js

@@ -22,7 +22,21 @@ 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). */
+/**
+ * Stage-2 headless output contract (spec §5, embedded in the judge bundle).
+ *
+ * ⚠️ LC-10 fast-follow (review minor M1): on a clean bench, JUDGE_TASK_B_NO_FINDINGS
+ * tells the judge to emit `"adjudications": []` — but this contract immediately
+ * follows it, and its worked example still shows `{"id":"A1"...},{"id":"B2"...}`.
+ * "One entry per listed finding id" is satisfied by zero entries, so it is not a
+ * contradiction, but the example is the last remaining incentive to invent an id:
+ * inventing one fails `UNKNOWN_FINDING_ID` (parse-stage2.js) and buys up to two
+ * paid repair solos per judge. The trailing bullet below states the zero case
+ * explicitly so the empty findings index has its own answer, not just an example
+ * that happens to allow it. It is unconditional (shown on every bench, including
+ * the ordinary and repair paths) because it is inert when findings exist and the
+ * repair prompt has no findings-state argument to swap on.
+ */
 const JUDGE_OUTPUT_CONTRACT = [
   'End your response with a trailing fenced ```json block — no text after it — in',
   'exactly this shape:',
@@ -41,15 +55,49 @@ const JUDGE_OUTPUT_CONTRACT = [
   '  Ties: use a nested array for tied labels, e.g. [["Review A", "Review B"], "Review C"].',
   '- "adjudications": one entry per listed finding id; "verdict" is one of:',
   '  agree | dispute | neutral. An "I missed this — it\'s valid" counts as agree.',
+  '- If the FINDINGS INDEX below is empty, "adjudications" must be exactly `[]` — do',
+  '  not invent a finding id merely to have something to adjudicate.',
 ].join('\n');
 
+/** Task B when there is something to adjudicate (the ordinary case). */
+const JUDGE_TASK_B =
+  'Task B — Adjudicate: for EVERY finding id listed below, state agree, dispute, or ' +
+  'neutral with your reasoning in prose.';
+
+/**
+ * Task B when the whole bench came back clean (LC-10).
+ *
+ * ⚠️ Once a well-formed empty findings set is a VALID review, a run in which every
+ * seat found nothing reaches Stage 2 with an EMPTY findings index — and the ordinary
+ * Task B then orders the judge to adjudicate "EVERY finding id listed below" when
+ * none are listed, under a bare heading with nothing beneath it. That is not merely
+ * untidy: `parse-stage2` validates every adjudication id against the run-global set,
+ * so a judge that answers the dangling instruction by inventing an id fails with
+ * UNKNOWN_FINDING_ID and buys up to two PAID repair solos per judge. Stating the
+ * empty case and naming the exact output (`"adjudications": []`) is what keeps the
+ * clean bench cheap.
+ */
+const JUDGE_TASK_B_NO_FINDINGS =
+  'Task B — Adjudicate: there is nothing to adjudicate on this bundle. No review ' +
+  'raised a finding, so the findings index below is empty. Emit "adjudications": [] ' +
+  'and do not invent finding ids to fill it — a review that read the material and ' +
+  'found nothing is a valid review. Task A still applies in full.';
+
+/** The findings index body when the bench raised nothing — never a bare heading. */
+const NO_FINDINGS_INDEX = '(none — no review in this bundle raised a finding)';
+
 /**
  * The single shared anonymized judge bundle.
  * @param {{reviews: Array<{label: string, text: string}>,
  *   findings: Array<{id: string, severity: string, claim: string}>}} args
+ *   `findings` may legitimately be EMPTY (LC-10): every seat reported a clean read.
+ *   The bundle then states so explicitly instead of emitting a heading over nothing.
  */
 function buildJudgeBundle({ reviews, findings, date }) {
-  const findingLines = findings.map(f => `${f.id} [${f.severity}] ${f.claim}`).join('\n');
+  const raised = Array.isArray(findings) ? findings : [];
+  const findingLines = raised.length
+    ? raised.map(f => `${f.id} [${f.severity}] ${f.claim}`).join('\n')
+    : NO_FINDINGS_INDEX;
   const reviewBlocks = reviews
     .map(r => `--- ${r.label} ---\n${r.text}`)
     .join('\n\n');
@@ -58,8 +106,7 @@ function buildJudgeBundle({ reviews, findings, 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 ' +
-    'neutral with your reasoning in prose.',
+    raised.length ? JUDGE_TASK_B : JUDGE_TASK_B_NO_FINDINGS,
     JUDGE_OUTPUT_CONTRACT,
     '--- FINDINGS INDEX (run-global ids) ---',
     findingLines,
@@ -68,15 +115,38 @@ function buildJudgeBundle({ reviews, findings, date }) {
   return parts.join('\n\n');
 }
 
-/** Bounded judge-repair re-prompt (solo; ≤ 2 per judge — spec §5). */
-function buildJudgeRepairPrompt({ errors }) {
+/**
+ * Bounded judge-repair re-prompt (solo; ≤ 2 per judge — spec §5).
+ *
+ * ⚠️ LC-12: a repair solo is a FRESH session with no memory of the judging turn.
+ * Shipping only `errors` asked the model to correct something it had never seen —
+ * the identical defect LC-6 fixed one stage earlier, where it cost three of five
+ * paid councils a seat. Stage 2 is worse: a refused judge has no `conformance`
+ * column, so the tally silently shows fewer votes and basis counts can flip a tier.
+ *
+ * `judgement` is embedded verbatim and uncapped — a silent truncation would
+ * recreate the defect in a subtler form (repairing a judgement the model can only
+ * half see) — and the absent case is STATED rather than papered over with an
+ * empty block.
+ * @param {{errors?: Array<{code:string,detail:string}>, judgement?: string}} args
+ */
+function buildJudgeRepairPrompt({ errors, judgement }) {
   const lines = (errors || []).map(e => `- ${e.code}: ${e.detail}`).join('\n');
+  const text = typeof judgement === 'string' ? judgement.trim() : '';
+  const prior = text
+    ? ['--- YOUR PREVIOUS JUDGEMENT (verbatim — this is the text to correct) ---',
+      text,
+      '--- END OF YOUR PREVIOUS JUDGEMENT ---'].join('\n')
+    : 'Your previous response was empty — there is no prior judgement to correct. '
+      + 'Do not invent rankings or adjudications to satisfy the schema: say so in your output.';
   return [
-    'Do NOT use any tools or read any files; everything is in this message; begin ' +
-    'immediately with the JSON block.',
-    'Your previous judging response\'s trailing JSON failed validation with these errors:',
+    'Do NOT use any tools or read any files; everything is in this message; begin '
+    + 'immediately with the JSON block.',
+    prior,
+    'That judging response\'s trailing JSON failed validation with these errors:',
     lines,
-    'Re-emit ONLY the corrected JSON block as a single fenced ```json block:',
+    'Re-emit ONLY the corrected JSON block (the same rankings and adjudications, fixed — '
+    + 'do not change your votes), as a single fenced ```json block:',
     JUDGE_OUTPUT_CONTRACT,
   ].join('\n\n');
 }
@@ -101,49 +171,107 @@ const VERDICT_SCALE_ADDENDUM = [
   '   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
+  const rankingLines = (rankings || [])
     .map(r => `${r.judge}: ${JSON.stringify(r.order)}`)
     .join('\n');
-  const adjLines = adjudications
+  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(
-    '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.',
     `Deterministic tier counts (peers-only cascade): ${tiers}`,
     '--- STAGE-1 REVIEWS (de-anonymized) ---',
     reviewBlocks,
     '--- PEER RANKINGS (judge: order, best first) ---',
-    rankingLines,
+    orNone(rankingLines, '(none — no judge produced a usable ranking)'),
     '--- PER-FINDING ADJUDICATIONS ---',
-    adjLines,
+    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). */
-function buildChairRepairPrompt() {
+/**
+ * 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.',
-    'Your synthesis was received, but the final parseable line was missing. Emit ONLY ' +
-    'one line, exactly one of:',
+    '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',
@@ -153,5 +281,7 @@ function buildChairRepairPrompt() {
 module.exports = {
   JUDGE_NO_TOOLS_PREAMBLE, CHAIR_NO_TOOLS_PREAMBLE, CHAIR_VERDICT_VALUES,
   JUDGE_OUTPUT_CONTRACT, 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,
 };

package/src/council/briefings.js

@@ -31,7 +31,20 @@ const FINDINGS_TWO_PART_FRAMING = [
   '2. A trailing fenced ```json block immediately after the prose — no text after it:',
 ].join('\n');
 
-/** JSON shape + field rules — shared by the full Stage-1 contract AND the repair prompt. */
+/**
+ * JSON shape + field rules — shared by the full Stage-1 contract AND the repair prompt.
+ *
+ * ⚠️ LC-10 (owner ruling, 2026-07-26). The `"overall"` and `"findings"` rules below
+ * are what finally make this prompt and `validateFindings` say the same thing. The
+ * briefing has always shipped the anti-sycophancy clause's "An empty severity category
+ * is a valid result" while the validator rejected exactly that answer (EMPTY_FINDINGS),
+ * so the only way for a model to satisfy the schema was to produce a finding —
+ * structural pressure to fabricate, which costgate01's grok obeyed. The validator now
+ * accepts a well-formed empty set, and these two lines state the same rule to the model:
+ * `findings` may be `[]`, `overall` may never be blank. Stating `overall` explicitly
+ * matters more than it looks — it is the field that separates "I read it and found
+ * nothing" from a hollow shell, and it was never in the field rules at all.
+ */
 const FINDINGS_JSON_SHAPE = [
   '```json',
   '{',
@@ -43,6 +56,10 @@ const FINDINGS_JSON_SHAPE = [
   '}',
   '```',
   '',
+  '- "overall" — a non-empty string. Always required, including when you found nothing.',
+  '- "findings" — the array of findings, always present. If you genuinely found nothing,',
+  '  emit [] and say so in "overall": a review that read the material and found nothing',
+  '  is a valid review. Never invent a finding to fill the array.',
   '- "id" — sequential integer within this review, starting at 1.',
   '- "severity" — one of: blocker | major | minor | nit.',
   '- "claim", "location", "rationale" — non-empty strings.',
@@ -121,13 +138,52 @@ function buildLensBriefing({ lens, briefing, date }) {
  * repair loop). References ONLY the json-shape fragment — never the
  * "prose review THEN json" framing — so a headless model isn't handed license
  * to write a whole new prose review on a tight repair turn.
+ *
+ * ⚠️ LC-6. This used to carry the validation ERRORS without the REVIEW they
+ * were errors about, and a repair solo is a FRESH session with no memory of
+ * the review turn. Three of five paid councils burned a seat on it:
+ *   - wsgate02 `qwen`  — refused twice: "I don't have a previous review to correct"
+ *   - wsgate04 `glm`   — refused twice: "the previous review's content was
+ *                        excluded by the caller… I will not fabricate findings"
+ *   - costgate01 `grok` — COMPLIED, by inventing a self-referential finding
+ *                        about its own empty output, which then entered
+ *                        tally.json, the street-cred table and the chair
+ *                        synthesis as C1 and reached a human's decision.
+ * Honest models lose the seat (a 4-model bench silently adjudicating on 3,
+ * still paying for the fourth); compliant ones poison the record.
+ *
+ * `review` is the text that ACTUALLY failed — the original review on the first
+ * attempt, the previous repair's output on the second — so the errors and the
+ * artifact they describe are always the same thing. It is embedded verbatim and
+ * uncapped: the largest real case was 35 KB, and a silent truncation would
+ * recreate this defect in a subtler form (repairing a review the model can only
+ * half see).
+ * @param {{errors?: Array<{code: string, detail: string}>, review?: string}} args
  */
-function buildFindingsRepairPrompt({ errors }) {
+function buildFindingsRepairPrompt({ errors, review }) {
   const lines = (errors || []).map(e => `- ${e.code}: ${e.detail}`).join('\n');
+  const text = typeof review === 'string' ? review.trim() : '';
+  // The absent case is stated, never papered over with an empty block: a model
+  // asked to repair nothing must be told to report nothing rather than left to
+  // guess, which is precisely what produced grok's invented finding.
+  //
+  // ⚠️ LC-10: this branch's instruction — "emit an empty findings array and say so
+  // in overall" — described an answer the validator then REJECTED, so a model that
+  // complied burned its second repair attempt and still landed 'unstructured'. It is
+  // now the correct answer: an empty set with a real `overall` validates, and the
+  // seat ends 'repaired' + findingsUnverified rather than 'unstructured'.
+  const prior = text
+    ? ['--- YOUR PREVIOUS REVIEW (verbatim — this is the text to correct) ---',
+      text,
+      '--- END OF YOUR PREVIOUS REVIEW ---'].join('\n')
+    : 'Your previous response was empty — there is no prior review text to correct. ' +
+      'Do not invent findings to satisfy the schema: emit an empty "findings" array ' +
+      'and say so in "overall".';
   return [
     'Do NOT use any tools or read any files; everything is in this message; begin ' +
     'immediately with the JSON block.',
-    'Your previous review\'s trailing findings JSON failed validation with these errors:',
+    prior,
+    'That review\'s trailing findings JSON failed validation with these errors:',
     lines,
     'Re-emit ONLY the corrected findings JSON block (the same findings, fixed — do not ' +
     'add or remove findings), as a single fenced ```json block:',