amicus 4.3.0 → 4.4.1

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,
+};

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/report.js

@@ -114,15 +114,26 @@ function renderMd(m) {
   for (const s of m.streetCred) { out.push(`| ${s.model} | ${fmtNum(s.peersOnly)} | ${fmtNum(s.withSelf)} |`); }
 
   out.push('\n## Findings by tier\n');
-  for (const t of TIER_ORDER) {
-    const group = m.findings.filter(f => f.tier === t);
-    if (!group.length) { continue; }
-    out.push(`### ${t}`);
-    for (const f of group) {
-      const dec = f.decision ? ` — ${f.decision}${f.applied ? ' (applied)' : ''}` : '';
-      out.push(`- **${f.id}** (${f.severity}, raiser ${f.raiser}) — a${f.basis.a}/d${f.basis.d}/n${f.basis.n}${dec}`);
+  // LC-10 fast-follow (review minor M3): m.findings can legitimately be EMPTY
+  // (every seat honestly reported nothing) — TIER_ORDER's four groups are then
+  // all empty too, and the loop below emits nothing, leaving this heading with
+  // no content beneath it before '## Cost'. Same heading-over-nothing class
+  // Task 3 closed in the Stage-2 prompts (buildJudgeBundle/buildChairPacket),
+  // human-facing here rather than model-facing. State the clean bench instead
+  // of leaving the heading to dangle.
+  if (!m.findings.length) {
+    out.push('_No findings were raised on this bench — a clean review is a valid review._\n');
+  } else {
+    for (const t of TIER_ORDER) {
+      const group = m.findings.filter(f => f.tier === t);
+      if (!group.length) { continue; }
+      out.push(`### ${t}`);
+      for (const f of group) {
+        const dec = f.decision ? ` — ${f.decision}${f.applied ? ' (applied)' : ''}` : '';
+        out.push(`- **${f.id}** (${f.severity}, raiser ${f.raiser}) — a${f.basis.a}/d${f.basis.d}/n${f.basis.n}${dec}`);
+      }
+      out.push('');
     }
-    out.push('');
   }
 
   // Defensive: never emit the heading unless at least one grouping has

package/src/council/run-assemble.js

@@ -40,13 +40,26 @@ function worseConformance(a, b) {
  * leg doc yields durationMs/usage null (never invent a value). `model` (the
  * council alias) overrides leg.model (the resolved executable id) so ledger
  * rows join meta.models by exact string (ledger.js:20-24).
+ *
+ * ⚠️ LC-11 / review F1: `findingsUnverified` and `repairRefused` are the same
+ * class of fact as `conformance` and ride the same row. They are the two halves
+ * of the repair contract's outcome: `findingsUnverified` marks a 'repaired' seat
+ * whose contract could NOT be checked (the original block was absent or
+ * unparseable, so there was no finding count to compare), and `repairRefused`
+ * ({code, detail}) marks the stronger case — the contract WAS checked and broken,
+ * which is otherwise indistinguishable from a seat that never emitted JSON at
+ * all. Both are additive and present only when set, so a run without either is
+ * byte-for-byte unchanged.
  */
-function buildRunStatsEntry({ leg, model, role, wasChair, conformance }) {
+function buildRunStatsEntry({ leg, model, role, wasChair, conformance, findingsUnverified,
+  repairRefused }) {
   return {
     model: model !== undefined ? model : (leg ? leg.model : null),
     role,
     wasChair: !!wasChair,
     conformance: conformance || 'clean',
+    ...(findingsUnverified ? { findingsUnverified: true } : {}),
+    ...(repairRefused ? { repairRefused } : {}),
     status: leg ? leg.status : 'error',
     durationMs: leg && typeof leg.durationMs === 'number' ? leg.durationMs : null,
     usage: (leg && leg.usage) || null,
@@ -139,6 +152,7 @@ function buildTallyInput({ runId, date, bench, chair, reviews, judgeResults, cha
   const rankings = okJudges.map(j => ({ judge: j.judge, order: j.order }));
   const runStats = reviews.map(r => buildRunStatsEntry({
     leg: r.leg, model: r.model, role: r.role, wasChair: false, conformance: r.conformance,
+    findingsUnverified: r.findingsUnverified, repairRefused: r.repairRefused,
   }));
   if (claudeReview) {
     meta.models.push(CLAUDE_SEAT);      // last, mirroring its review-N+1 label
@@ -176,7 +190,34 @@ function writeVerdictFiles({ runDir, record, overallVerdict, chairText }) {
   return verdict;
 }
 
+/**
+ * Build the chair packet and persist it as `chair-packet.md`. Lifted verbatim
+ * out of run.js for the 300-line gate (v4.4.1 Task 0.5) — same composition,
+ * same debate addendum, same file write.
+ * @param {{runDir: string, reviews: Array, claudeReview: object|null,
+ *   tallyInput: object, record: object, debateOutcomes: Array|null, date: string}} args
+ *   `tallyInput`/`record` are the DEBATED ones when --debate ran, the
+ *   provisional pair otherwise (run.js keeps that sequencing).
+ * @returns {string} the packet text (run.js hands it straight to runChair)
+ */
+function buildChairPacketFile({ runDir, reviews, claudeReview, tallyInput, record, debateOutcomes, date }) {
+  const { buildChairPacket } = require('./briefings-stage2');
+  const { buildDebateAddendum } = require('./briefings-debate');
+  const packet = buildChairPacket({
+    // §4.4: the chair sees Claude's de-anonymized review like any other; it casts
+    // no rankings/adjudications, so it appears ONLY as one more review block.
+    reviews: reviews.map(r => ({ model: r.model, text: r.text }))
+      .concat(claudeReview ? [{ model: 'claude', text: claudeReview.text }] : []),
+    rankings: tallyInput.rankings,
+    adjudications: tallyInput.adjudications,
+    tierCounts: record.tierCounts, date,
+  }) + (debateOutcomes ? '\n\n' + buildDebateAddendum({ outcomes: debateOutcomes }) : '');
+  fs.writeFileSync(path.join(runDir, 'chair-packet.md'), packet, { mode: 0o600 });
+  return packet;
+}
+
 module.exports = {
   buildRunStatsEntry, worseConformance, buildTallyInput, writeTallyFiles, writeVerdictFiles,
+  buildChairPacketFile,
   preflightClaudeReview, labelClaudeReview, claudeRunStatsRow, CLAUDE_SEAT,
 };