amicus 4.4.0 → 4.5.0

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, a distinction downstream callers key off).
+ *
+ * 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): 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,34 @@ 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; }
+}
+
 /**
  * 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 +245,6 @@ 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,
+};

package/src/council/parse-stage2.js

@@ -35,7 +35,15 @@ function parseJudgeOutput(text, { labels, findingIds }) {
   const errors = [];
   const known = new Set(labels);
   const flat = [];
-  if (!Array.isArray(parsed.ranking) || parsed.ranking.length === 0) {
+  // ⚠️ v4.4.1 FINAL-REVIEW C. `JSON.parse('null')` SUCCEEDS — it returns null and
+  // throws nothing — so a body of literal `null` sailed past the catch above and
+  // `parsed.ranking` threw `TypeError: Cannot read properties of null`. parseDebateDefense
+  // (:129) and parseRevote (:167) below already carried this `!parsed` guard; the judge
+  // path and findings.js's validateFindings did not, which made it an asymmetry among
+  // five consumers of one extractor rather than a new rule. Guarded on BOTH derefs so
+  // a `null` body reports exactly what a keyless `{}` body already reported —
+  // BAD_RANKING + BAD_ADJUDICATIONS — and no new error code enters a repair prompt.
+  if (!parsed || !Array.isArray(parsed.ranking) || parsed.ranking.length === 0) {
     errors.push({ code: 'BAD_RANKING', detail: 'ranking must be a non-empty array of review labels' });
   } else {
     for (const slot of parsed.ranking) {
@@ -52,7 +60,7 @@ function parseJudgeOutput(text, { labels, findingIds }) {
   }
 
   const knownIds = new Set(findingIds);
-  if (!Array.isArray(parsed.adjudications)) {
+  if (!parsed || !Array.isArray(parsed.adjudications)) {   // see the `!parsed` note above
     errors.push({ code: 'BAD_ADJUDICATIONS', detail: 'adjudications must be an array' });
   } else {
     for (const a of parsed.adjudications) {

package/src/council/presets-cli.js

@@ -56,7 +56,8 @@ function runSave(name, modelsArg, useJson) {
 
 function renderSave(doc) {
   const notice = doc.overwritten ? ' (overwritten)' : '';
-  return `Saved council '${doc.name}'${notice}: ${doc.models.join(', ')}\n`;
+  return `Saved council '${doc.name}'${notice}: ${doc.models.join(', ')}\n` +
+    "  for full run configuration — chair, options, templates — see 'amicus pack'\n";
 }
 
 /**
@@ -102,6 +103,16 @@ function renderList(entries) {
  * which fails outright below 2 usable members), `show` is diagnostic-only:
  * it always reports the full resolved/dropped split, even for a council
  * that currently has fewer than 2 usable members.
+ *
+ * v4.5 Wave 2 (post-HOLD chip, task-23-report.md Anomaly 1): the resolved/
+ * dropped split now REUSES `classifyCouncilMembers` — the exact alias +
+ * catalog-membership + local-provider-tri-state check `resolveCouncilMembers`
+ * applies on every real run — instead of a parallel check that only asked
+ * "does the alias map to SOME id?" and never consulted the catalog at all
+ * (so a member whose alias resolved to a catalog-absent id read as healthy
+ * here while every real run silently dropped it). `droppedMembers` carries
+ * each dropped member's reason, distinguishing an unresolvable alias from a
+ * catalog-absent id — the same distinction `resolveCouncilMembers` computes.
  * @param {string|undefined} name
  * @param {boolean} useJson
  * @returns {number} exit code
@@ -111,7 +122,7 @@ function runShow(name, useJson) {
     return failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: 'council show needs a <name>',
       hint: 'amicus council show <name> [--json]' });
   }
-  const { getCouncilWithSource, getEffectiveAliases } = require('../utils/config');
+  const { getCouncilWithSource, classifyCouncilMembers } = require('../utils/config');
   const { readCache } = require('../utils/model-catalog');
   const catalog = (readCache() || {}).models || [];
   const { members, builtin } = getCouncilWithSource(name, catalog);
@@ -119,14 +130,8 @@ function runShow(name, useJson) {
     return failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: `Unknown council '${name}'`,
       hint: "'amicus council list' shows available councils, or 'amicus council save' to create one" });
   }
-  const aliases = getEffectiveAliases();
-  const resolved = [];
-  const dropped = [];
-  for (const member of members) {
-    const id = member.includes('/') ? member : aliases[member];
-    (id ? resolved : dropped).push(member);
-  }
-  const doc = { name, builtin, members, resolved, dropped };
+  const { models, dropped, droppedMembers } = classifyCouncilMembers(members, catalog);
+  const doc = { name, builtin, members, resolved: models, dropped, droppedMembers };
   process.stdout.write(useJson ? JSON.stringify(doc, null, 2) + '\n' : renderShow(doc));
   return 0;
 }
@@ -134,7 +139,14 @@ function runShow(name, useJson) {
 function renderShow(doc) {
   const tag = doc.builtin ? ' [built-in]' : '';
   let out = `Council '${doc.name}'${tag}\n  members: ${doc.members.join(', ')}\n  resolved: ${doc.resolved.join(', ')}\n`;
-  if (doc.dropped.length) { out += `  dropped: ${doc.dropped.join(', ')}\n`; }
+  if (doc.dropped.length) {
+    // Per-member reason (v4.5 Wave 2) when available; falls back to the bare
+    // ref list so this never throws on a hand-built doc missing the new field.
+    const detail = (doc.droppedMembers && doc.droppedMembers.length)
+      ? doc.droppedMembers.map(d => `${d.member} (${d.reason})`).join(', ')
+      : doc.dropped.join(', ');
+    out += `  dropped: ${detail}\n`;
+  }
   return out;
 }