amicus 4.4.0 → 4.4.1

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.',
@@ -149,6 +166,12 @@ function buildFindingsRepairPrompt({ errors, review }) {
   // 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,

package/src/council/findings.js

@@ -4,12 +4,124 @@
 const SEVERITIES = ['blocker', 'major', 'minor', 'nit'];
 const REQUIRED = ['claim', 'location', 'rationale'];
 
-/** Extract the LAST ```json fenced block's body, or null. */
+/** The start of a ```json block. Openers are enumerated INDEPENDENTLY — see below. */
+const OPENER = /```json\s*\n/g;
+
+/**
+ * The two readings of "where does this block close?", primary first.
+ *
+ * ANCHORED_CLOSE is the primary and the definition of a block: the closing fence
+ * starts a line (CommonMark's rule; leading horizontal whitespace allowed). It is
+ * what makes a body that CONTAINS a fence extractable at all.
+ *
+ * The same-line reading — the first triple-backtick anywhere ends the body — is the
+ * pre-Task-10 one. As a way to FIND blocks it is broken (it truncates any body that
+ * quotes a fence), but as a way to read a body a sloppy emit mis-delimited it is
+ * right, and JSON.parse rather than the regex decides which reading was.
+ */
+const ANCHORED_CLOSE = /^[ \t]*```/m;
+const FENCE = '```';
+
+/**
+ * How one opener's body can be read, primary first.
+ * @param {string} rest the text immediately following an opener
+ * @returns {Array<{body: string, anchored: boolean}>} 0–2 readings
+ */
+function bodyReadings(rest) {
+  const out = [];
+  const anchored = ANCHORED_CLOSE.exec(rest);
+  if (anchored) { out.push({ body: rest.slice(0, anchored.index), anchored: true }); }
+  const inline = rest.indexOf(FENCE);
+  if (inline !== -1) { out.push({ body: rest.slice(0, inline), anchored: false }); }
+  return out;
+}
+
+/**
+ * Extract the last ```json fenced block that is VALID JSON, or null.
+ *
+ * ⚠️ OWNER RULING (v4.4.1). "Last block" means the last candidate that PARSES, not
+ * the last one that is merely syntactically delimited. One rule closes two traps
+ * that no single regex can close at once — both of them measured, not hypothetical:
+ *
+ * TRAP 1 — a fence INSIDE the body (pre-Task-10). The pattern was
+ * `/```json\s*\n([\s\S]*?)```/g`: the first triple-backtick ANYWHERE in the JSON
+ * ended the match, so a findings block whose `claim` quotes a fence — which any
+ * review of markdown inevitably writes — was truncated mid-string and failed
+ * JSON.parse. On the paid md-lite council preserved in output/md-lite-council/,
+ * THREE of four seats hit it: `opus` cut at "```/) for both open and" (5 findings
+ * lost), `glm` at "```js) is silently disca" (6 lost), `minimax` at a
+ * repeated-backtick example. The chair synthesized from what survived, unaware.
+ *
+ * TRAP 2 — a sloppy block BEFORE a good one (introduced by Task 10's `c5f4a9e`,
+ * measured and pinned by Task 11). With the close anchored to line start, a
+ * same-line-fenced block's body runs on to the next line-start fence — which is the
+ * NEXT block's OPENING fence. A well-formed block behind a sloppy one became
+ * unreachable; the old unanchored regex found it.
+ *
+ * The algorithm, in three moves.
+ *
+ * 1. OPENERS ARE ENUMERATED INDEPENDENTLY, not by a single scan that resumes after
+ *    each match. That alone is what killed trap 2: the old scan's cursor jumped past
+ *    the good block's opener because the sloppy block's run-on body had swallowed
+ *    it, so the good block was never even a candidate. Every ```json opener now gets
+ *    considered on its own terms, whatever the block before it did.
+ * 2. EACH OPENER IS READ BOTH WAYS — anchored close (primary) and same-line close
+ *    (fallback) — so a sloppy but parseable emit stays reachable.
+ * 3. THE LAST OPENER WHOSE BODY PARSES WINS, preferring its anchored reading. A
+ *    truncated reading can never beat a whole one, because a truncated body does not
+ *    parse; JSON.parse is the arbiter, not the regex.
+ *
+ * The safety of consulting the sloppy reading at all is structural, not lucky: a raw
+ * newline inside a JSON string is invalid JSON, so no line of a WELL-FORMED body can
+ * begin with a fence, and no well-formed body can contain a `\n`-terminated ```json
+ * opener. The readings therefore agree on every well-formed block and can only
+ * disagree about a malformed one.
+ *
+ * ⚠️ WIDENED BY A SECOND OWNER RULING (v4.4.1, same release). The same-line reading
+ * may also DISCOVER a block, not merely recover one. The first cut of this function
+ * gated it — "recover, never discover" — so an opener whose ONLY close shared a line
+ * with body content returned null even when its JSON was perfect, buying a paid
+ * repair leg over a cosmetic closer. The owner widened it: every reading of every
+ * opener is a candidate, and JSON.parse arbitrates, full stop. Simulated before the
+ * ruling and re-pinned below: a body that QUOTES a fence still parses (trap 1 stays
+ * closed — per-opener arbitration keeps the anchored reading winning, because it is
+ * the one that parses), and a lone same-line block now parses instead of repairing.
+ *
+ * Only an opener that never closed AT ALL — no fence of either kind after it, i.e. a
+ * cut-off emit — yields no candidate. When no opener yields a candidate, the answer
+ * is null: nothing was ever closed, and the text goes to the repair wave.
+ *
+ * When candidates exist but NOTHING parses, the last opener's preferred (anchored if
+ * it has one) body is returned rather than null — deliberately. A malformed emit must
+ * not look like an absent one: callers key off that distinction (validateFindings
+ * reports NOT_PARSEABLE with a real body instead of NO_FENCED_BLOCK;
+ * countAttemptedFindings returns null vs 0, which repairCanHonorContract then reads).
+ *
+ * Every Stage-1/Stage-2 extractor funnels through here — validateFindings,
+ * countAttemptedFindings, and parse-stage2's parseJudgeOutput / parseDebateDefense
+ * / parseRevote — so judge, debate-defense and re-vote parsing carried both defects
+ * and are fixed by this one change.
+ *
+ * @param {string} text full model output (prose + fenced block)
+ * @returns {string|null} the winning block body, or null when nothing closed
+ */
 function lastJsonBlock(text) {
-  const re = /```json\s*\n([\s\S]*?)```/g;
-  let m, last = null;
-  while ((m = re.exec(text)) !== null) { last = m[1]; }
-  return last;
+  const src = String(text ?? '');
+  const perOpener = [];
+  OPENER.lastIndex = 0;
+  let m;
+  while ((m = OPENER.exec(src)) !== null) {
+    const readings = bodyReadings(src.slice(m.index + m[0].length));
+    if (readings.length > 0) { perOpener.push(readings); } // an opener that never closed is no candidate
+  }
+  if (perOpener.length === 0) { return null; }              // nothing ever closed
+  for (let i = perOpener.length - 1; i >= 0; i--) {
+    for (const reading of perOpener[i]) {
+      try { JSON.parse(reading.body); return reading.body; }
+      catch { /* not this reading — keep walking backwards */ }
+    }
+  }
+  return perOpener[perOpener.length - 1][0].body;           // malformed ≠ absent
 }
 
 /**
@@ -27,9 +139,57 @@ function validateFindings(jsonText) {
   try { parsed = JSON.parse(body); }
   catch (e) { return { ok: false, findings: [], errors: [{ code: 'NOT_PARSEABLE', detail: e.message }] }; }
 
-  const findings = Array.isArray(parsed.findings) ? parsed.findings : [];
-  if (findings.length === 0) {
-    errors.push({ code: 'EMPTY_FINDINGS', detail: 'findings is missing or empty' });
+  // ⚠️ v4.4.1 FINAL-REVIEW C — a body that parses to nothing usable.
+  // `JSON.parse('null')` SUCCEEDS: it returns null and throws nothing, so the catch
+  // above never sees it and every `parsed.<key>` below threw
+  // `TypeError: Cannot read properties of null`. Because run-stages.js:164 calls this
+  // from inside run.js's try/catch, ONE seat emitting a `null` body aborted an entire
+  // PAID council as exit 1 rather than degrading that seat — the fail-closed shape
+  // this release exists to remove.
+  //
+  // Same guard parse-stage2.js:129 and :167 already carried; this was an asymmetry
+  // among five consumers of one extractor, not a new rule. `!parsed` (their idiom)
+  // rather than `parsed === null`, so the other contentless bodies — 0, false, "" —
+  // land here too: each carries no object at all, each was already ok:false via
+  // EMPTY_FINDINGS, and NOT_PARSEABLE is the truer story to hand the repair prompt.
+  // A truthy scalar (123, "text") never crashed and is left on its existing path.
+  //
+  // NOT_PARSEABLE, not NO_FENCED_BLOCK: the distinction is load-bearing. The model
+  // emitted something broken, not nothing — and countAttemptedFindings must keep
+  // answering null (unverifiable) rather than 0 (a declared empty set), because
+  // repairCanHonorContract reads exactly that difference. It does: its own JSON.parse
+  // succeeds on `null`, and `Array.isArray(null.findings)` throws into its catch.
+  if (!parsed) {
+    return { ok: false, findings: [], errors: [{ code: 'NOT_PARSEABLE',
+      detail: `block body is ${JSON.stringify(parsed)}, not an object` }] };
+  }
+
+  // ⚠️ LC-10 (owner ruling, 2026-07-26). A review that read the material and found
+  // nothing is a VALID review — the anti-sycophancy clause shipped in every Stage-1
+  // briefing says so verbatim ("An empty severity category is a valid result"), and
+  // rejecting it structurally pressured models into inventing findings to satisfy
+  // the schema. costgate01's grok did exactly that, and the fabrication reached
+  // tally.json, the street-cred rankings, the chair synthesis and a human decision.
+  //
+  // The distinction that makes this safe: a BROKEN emit already has its own codes
+  // (NO_FENCED_BLOCK, NOT_PARSEABLE) and returns above this line. What reaches here
+  // is a cleanly-parsed object. A non-empty `overall` is what separates a deliberate
+  // "nothing found" from a model that emitted a hollow shell — the empty-overall case
+  // stays an error.
+  //
+  // The ruling blesses `findings: []` — an array that is PRESENT and empty. A missing
+  // or non-array `findings` key is not a declaration of zero and stays an error, which
+  // is the same line countAttemptedFindings already draws: an explicit `[]` counts as
+  // zero, an absent array returns null (unverifiable). Widening this to "no findings
+  // key at all is fine" would let a bare {"overall":"looks good"} — the exact hollow
+  // shell the `overall` guard exists to catch — pass as a clean review.
+  const declared = Array.isArray(parsed.findings);
+  const findings = declared ? parsed.findings : [];
+  const overall = typeof parsed.overall === 'string' ? parsed.overall.trim() : '';
+  if (!declared) {
+    errors.push({ code: 'EMPTY_FINDINGS', detail: 'findings is missing or not an array' });
+  } else if (findings.length === 0 && overall === '') {
+    errors.push({ code: 'EMPTY_FINDINGS', detail: 'findings is empty and overall is missing or blank' });
   }
   const seen = new Set();
   findings.forEach((f, i) => {
@@ -45,6 +205,70 @@ function validateFindings(jsonText) {
   return { ok: errors.length === 0, findings: errors.length === 0 ? findings : [], errors };
 }
 
+/**
+ * How many findings a review's trailing block ATTEMPTED to declare, regardless of
+ * whether they validate.
+ *
+ * ⚠️ LC-11: the repair prompt's contract is "the same findings, fixed — do not add
+ * or remove findings". Cardinality is the checkable half of that contract, and it
+ * is the half that matters: a repair which changes the count has produced findings
+ * the ORIGINAL PROSE never narrates, and that prose is what the judges read in
+ * bundle-stage2.md.
+ *
+ * Deliberately NOT validateFindings: an invalid block (bad severity, missing
+ * field) still declares a cardinality, and that is exactly the case the repair
+ * wave exists for.
+ *
+ * @param {string} text full review text (prose + fenced block)
+ * @returns {number|null} null when there is no block or it does not parse — in
+ *   which case there is nothing to compare and the caller must mark the result
+ *   unverified rather than implying a check happened.
+ */
+function countAttemptedFindings(text) {
+  const body = lastJsonBlock(text || '');
+  if (body === null) { return null; }
+  try {
+    const parsed = JSON.parse(body);
+    return Array.isArray(parsed.findings) ? parsed.findings.length : null;
+  } catch { return null; }
+}
+
+/**
+ * A canonical repair that HONORS the contract for a review which declared zero
+ * findings: the same (empty) set, with a real `overall`. Probe only — it is never
+ * sent to a model.
+ */
+const EMPTY_SET_REPAIR_PROBE =
+  '```json\n{"overall":"I read the material and found nothing to report.","findings":[]}\n```';
+
+/**
+ * Can a repair that honors the count contract pass validation at all, given the
+ * count the ORIGINAL declared?
+ *
+ * ⚠️ v4.4.1 review F2. The repair prompt's contract is "the same findings, fixed —
+ * do not add or remove findings", and run-stages.js refuses a repair that changed
+ * the count. When the original declared ZERO findings, the only contract-honoring
+ * repair is another empty set — so if the validator rejects an empty set, every
+ * outcome of that repair wave is predetermined: a compliant repair fails
+ * validation, a non-compliant one is refused on the count. Up to two PAID solo
+ * legs whose only reachable end state is 'unstructured'. Don't buy it.
+ *
+ * The answer is ASKED of the validator instead of hard-coded so the two rules can
+ * never drift. Task 3 (LC-10) makes a well-formed empty set valid; the day it
+ * lands this predicate starts returning true on its own, and the malformed empty
+ * original (blank or missing `overall`) enters the repair loop again — where a
+ * repair can now succeed by re-emitting zero findings with a real `overall`.
+ *
+ * @param {number|null} attemptedCount countAttemptedFindings(originalText)
+ * @returns {boolean} false ⇒ skip the repair loop; the spend cannot buy an outcome.
+ *   null (nothing to compare) is always repairable — that is the wave's main
+ *   legitimate use.
+ */
+function repairCanHonorContract(attemptedCount) {
+  if (attemptedCount !== 0) { return true; }
+  return validateFindings(EMPTY_SET_REPAIR_PROBE).ok;
+}
+
 /**
  * v4.0 §7: stamp the council v2 envelope onto a validateFindings result
  * (additive — ok/findings/errors stay top-level; existing key-readers keep
@@ -57,4 +281,7 @@ function buildValidateDoc(result) {
   return { schemaVersion: COUNCIL_SCHEMA_VERSION, type: 'council-validate', ...result };
 }
 
-module.exports = { validateFindings, buildValidateDoc, SEVERITIES, lastJsonBlock };
+module.exports = {
+  validateFindings, buildValidateDoc, SEVERITIES, lastJsonBlock, countAttemptedFindings,
+  repairCanHonorContract,
+};