@event4u/agent-config 14.12.0 → 14.13.0

package/src/scripts/adoption_report.ts

@@ -259,7 +259,7 @@ function _pyTruthy(v: Json): boolean {
 export function render_report(rows: JsonObject[], weeks: number): string {
     let header =
         '# Adoption report — rolling trend\n\n' +
-        '> Generated by `scripts/adoption_report.py` from ' +
+        '> Generated by `adoption_report`. Do not edit. From ' +
         '`agents/runtime/metrics/adoption-snapshots.jsonl`.\n' +
         `> Window: rolling ${weeks} weeks. Source contract: ` +
         '`docs/contracts/adoption-signal-floor.md`.\n\n';

package/src/scripts/adr/evidence_census.ts

@@ -700,7 +700,7 @@ export function renderArtifact(result: CensusResult): string {
     L.push('# ADR evidence census — proposed provenance and evidence grades');
     L.push('');
     L.push(
-        `Generated by \`src/scripts/adr/evidence_census.ts\`. Records examined: **${String(result.scanned)}** ` +
+        `Generated by \`evidence_census\`. Records examined: **${String(result.scanned)}** ` +
             `(${String(result.records.filter((r) => r.surface === 'flat').length)} flat, ` +
             `${String(result.records.filter((r) => r.surface === 'area').length)} per-area).`,
     );

package/src/scripts/adr/regenerate_index.ts

@@ -17,6 +17,7 @@ import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { readAdrAxisCells, readAdrFrontmatterScalars } from '../_lib/adr_frontmatter.js';
+import { generatedByItalic } from '../_lib/generated_by.js';
 
 // ^ADR-(\d{3})-([a-z0-9-]+)\.md$
 const NAMED = /^ADR-(\d{3})-([a-z0-9-]+)\.md$/;
@@ -171,6 +172,28 @@ export function scan(d: string): [Row[], Row[], string[]] {
     return [num, leg, errs];
 }
 
+/**
+ * A supersession cell: the refs, plus the partial-supersession scope in
+ * parentheses when the record declares one.
+ *
+ * The scope used to live INSIDE the ref value — `superseded_by: ADR-124
+ * (engine-adoption interpretation only)` — which put prose inside a
+ * comma-separated ref list and forced every reader to strip parentheses before
+ * resolving a number. `adr-layout` moved it to a sibling `*_scope` field. This
+ * helper is why that move costs the reader nothing: the rendered cell is
+ * unchanged, so a partial supersession is still visible at a glance, while the
+ * SOURCE stays parseable without a regex.
+ *
+ * A scope with no refs renders as `—`: a qualifier on nothing is not a
+ * supersession, and printing the prose alone would read as one.
+ */
+export function supersessionCell(refs: string | undefined, scope: string | undefined): string {
+    const r = (refs ?? '').trim();
+    if (r === '' || r === '—') return '—';
+    const s = (scope ?? '').trim();
+    return s === '' || s === '—' ? r : `${r} (${s})`;
+}
+
 /** Mirror `row(r)`. */
 export function row(r: Row): string {
     const decision = r.decision ?? r.slug ?? '—';
@@ -179,7 +202,8 @@ export function row(r: Row): string {
     return (
         `| [${label}](${r.path}) | ${title} | ${r.status ?? '—'} ` +
         `| ${r.date ?? '—'} | ${r.provenance_kind ?? '—'} | ${r.evidence_grade ?? '—'} ` +
-        `| ${r.supersedes ?? '—'} | ${r.superseded_by ?? '—'} ` +
+        `| ${supersessionCell(r.supersedes, r.supersedes_scope)} ` +
+        `| ${supersessionCell(r.superseded_by, r.superseded_scope)} ` +
         `| ${r.amended_by ?? '—'} |`
     );
 }
@@ -243,7 +267,7 @@ export function render(num: Row[], leg: Row[], outside: OutsideRow[] = []): stri
     const out = [
         '# ADR Index',
         '',
-        '_Auto-generated by `src/scripts/adr/regenerate_index.ts`. Do not edit._',
+        generatedByItalic('regenerate_index'),
         '',
     ];
     if (num.length === 0 && leg.length === 0 && outside.length === 0) {

package/src/scripts/adr_cite_check.ts

@@ -503,6 +503,20 @@ export function verdict_for(r: Omit<CiteResult, 'verdict'>): string {
         const by = r.superseded_by !== undefined && r.superseded_by !== '—' ? ` (by ${r.superseded_by})` : '';
         return `NOT A LIVE LOCK — status is \`${status}\`${by}. Citing it as a blocker is a stale-state claim.`;
     }
+    if (status === 'challenged') {
+        // Reported DISTINCTLY from `accepted` and from `superseded`, and it is a
+        // LIVE lock. `challenged` records "accepted, and under active question";
+        // it names no successor and suspends nothing. If citing it cleared the
+        // lock, the status would become a way to stop obeying a decision without
+        // reopening it — road-to-decision-conformance 1.2 names that as the
+        // failure to prevent, and this branch is where it would have happened.
+        return (
+            'LIVE, CHALLENGED — the decision is under active question and STILL BINDS. ' +
+            'A challenge is not a successor: nothing has replaced this record. Read the ' +
+            'challenge, then either satisfy it or route the reopening — do not treat the ' +
+            'status as permission to act against the decision.'
+        );
+    }
     if (status === 'rejected') {
         return (
             'LIVE — status `rejected` records a REJECTED PROPOSAL, so the rejection is the ' +
@@ -793,18 +807,167 @@ export function selfTest(): number {
     }
 }
 
+/**
+ * One row per ADR — the corpus survey `road-to-decision-conformance` Phase 2
+ * asks for. Distinct from `--cited`, which resolves every ADR *citation* and
+ * answers "does this reference land"; this answers "what state is the corpus
+ * in", which is a different denominator (186 records vs the citations that
+ * happen to name them).
+ */
+export interface CorpusRow {
+    ref: string;
+    file: string;
+    status: string;
+    /** `superseded_by` when present, else `—`. */
+    successor: string;
+    /** Does the record carry a `review_trigger` at all? */
+    has_trigger: boolean;
+    /** Only meaningful when `has_trigger`; see `TRIGGER_VERDICTS`. */
+    trigger: 'fired' | 'not-fired' | 'indeterminate' | 'none';
+    reopen_policy: string;
+    /** Cited anywhere OUTSIDE `docs/decisions/`. */
+    cited_outside: boolean;
+}
+
+/**
+ * The three states 2.2 requires, and why a fourth exists beside them.
+ *
+ * `none` is NOT one of the three. The step asks that fired + not-fired +
+ * indeterminate sum to "the number of ADRs carrying a trigger", so a record
+ * with no trigger is outside the denominator rather than a fourth bucket
+ * inside it.
+ */
+export const TRIGGER_VERDICTS = ['fired', 'not-fired', 'indeterminate'] as const;
+
+/** Every ADR file, surveyed. */
+export function corpus_survey(repo_root: string = REPO_ROOT): CorpusRow[] {
+    const files = adr_files(repo_root);
+    const cited_outside = new Set<string>();
+    for (const root of CITATION_ROOTS) {
+        for (const file of walk_citable(path.join(repo_root, root))) {
+            const rel = path.relative(repo_root, file);
+            if (rel.startsWith(path.join('docs', 'decisions'))) continue;
+            for (const m of fs.readFileSync(file, 'utf-8').matchAll(CITATION_RE)) {
+                const parsed = normalise_ref(m[0]);
+                if (parsed !== null) cited_outside.add(parsed.id);
+            }
+        }
+    }
+    const rows: CorpusRow[] = [];
+    for (const f of files) {
+        const text = fs.readFileSync(f, 'utf-8');
+        const fm = parse_frontmatter(text) ?? {};
+        const base = path.basename(f);
+        // Key on the SAME identity the citation side produces, via
+        // `normalise_ref`. Deriving it with a private regex here is how the two
+        // halves of a join silently stop matching.
+        const parsedSelf = normalise_ref(path.relative(repo_root, f));
+        const num = parsedSelf?.id ?? base;
+        const raw_trigger = (fm['review_trigger'] ?? '').trim();
+        rows.push({
+            ref: num,
+            file: path.relative(repo_root, f),
+            status: (fm['status'] ?? '(none)').trim(),
+            successor: (fm['superseded_by'] ?? '—').trim() || '—',
+            has_trigger: raw_trigger !== '' && raw_trigger.toLowerCase() !== 'unclassified',
+            trigger: trigger_state(fm),
+            reopen_policy: (fm['reopen_policy'] ?? 'unclassified').trim() || 'unclassified',
+            cited_outside: cited_outside.has(num),
+        });
+    }
+    return rows.sort((a, b) => a.ref.localeCompare(b.ref));
+}
+
+export interface CorpusSummary {
+    total: number;
+    by_status: Record<string, number>;
+    with_trigger: number;
+    trigger_counts: Record<string, number>;
+    accepted: number;
+    accepted_cited_outside: number;
+    uncited_pct: number;
+    reopen_policy_declared: number;
+}
+
+export function corpus_summary(rows: readonly CorpusRow[]): CorpusSummary {
+    const by_status: Record<string, number> = {};
+    for (const r of rows) by_status[r.status] = (by_status[r.status] ?? 0) + 1;
+    const with_trigger = rows.filter((r) => r.has_trigger).length;
+    const trigger_counts: Record<string, number> = { fired: 0, 'not-fired': 0, indeterminate: 0 };
+    for (const r of rows) {
+        if (!r.has_trigger) continue;
+        trigger_counts[r.trigger] = (trigger_counts[r.trigger] ?? 0) + 1;
+    }
+    const accepted = rows.filter((r) => r.status.toLowerCase() === 'accepted');
+    const cited = accepted.filter((r) => r.cited_outside).length;
+    return {
+        total: rows.length,
+        by_status,
+        with_trigger,
+        trigger_counts,
+        accepted: accepted.length,
+        accepted_cited_outside: cited,
+        uncited_pct: accepted.length === 0 ? 0 : ((accepted.length - cited) * 100) / accepted.length,
+        reopen_policy_declared: rows.filter((r) => r.reopen_policy !== 'unclassified').length,
+    };
+}
+
+function render_corpus(rows: readonly CorpusRow[], sum: CorpusSummary): string {
+    const out: string[] = [];
+    out.push(`adr corpus survey · ${String(sum.total)} decision record(s)\n`);
+    out.push('  status:');
+    for (const [k, v] of Object.entries(sum.by_status).sort()) {
+        out.push(`      ${k.padEnd(14)} ${String(v)}`);
+    }
+    out.push('');
+    out.push(`  review_trigger — ${String(sum.with_trigger)} record(s) carry one:`);
+    for (const k of TRIGGER_VERDICTS) {
+        out.push(`      ${k.padEnd(14)} ${String(sum.trigger_counts[k] ?? 0)}`);
+    }
+    const triSum = TRIGGER_VERDICTS.reduce((a, k) => a + (sum.trigger_counts[k] ?? 0), 0);
+    out.push(
+        `      ${'sum'.padEnd(14)} ${String(triSum)}` +
+            (triSum === sum.with_trigger ? '  ✅ equals the carrying count' : '  ❌ DOES NOT equal the carrying count'),
+    );
+    out.push('');
+    out.push(
+        `  citation reach — ${String(sum.accepted_cited_outside)} of ${String(sum.accepted)} accepted ` +
+            `ADR(s) are cited outside docs/decisions/ (${sum.uncited_pct.toFixed(1)} % uncited)`,
+    );
+    out.push(
+        `  reopen_policy  — ${String(sum.reopen_policy_declared)} of ${String(sum.total)} declare one; ` +
+            'the rest resolve to `unclassified`',
+    );
+    out.push('');
+    out.push('  Reports only. This command decides nothing and gates nothing.');
+    return out.join('\n') + '\n';
+}
+
 function main(argv: string[]): number {
     const as_json = argv.includes('--json');
     if (argv.includes('--self-test')) return selfTest();
     const corpus_mode = argv.includes('--cited');
+    const survey_mode = argv.includes('--all');
+    if (survey_mode) {
+        const root = scan_root();
+        const rows = corpus_survey(root);
+        const sum = corpus_summary(rows);
+        process.stdout.write(
+            as_json ? `${JSON.stringify({ summary: sum, rows }, null, 2)}\n` : render_corpus(rows, sum),
+        );
+        return 0;
+    }
     const explicit = argv.filter((a) => !a.startsWith('--'));
     if (!corpus_mode && explicit.length === 0) {
         process.stderr.write(
             'usage: adr_cite_check <ADR-NNN> [ADR-NNN …] [--json]\n' +
                 '       adr_cite_check --cited [--json]\n' +
+                '       adr_cite_check --all [--json]\n' +
                 '       evaluate a decision before citing it as a reason not to act\n' +
                 '       --cited: resolve every ADR citation in ' +
-                `${CITATION_ROOTS.join(', ')} (the CI gate)\n`,
+                `${CITATION_ROOTS.join(', ')} (the CI gate)\n` +
+                '       --all: one row per decision record — status, successor, trigger\n' +
+                '              state, reopen_policy, citation reach. Reports only.\n',
         );
         return 2;
     }

package/src/scripts/ai_council/blind_review.ts

@@ -31,7 +31,17 @@ type Dict = Record<string, unknown>;
 
 // ── deterministic seeding (sha256 of the question text — no Math.random, no Date) ──
 
-function _sha256_hex(s: string): string {
+/**
+ * `sha256(s)` as lowercase hex.
+ *
+ * EXPORTED since 2026-08-30 rather than copied: the re-council guard
+ * (`recouncil_guard.ts`) needs the question hash, and
+ * road-to-inbox-harvest-2026-08-e-council-topology-evidence 1A.1 requires it to
+ * reuse THE EXISTING one — "no second hash implementation". Two hashes of one
+ * question are two answers to "is this the same question", and the second one
+ * is the one nobody updates.
+ */
+export function _sha256_hex(s: string): string {
     return createHash('sha256').update(s, 'utf-8').digest('hex');
 }
 

package/src/scripts/ai_council/clients.ts

@@ -269,6 +269,8 @@ export class CouncilResponse {
     // persisted response JSON stay backward-compatible.
     model_served: string;
     text: string;
+    /** Pre-rewrite reply; `null` when nothing rewrote `text`. See inline_findings.ts. */
+    raw_text: string | null;
     input_tokens: number;
     output_tokens: number;
     // Prompt-cache accounting (Anthropic). `cache_read_input_tokens` bill at
@@ -286,6 +288,7 @@ export class CouncilResponse {
         model: string;
         model_served?: string;
         text: string;
+        raw_text?: string | null;
         input_tokens?: number;
         output_tokens?: number;
         cache_creation_input_tokens?: number;
@@ -298,6 +301,7 @@ export class CouncilResponse {
         this.model = opts.model;
         this.model_served = opts.model_served ?? '';
         this.text = opts.text;
+        this.raw_text = opts.raw_text ?? null;
         this.input_tokens = opts.input_tokens ?? 0;
         this.output_tokens = opts.output_tokens ?? 0;
         this.cache_creation_input_tokens = opts.cache_creation_input_tokens ?? 0;

package/src/scripts/ai_council/config.ts

@@ -359,6 +359,8 @@ export interface ConsensusScoringConfig {
     readonly strong_threshold: number;
     readonly minority_threshold: number;
     readonly lenses: readonly string[];
+    /** Phase 1B — see `inline_findings.ts`. Default `false` until 1B.4's gate is met. */
+    readonly inline_findings: boolean;
 }
 
 const _VALID_NECESSITY_MODES: ReadonlySet<string> = new Set([
@@ -1462,6 +1464,7 @@ function _build_consensus_scoring(d: Dict): ConsensusScoringConfig {
         strong_threshold: strong,
         minority_threshold: minority,
         lenses: lenses_raw as string[],
+        inline_findings: Boolean(_pyTruthy(_get(d, 'inline_findings', false))),
     };
 }
 

package/src/scripts/ai_council/consensus.ts

@@ -34,9 +34,9 @@ import { pyRound } from '../_lib/value_ladder.js';
 // Python: re.compile(r"```(?:json)?\s*(\[.*?\])\s*```", re.DOTALL)
 // re.DOTALL → 's'. Python regex is not global; a fresh RegExp per call avoids
 // lastIndex carryover, and we use .exec() (first match) below.
-const _JSON_BLOCK_SRC = '```(?:json)?\\s*(\\[[\\s\\S]*?\\])\\s*```';
+export const _JSON_BLOCK_SRC = '```(?:json)?\\s*(\\[[\\s\\S]*?\\])\\s*```';
 // Python: re.compile(r"(\[\s*\{.*?\}\s*\])", re.DOTALL)
-const _BARE_ARRAY_SRC = '(\\[\\s*\\{[\\s\\S]*?\\}\\s*\\])';
+export const _BARE_ARRAY_SRC = '(\\[\\s*\\{[\\s\\S]*?\\}\\s*\\])';
 
 // Defaults mirror the roadmap (Phase 4 Step 4). The .agent-settings.yml
 // block overrides them at run time.
@@ -302,6 +302,22 @@ export type FindingsParseOutcome = 'parsed' | 'empty' | 'parse_failed';
 export interface FindingsExtraction {
     readonly findings: Finding[];
     readonly outcome: FindingsParseOutcome;
+    /**
+     * How many array items the parse SAW, before `_collect_findings` skipped the
+     * ones missing `id` or `text`.
+     *
+     * `outcome: 'parsed'` alone says only "this was a syntactically valid JSON
+     * array". A caller deciding whether the array is a member's own findings
+     * BLOCK — as opposed to some other JSON the member happened to quote —
+     * needs to know whether every item survived. Added 2026-08-30 after a
+     * completion review found the inline-findings short-circuit reading
+     * `'parsed'` as "this is a findings block" and silently deleting quoted
+     * evidence from the text peer review reads.
+     *
+     * 0 for `empty` and `parse_failed`, and 0 for the bare-`[]` branch, whose
+     * item count genuinely is zero.
+     */
+    readonly item_count: number;
 }
 
 /**
@@ -317,7 +333,7 @@ export function parse_findings_outcome(
 ): FindingsExtraction {
     const source = opts.source;
     if (text.trim() === '') {
-        return { findings: [], outcome: 'empty' };
+        return { findings: [], outcome: 'empty', item_count: 0 };
     }
     const array = _extract_json_array(text);
     if (!array) {
@@ -335,20 +351,24 @@ export function parse_findings_outcome(
         // `parse_findings_response` and `parse_scores_response` accept, which is a
         // behaviour change this step did not ask for.
         if (/(^|[\s`])\[\s*\](\s|`|$)/.test(text)) {
-            return { findings: [], outcome: 'parsed' };
+            return { findings: [], outcome: 'parsed', item_count: 0 };
         }
-        return { findings: [], outcome: 'parse_failed' };
+        return { findings: [], outcome: 'parse_failed', item_count: 0 };
     }
     let parsed: unknown;
     try {
         parsed = JSON.parse(array);
     } catch {
-        return { findings: [], outcome: 'parse_failed' };
+        return { findings: [], outcome: 'parse_failed', item_count: 0 };
     }
     if (!Array.isArray(parsed)) {
-        return { findings: [], outcome: 'parse_failed' };
+        return { findings: [], outcome: 'parse_failed', item_count: 0 };
     }
-    return { findings: _collect_findings(parsed, source), outcome: 'parsed' };
+    return {
+        findings: _collect_findings(parsed, source),
+        outcome: 'parsed',
+        item_count: parsed.length,
+    };
 }
 
 export function parse_findings_response(

package/src/scripts/ai_council/consensus_round.ts

@@ -0,0 +1,226 @@
+// The two-pass consensus round.
+//
+// Split out of `orchestrator.ts` in the change that made pass 1 conditional
+// (Phase 1B, inline findings). `orchestrator.ts` sits ~750 lines past the
+// 1500-line source-size ceiling, so the budget gate refuses new lines there —
+// correctly: the fix for a bloated file is not a shorter comment, it is the
+// concern moving out. This is the concern that moved, and it is the one the
+// change actually edits.
+//
+// `orchestrator.ts` re-exports `run_consensus_scoring`, so every existing
+// importer is untouched. The import of `consult` below closes a module cycle
+// with that file; it is call-time, not init-time — nothing here runs at module
+// load — which is the shape ESM resolves without a partial-initialization
+// hazard.
+import type { CouncilResponse, ExternalAIClient } from './clients.js';
+import { DEFAULT_MAX_TOKENS } from './clients.js';
+import type { Finding } from './consensus.js';
+import {
+    ConsensusBucket,
+    FindingScore,
+    aggregate_scores,
+    anonymize_findings,
+    bucket_by_threshold,
+    parse_findings_outcome,
+    parse_scores_response,
+} from './consensus.js';
+import type { RecordedExtractionOutcome } from './inline_findings.js';
+import { takeInlineFindings } from './inline_findings.js';
+import { consult } from './orchestrator.js';
+import type { RunConsensusScoringOptions } from './orchestrator_results.js';
+import { ConsensusResult, CouncilQuestion } from './orchestrator_results.js';
+import { build_extraction_user_prompt, build_scoring_user_prompt } from './prompts.js';
+
+/** Python `str.strip()` parity, as everywhere else in this package. */
+const _pyStrip = (s: string): string => s.replace(/^\s+|\s+$/g, '');
+
+/**
+ * Two-pass consensus round (Phase 4 / F3).
+ *
+ * Pass 1 — extraction: each member re-emits its own deliberation as
+ * a JSON array of `{id, text}` findings. Pass 2 — scoring: each
+ * member sees the *other* members' findings under anonymous labels
+ * and rates them 1-10 + agree/disagree + reason.
+ *
+ * The cost budget is shared across both passes; the daily ledger
+ * receives both. Errors in one member's extraction or scoring tag
+ * that member but never abort the round.
+ */
+export function run_consensus_scoring(
+    members: ExternalAIClient[],
+    deliberation_responses: CouncilResponse[],
+    opts: RunConsensusScoringOptions = {},
+): ConsensusResult {
+    const budget = opts.budget ?? null;
+    const table = opts.table ?? null;
+    const on_overrun = opts.on_overrun ?? null;
+    const project = opts.project ?? null;
+    const original_ask = opts.original_ask ?? '';
+    const max_tokens = opts.max_tokens ?? DEFAULT_MAX_TOKENS;
+    const strong_threshold = opts.strong_threshold ?? 0.7;
+    const minority_threshold = opts.minority_threshold ?? 0.4;
+    const inline_extractions = opts.inline_extractions ?? null;
+
+    if (members.length === 0 || deliberation_responses.length === 0) {
+        return new ConsensusResult({
+            bucket: new ConsensusBucket(),
+            findings: [],
+            scores: [],
+            metadata: new Map(),
+            extraction_responses: [],
+            scoring_responses: [],
+        });
+    }
+
+    // ── Pass 1: extraction ──────────────────────────────────────────
+    const member_by_name = new Map<string, ExternalAIClient>();
+    for (const m of members) {
+        member_by_name.set(m.name, m);
+    }
+    const extraction_responses: CouncilResponse[] = [];
+    const all_findings: Finding[] = [];
+    // Per-member extraction outcome — step 2.2. Recorded rather than derived from the
+    // findings count, because "zero findings" and "could not be read" are different facts
+    // and the count cannot tell them apart. `parsed-after-reask` is kept distinct from
+    // `parsed`: a member that needed a second ask is a signal about the prompt or the
+    // member, and collapsing it into `parsed` would hide the only evidence that the
+    // re-ask is doing anything.
+    const parse_outcomes = new Map<string, RecordedExtractionOutcome>();
+    for (const resp of deliberation_responses) {
+        const member = member_by_name.get(resp.provider);
+        if (member === undefined || resp.error || !_pyStrip(resp.text)) {
+            continue;
+        }
+        const source = `${member.name}:${member.model}`;
+
+        // Phase 1B replaces the second call, it does not delete it: no harvested
+        // block → fall through to the extraction call over untouched text.
+        if (takeInlineFindings(inline_extractions, source, parse_outcomes, all_findings)) {
+            continue;
+        }
+
+        const question = new CouncilQuestion({
+            mode: 'prompt',
+            user_prompt: build_extraction_user_prompt(resp.text),
+            max_tokens,
+        });
+        const extracted = consult([member], question, budget, {
+            table,
+            on_overrun,
+            project,
+            original_ask,
+        });
+        extraction_responses.push(...extracted);
+        if (extracted.length === 0 || extracted[0]!.error) {
+            continue;
+        }
+        let ex = parse_findings_outcome(extracted[0]!.text, { source });
+
+        // Step 2.2 — ONE bounded re-ask on `parse_failed`, and one only.
+        //
+        // A member that said something no parser could read used to be indistinguishable
+        // from a member that found nothing: `parse_findings_response` returned `[]` for
+        // both, and this loop pushed the empty array with no branch. So an unparseable
+        // answer counted as a clean zero-findings review.
+        //
+        // ONE re-ask, not a loop. A re-ask is a paid call, and an unbounded retry turns
+        // one unparseable answer into open-ended spend — the failure mode the N=3
+        // validation budget exists for, reached here by a different road. `empty` is NOT
+        // re-asked: a member that said nothing has nothing to restate, and re-asking it
+        // buys a second silence.
+        if (ex.outcome === 'parse_failed') {
+            const retry_q = new CouncilQuestion({
+                mode: 'prompt',
+                user_prompt:
+                    build_extraction_user_prompt(resp.text) +
+                    '\n\nYour previous answer could not be parsed. Reply with ONLY a JSON ' +
+                    'array of {"id": string, "text": string} objects, no prose before or ' +
+                    'after it. An empty array [] is a valid answer meaning you found nothing.',
+                max_tokens,
+            });
+            const retried = consult([member], retry_q, budget, {
+                table,
+                on_overrun,
+                project,
+                original_ask,
+            });
+            extraction_responses.push(...retried);
+            if (retried.length > 0 && !retried[0]!.error) {
+                ex = parse_findings_outcome(retried[0]!.text, { source });
+            }
+            parse_outcomes.set(source, ex.outcome === 'parsed' ? 'parsed-after-reask' : 'parse_failed');
+        } else {
+            parse_outcomes.set(source, ex.outcome);
+        }
+        all_findings.push(...ex.findings);
+    }
+
+    if (all_findings.length === 0) {
+        return new ConsensusResult({
+            bucket: new ConsensusBucket(),
+            findings: [],
+            scores: [],
+            metadata: new Map(),
+            parse_outcomes,
+            extraction_responses,
+            scoring_responses: [],
+        });
+    }
+
+    // ── Pass 2: scoring (each member rates the OTHERS' findings) ────
+    const scoring_responses: CouncilResponse[] = [];
+    const all_scores: FindingScore[] = [];
+    for (const member of members) {
+        const scorer = `${member.name}:${member.model}`;
+        const others = all_findings.filter((f) => f.source !== scorer);
+        if (others.length === 0) {
+            continue;
+        }
+        const anon = anonymize_findings(others);
+        const label_to_id = new Map<string, string>();
+        const anon_text = new Map<string, string>();
+        for (const [label, f] of anon) {
+            label_to_id.set(label, f.id);
+            anon_text.set(label, f.text);
+        }
+        const question = new CouncilQuestion({
+            mode: 'prompt',
+            user_prompt: build_scoring_user_prompt(anon_text),
+            max_tokens,
+        });
+        const scored = consult([member], question, budget, {
+            table,
+            on_overrun,
+            project,
+            original_ask,
+        });
+        scoring_responses.push(...scored);
+        if (scored.length === 0 || scored[0]!.error) {
+            continue;
+        }
+        for (const s of parse_scores_response(scored[0]!.text, { scorer })) {
+            const real_id = label_to_id.get(s.finding_id);
+            if (real_id === undefined) {
+                continue;
+            }
+            all_scores.push(
+                new FindingScore(real_id, s.scorer, s.score, s.agree, s.reason),
+            );
+        }
+    }
+
+    const metadata = aggregate_scores(all_findings, all_scores);
+    const bucket = bucket_by_threshold(all_findings, metadata, {
+        strong: strong_threshold,
+        minority: minority_threshold,
+    });
+    return new ConsensusResult({
+        bucket,
+        findings: all_findings,
+        scores: all_scores,
+        metadata,
+        parse_outcomes,
+        extraction_responses,
+        scoring_responses,
+    });
+}