@event4u/agent-config 14.11.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/argument_exhaustion.ts

@@ -0,0 +1,130 @@
+/**
+ * The argument-exhaustion stop predicate, with the ordering encoded.
+ *
+ * `road-to-inbox-harvest-2026-08-e-council-topology-evidence` Phase 6.2, and the
+ * resolution of its `early-stop-vs-dissent-ordering` blocker.
+ *
+ * ## The ordering IS the substance
+ *
+ * Anti-conformity repair must fire **before** the cost stop, because
+ * **convergence may be conformity collapse rather than solution stability**. A
+ * round where everyone agrees because nobody pushed back looks, to a cost meter,
+ * exactly like a round where the argument is genuinely finished — and stopping
+ * there reports the collapse as consensus. That is the failure Phase 6 exists to
+ * prevent, so `dissentRepairAttempted` is a **required conjunct of the
+ * predicate**, not a soft check somewhere upstream that the predicate hopes ran.
+ *
+ * Encoding it as a conjunct rather than as call-order discipline is deliberate:
+ * a caller that forgets the order produces a wrong answer silently, while a
+ * caller that forgets to set the field produces `false` — the safe direction,
+ * and a visible one.
+ *
+ * ## Why all four, and why none of them is majority size
+ *
+ * A stop fires only when **every** condition holds:
+ *
+ * 1. `roundsCompleted >= MIN_ROUNDS` — one round is an opening statement, not an
+ *    argument. There is nothing to be exhausted yet.
+ * 2. `dissentRepairAttempted` — the conformity defence got its chance.
+ * 3. every present member is a self-near-duplicate of their own prior round —
+ *    the members have stopped adding, judged by the novelty logic that already
+ *    exists rather than by a new similarity measure.
+ * 4. no unresolved adversarial trigger — an open objection is unfinished
+ *    argument whatever the novelty numbers say.
+ *
+ * **Majority size is absent on purpose** (6.3). Unanimity is the single most
+ * available signal and the single least trustworthy one here: it is exactly what
+ * conformity collapse produces. A predicate that read it would stop soonest in
+ * precisely the case it must not.
+ *
+ * Everything here is pure and reads already-paid outputs — no model call, which
+ * is 6.1's contract and the reason this can be evaluated after every round for
+ * free.
+ */
+
+/** One round is an opening statement; exhaustion needs an exchange. */
+export const MIN_ROUNDS = 2;
+
+export interface StopInputs {
+    /** Rounds completed so far. */
+    roundsCompleted: number;
+    /**
+     * Whether anti-conformity repair ran for the round under judgement.
+     *
+     * The ordering conjunct. `false` when repair was skipped, deferred, or
+     * never reached — all three are the same thing to this predicate, because
+     * all three leave conformity collapse untested.
+     */
+    dissentRepairAttempted: boolean;
+    /**
+     * Per present member: did this round near-duplicate that member's own prior
+     * round? Absent members contribute no entry rather than a `false`.
+     */
+    selfNearDuplicate: readonly boolean[];
+    /** Adversarial triggers raised and not yet resolved. */
+    unresolvedAdversarialTriggers: number;
+}
+
+export type StopBlocker =
+    | 'too-few-rounds'
+    | 'dissent-repair-not-attempted'
+    | 'members-still-adding'
+    | 'unresolved-adversarial-trigger'
+    | 'no-members-present';
+
+export interface StopVerdict {
+    stop: boolean;
+    /** Every condition that failed, not just the first — a caller acting on one
+     *  reason at a time would re-evaluate N times to learn N blockers. */
+    blockers: StopBlocker[];
+}
+
+export function evaluateStop(x: StopInputs): StopVerdict {
+    const blockers: StopBlocker[] = [];
+
+    if (x.roundsCompleted < MIN_ROUNDS) blockers.push('too-few-rounds');
+
+    // The ordering conjunct. Deliberately evaluated as its own condition rather
+    // than folded into a caller-side guard: see the module docstring.
+    if (!x.dissentRepairAttempted) blockers.push('dissent-repair-not-attempted');
+
+    if (x.selfNearDuplicate.length === 0) {
+        // No present member is not "everyone is done" — it is no evidence at
+        // all. `every()` over an empty array is vacuously true, which would
+        // make an empty council the easiest one to stop.
+        blockers.push('no-members-present');
+    } else if (!x.selfNearDuplicate.every((d) => d)) {
+        blockers.push('members-still-adding');
+    }
+
+    if (x.unresolvedAdversarialTriggers > 0) blockers.push('unresolved-adversarial-trigger');
+
+    return { stop: blockers.length === 0, blockers };
+}
+
+/**
+ * The rendering contract for a stopped run (6.4).
+ *
+ * A stopped run must be **textually distinguishable** from a full one. The
+ * failure this prevents is quiet and expensive: an artifact that reads as though
+ * all configured rounds executed, when three of five did, is a claim about
+ * deliberation depth that nobody made on purpose.
+ */
+export interface StopRender {
+    roundsCompleted: number;
+    roundsConfigured: number;
+    savedCalls: number;
+    savedCostUsd: number;
+    exhaustedMembers: readonly string[];
+}
+
+export function renderStop(r: StopRender): string {
+    return [
+        `council: STOPPED EARLY — round ${String(r.roundsCompleted)} of ${String(r.roundsConfigured)}.`,
+        '  reason: argument exhaustion — every present member near-duplicated their own',
+        '          prior round, after anti-conformity repair had already been attempted.',
+        `  exhausted: ${r.exhaustedMembers.length > 0 ? r.exhaustedMembers.join(', ') : '(none named)'}`,
+        `  saved: ${String(r.savedCalls)} call(s), $${r.savedCostUsd.toFixed(4)}`,
+        '  NOT a full run: the remaining configured rounds did not execute.',
+    ].join('\n');
+}

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(