@event4u/agent-config 14.12.0 → 14.14.0

package/src/scripts/activation_receipt.ts

@@ -0,0 +1,258 @@
+#!/usr/bin/env tsx
+/**
+ * `activation_receipt` — observe how far a shipped artefact climbed the
+ * activation ladder, and append the receipt to the audit ledger.
+ *
+ * `road-to-governed-evidence-production` step 1.1's PRODUCTION CALLER. The
+ * producer library (`_lib/activation_receipt_producer.ts`) holds the discipline;
+ * this file holds the three real observations and the write. It exists because
+ * a library nothing calls has no coverage — the same defect the roadmap kept
+ * open on `assertCheapestFirst`. **Corrected 2026-09-01:** that one is now half
+ * closed. `assertCheapestFirst` has two production callers in
+ * `_lib/llm_candidate_proposer.ts` (`:417`, `:446`), so it no longer polices a
+ * population of zero; what it still does not police is a SPENT population,
+ * which is what AC-3 stays open on.
+ *
+ * ## What it observes, and from where
+ *
+ * | Rung | Source | What is read |
+ * |---|---|---|
+ * | `eligible`  | `source-tree`        | the authored artefact under `src/` |
+ * | `selected`  | `discovery-manifest` | `dist/discovery/discovery-manifest.json`, `install.default` |
+ * | `projected` | `host-projection`    | the host tree under `.claude/` |
+ *
+ * `delivered`, `visible` and `adhered` have no admitted source and are therefore
+ * ABSENT from every receipt this writes — which the ladder reads as `unknown`
+ * and keeps out of every rate's denominator. That is the honest state of
+ * coverage today, not a placeholder to be filled with a guess.
+ *
+ * ## Costs and boundaries
+ *
+ * Zero model calls, no network, no subprocess: three `statSync` calls and one
+ * JSON read. Admissible under the `metered-backend-park` blocker, which forbids
+ * a live model harness rather than a filesystem read. Claims:
+ * `docs/contracts/activation-receipt-trust-boundary.md`.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+import {
+    appendActivationLine,
+    buildActivationLine,
+    buildActivationReceipt,
+    observeProjection,
+    observeSelection,
+    observeSourceTree,
+    type RungObservation,
+} from './_lib/activation_receipt_producer.js';
+import { LADDER_RUNGS, firstStall, type ActivationReceipt } from './_lib/activation_ladder.js';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+
+export const EXIT_OK = 0;
+export const EXIT_USAGE = 2;
+
+const USAGE = `usage: activation_receipt --rule <id> | --skill <id> [options]
+
+  --rule ID         a rule artefact, e.g. commit-policy
+  --skill ID        a skill artefact, e.g. code-review
+  --host DIR        host projection root (default: .claude)
+  --root DIR        repository root (default: this checkout)
+  --dry-run         observe and print; do NOT append to the audit ledger
+
+Observes the eligible / selected / projected rungs and appends one
+audit-log-v1 line carrying an \`activation\` object. Zero model calls.
+`;
+
+/** Where the artefact lives, per kind, in each of the two trees. */
+interface ArtefactPaths {
+    readonly id: string;
+    readonly sourceRel: string;
+    readonly hostRel: string;
+}
+
+export function artefactPaths(kind: 'rule' | 'skill', id: string): ArtefactPaths {
+    return kind === 'rule'
+        ? { id, sourceRel: path.join('rules', `${id}.md`), hostRel: path.join('rules', `${id}.md`) }
+        : {
+              id,
+              sourceRel: path.join('skills', id, 'SKILL.md'),
+              hostRel: path.join('skills', id, 'SKILL.md'),
+          };
+}
+
+/**
+ * The ids the discovery manifest admits into the DEFAULT install.
+ *
+ * Returns an EMPTY set when the manifest is missing or unreadable, and
+ * `observeSelection` reads an empty set as "no manifest" rather than as "the
+ * manifest selected nothing" — the absent/negative split again, at the one place
+ * a build artefact can legitimately be missing.
+ */
+export function selectedIdsFromManifest(manifestPath: string): Set<string> {
+    let doc: unknown;
+    try {
+        doc = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    } catch {
+        return new Set();
+    }
+    const artefacts = (doc as { artefacts?: unknown }).artefacts;
+    if (!Array.isArray(artefacts)) return new Set();
+    const out = new Set<string>();
+    for (const a of artefacts) {
+        const rec = a as { path?: unknown; install?: { default?: unknown } };
+        if (typeof rec.path !== 'string') continue;
+        if (rec.install?.default !== true) continue;
+        out.add(artefactIdFromPath(rec.path));
+    }
+    return out;
+}
+
+/**
+ * The artefact id a manifest path names.
+ *
+ * `src/rules/commit-policy.md` -> `commit-policy`;
+ * `src/skills/code-review/SKILL.md` -> `code-review`. Any other path yields its
+ * basename without extension, which is not an id anything will match — a
+ * deliberate non-match rather than a guess.
+ */
+export function artefactIdFromPath(p: string): string {
+    const parts = p.split('/');
+    const last = parts[parts.length - 1] ?? '';
+    if (last === 'SKILL.md') return parts[parts.length - 2] ?? '';
+    return last.replace(/\.md$/, '');
+}
+
+export interface ObserveResult {
+    readonly receipt: ActivationReceipt | null;
+    readonly errors: readonly string[];
+    readonly observations: readonly RungObservation[];
+}
+
+/** The three observations, in ladder order. Pure apart from the reads. */
+export function observeArtefact(
+    root: string,
+    hostRoot: string,
+    kind: 'rule' | 'skill',
+    id: string,
+): ObserveResult {
+    const p = artefactPaths(kind, id);
+    const observations: RungObservation[] = [];
+    const eligible = observeSourceTree(path.join(root, 'src'), p.sourceRel);
+    if (eligible !== undefined) observations.push(eligible);
+    const selected = observeSelection(
+        selectedIdsFromManifest(path.join(root, 'dist', 'discovery', 'discovery-manifest.json')),
+        id,
+    );
+    if (selected !== undefined) observations.push(selected);
+    const projected = observeProjection(hostRoot, p.hostRel);
+    if (projected !== undefined) observations.push(projected);
+
+    const { receipt, errors } = buildActivationReceipt(id, observations);
+    return { receipt, errors, observations };
+}
+
+interface Flags {
+    kind?: 'rule' | 'skill';
+    id?: string;
+    host?: string;
+    root?: string;
+    dryRun: boolean;
+}
+
+function parse(argv: readonly string[]): Flags | string {
+    const f: Flags = { dryRun: false };
+    for (let i = 0; i < argv.length; i += 1) {
+        const a = argv[i];
+        if (a === '--dry-run') {
+            f.dryRun = true;
+            continue;
+        }
+        const v = argv[i + 1];
+        if (v === undefined || v.startsWith('--')) return `${a} requires a value`;
+        i += 1;
+        if (a === '--rule') {
+            f.kind = 'rule';
+            f.id = v;
+        } else if (a === '--skill') {
+            f.kind = 'skill';
+            f.id = v;
+        } else if (a === '--host') {
+            f.host = v;
+        } else if (a === '--root') {
+            f.root = v;
+        } else {
+            return `unknown option '${a}'`;
+        }
+    }
+    return f;
+}
+
+export function main(argv?: string[]): number {
+    const args = argv ?? process.argv.slice(2);
+    if (args.length === 0 || args.includes('-h') || args.includes('--help')) {
+        process.stdout.write(USAGE);
+        return args.length === 0 ? EXIT_USAGE : EXIT_OK;
+    }
+    const parsed = parse(args);
+    if (typeof parsed === 'string') {
+        process.stderr.write(`activation_receipt: error: ${parsed}\n${USAGE}`);
+        return EXIT_USAGE;
+    }
+    if (parsed.kind === undefined || parsed.id === undefined || parsed.id === '') {
+        process.stderr.write(`activation_receipt: error: one of --rule or --skill is required\n${USAGE}`);
+        return EXIT_USAGE;
+    }
+    const root = parsed.root ?? REPO_ROOT;
+    const hostRoot = parsed.host ?? path.join(root, '.claude');
+
+    const { receipt, errors } = observeArtefact(root, hostRoot, parsed.kind, parsed.id);
+    if (receipt === null) {
+        for (const e of errors) process.stderr.write(`activation_receipt: refused — ${e}\n`);
+        return 1;
+    }
+
+    const stall = firstStall(receipt);
+    const observedCount = Object.keys(receipt.rungs).length;
+    process.stdout.write(
+        `activation_receipt · ${receipt.artefact} · observed ${observedCount}/${LADDER_RUNGS.length} rung(s) · ` +
+            (stall === null
+                ? 'climbed every observed rung · family=none\n'
+                : `stalled at ${stall.stage} · family=${stall.family}\n`),
+    );
+
+    const ts = new Date().toISOString();
+    const { line, errors: lineErrors } = buildActivationLine({
+        artefact: receipt.artefact,
+        rungs: receipt.rungs,
+        ts,
+        id: crypto.randomUUID(),
+    });
+    if (line === null) {
+        for (const e of lineErrors) process.stderr.write(`activation_receipt: refused — ${e}\n`);
+        return 1;
+    }
+    if (parsed.dryRun) {
+        process.stdout.write(`${JSON.stringify(line)}\n`);
+        return EXIT_OK;
+    }
+    const file = appendActivationLine(root, line, ts);
+    process.stdout.write(`activation_receipt · appended to ${path.relative(root, file)}\n`);
+    return EXIT_OK;
+}
+
+function _isCliEntry(): boolean {
+    try {
+        if (process.argv[1] === undefined) return false;
+        return fs.realpathSync(_HERE) === fs.realpathSync(path.resolve(process.argv[1]));
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry()) {
+    process.exit(main());
+}

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(