@event4u/agent-config 14.12.0 → 14.13.0

package/src/scripts/config_cost_report.ts

@@ -0,0 +1,302 @@
+#!/usr/bin/env tsx
+/**
+ * `config-cost report` — what does this configuration cost per session
+ * (`road-to-delivered-cost-truth` Phase 1).
+ *
+ * Class A per ADR-124: in-process, per-invocation, no socket, no daemon, no
+ * network, no writes outside a stdout/JSON report. The same class
+ * `cache_realization_report` already occupies, and for the same reason.
+ *
+ * Four figures, and the discipline is the point of each:
+ *
+ *   delivered payload         from the per-asset ledger, exact BPE where it resolves
+ *   billable_input split      fresh input · cache read · cache creation
+ *   cache-read share          `null` when nothing was billed, never 0 %
+ *   payload_amplification     delivered / profile-declared, or `unknown_profile`
+ *
+ * NO CURRENCY, ANYWHERE. The suite does not know the consumer's contract, so a
+ * monetary figure would be extrapolated from a rate it invented — actionable and
+ * wrong, which is worse than absent. `check_no_currency_in_cost_surfaces` gates
+ * it rather than leaving it to intent.
+ *
+ * Usage:
+ *   ./scripts-run src/scripts/config_cost_report [--format text|json]
+ *     [--root <path>] [--profile <name>] [--transcript-root <path>]
+ *     [--max-age-days <n>] [--summary-line]
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { buildLedger } from './_lib/asset_delivery_ledger.js';
+import {
+    amplification,
+    billableSplit,
+    rereadCost,
+    summaryLine,
+    type AmplificationResult,
+    type BillableSplit,
+    type ProfileDeclaration,
+    type RereadCost,
+    type RereadLeg,
+} from './_lib/config_cost.js';
+import { prefixStableDirRoots } from './_lib/prefix_stable_surfaces.js';
+import { DEFAULT_PROJECTS_ROOT, aggregateByBucket, scanTranscripts } from './_lib/cc_transcript.js';
+import { computeRereads } from './_lib/transcript_reads.js';
+import { gpt_tokens } from './_lib/token_count.js';
+
+const HERE = path.dirname(new URL(import.meta.url).pathname);
+const REPO_ROOT = path.resolve(HERE, '..', '..');
+
+export interface Options {
+    format: 'text' | 'json';
+    transcript: string | null;
+    root: string;
+    profile: string | null;
+    transcriptRoot: string;
+    maxAgeDays: number;
+    summaryOnly: boolean;
+}
+
+export function parseArgs(argv: string[]): Options {
+    const o: Options = {
+        format: 'text',
+        transcript: null,
+        root: REPO_ROOT,
+        profile: null,
+        transcriptRoot: DEFAULT_PROJECTS_ROOT,
+        maxAgeDays: 14,
+        summaryOnly: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === undefined) continue;
+        if (a === '--format') o.format = (argv[++i] as Options['format']) ?? o.format;
+        else if (a.startsWith('--format=')) o.format = a.slice('--format='.length) as Options['format'];
+        else if (a === '--root') o.root = path.resolve(argv[++i] ?? o.root);
+        else if (a.startsWith('--root=')) o.root = path.resolve(a.slice('--root='.length));
+        else if (a === '--profile') o.profile = argv[++i] ?? null;
+        else if (a.startsWith('--profile=')) o.profile = a.slice('--profile='.length);
+        else if (a === '--transcript-root') o.transcriptRoot = argv[++i] ?? o.transcriptRoot;
+        else if (a.startsWith('--transcript-root=')) o.transcriptRoot = a.slice('--transcript-root='.length);
+        else if (a === '--max-age-days') o.maxAgeDays = Number(argv[++i]) || o.maxAgeDays;
+        else if (a.startsWith('--max-age-days=')) o.maxAgeDays = Number(a.slice('--max-age-days='.length)) || o.maxAgeDays;
+        else if (a === '--transcript') o.transcript = argv[++i] ?? null;
+        else if (a.startsWith('--transcript=')) o.transcript = a.slice('--transcript='.length);
+        else if (a === '--summary-line') o.summaryOnly = true;
+    }
+    if (o.format !== 'text' && o.format !== 'json') o.format = 'text';
+    return o;
+}
+
+/** Read a profile's declared standing payload. Absent file or key → `null`, never a default. */
+export function readProfileDeclaration(root: string, profile: string): ProfileDeclaration | null {
+    const file = path.join(root, 'src', 'config', 'profiles', `${profile}.ini`);
+    let text: string;
+    try {
+        text = fs.readFileSync(file, 'utf-8');
+    } catch {
+        return null;
+    }
+    const num = (key: string): number | null => {
+        const m = new RegExp(`^${key}\\s*=\\s*([0-9.]+)\\s*$`, 'm').exec(text);
+        if (m === null) return null;
+        const v = Number(m[1]);
+        return Number.isFinite(v) ? v : null;
+    };
+    const rules = num('declared_rules_tokens');
+    const skills = num('declared_skill_catalogue_tokens');
+    const headroom = num('declared_payload_sanity_headroom');
+    if (rules === null || skills === null || headroom === null) return null;
+    return { profile, declared: { rules_tokens: rules, skill_catalogue_tokens: skills }, sanity_headroom: headroom };
+}
+
+/** The active profile, read from the settings cascade. `full` is the shipped default. */
+export function activeProfile(root: string, override: string | null): string {
+    if (override !== null) return override;
+    for (const rel of ['.agent-settings.yml', path.join('agents', 'settings', '.agent-settings.yml')]) {
+        try {
+            const m = /^\s*profile:\s*['"]?([A-Za-z0-9_-]+)/m.exec(fs.readFileSync(path.join(root, rel), 'utf-8'));
+            if (m !== null) return m[1] as string;
+        } catch {
+            /* absent layer — try the next */
+        }
+    }
+    return 'full';
+}
+
+/**
+ * Turn the re-reads `hot_context_hook` already counts into a token figure
+ * (step 1.3).
+ *
+ * The hook notices a repeated read and renders it as an advisory line; nothing
+ * ever priced it, so a re-read was visible and free-looking. The cost is
+ * `duplicate_reads x the file's MEASURED size` — derived, never a constant,
+ * because a constant would rank a re-read of a one-line config beside a re-read
+ * of a 3,000-token rule.
+ *
+ * A file that no longer exists is skipped rather than priced at zero: it was
+ * genuinely read, and a zero would understate the cost while looking measured.
+ */
+export function collectRereadLegs(transcriptPath: string | null, root: string): RereadLeg[] {
+    if (transcriptPath === null) return [];
+    let result;
+    try {
+        result = computeRereads([transcriptPath]);
+    } catch {
+        return [];
+    }
+    const legs: RereadLeg[] = [];
+    for (const f of result.files) {
+        if (f.duplicate_reads <= 0) continue;
+        const rel = path.relative(root, f.file_path);
+        if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) continue;
+        let text: string;
+        try {
+            text = fs.readFileSync(f.file_path, 'utf-8');
+        } catch {
+            continue;
+        }
+        legs.push({
+            file: rel,
+            total_reads: f.total_reads,
+            duplicate_reads: f.duplicate_reads,
+            file_tokens: gpt_tokens(text).tokens,
+        });
+    }
+    legs.sort((a, b) => b.duplicate_reads * b.file_tokens - a.duplicate_reads * a.file_tokens);
+    return legs;
+}
+
+export interface CostReport {
+    schema: 'config-cost-report/v1';
+    profile: string;
+    delivered: { total_tokens: number; rules_tokens: number; skill_catalogue_tokens: number; exact_throughout: boolean };
+    /** `null` with a stated reason when the transcript ledger carries nothing. */
+    billable: BillableSplit | null;
+    billable_reason: string | null;
+    amplification: AmplificationResult;
+    reread: RereadCost;
+    summary_line: string;
+}
+
+export function buildReport(o: Options, legsOverride?: readonly RereadLeg[]): CostReport {
+    const legs = legsOverride ?? collectRereadLegs(o.transcript, o.root);
+    const [rulesRel, skillsRel] = prefixStableDirRoots();
+    const ledger = buildLedger(
+        path.join(o.root, rulesRel ?? 'dist/agent-src/rules'),
+        path.join(o.root, skillsRel ?? 'dist/agent-src/skills'),
+        o.root,
+    );
+    const measured = {
+        rules_tokens: ledger.by_kind.rule.tokens,
+        skill_catalogue_tokens: ledger.by_kind['skill-catalogue-line'].tokens,
+    };
+
+    let billable: BillableSplit | null = null;
+    let billableReason: string | null = null;
+    try {
+        const scan = scanTranscripts({ root: o.transcriptRoot, maxAgeDays: o.maxAgeDays });
+        const buckets = aggregateByBucket(scan.records);
+        const fresh = buckets.main.input_tokens + buckets.subagent.input_tokens;
+        const read = buckets.main.cache_read_input_tokens + buckets.subagent.cache_read_input_tokens;
+        const creation = buckets.main.cache_creation_input_tokens + buckets.subagent.cache_creation_input_tokens;
+        if (fresh + read + creation === 0) {
+            billableReason = `no billable input recorded under ${o.transcriptRoot} in the last ${String(o.maxAgeDays)} day(s)`;
+        } else {
+            billable = billableSplit(fresh, read, creation);
+        }
+    } catch (err) {
+        billableReason = `the transcript ledger at ${o.transcriptRoot} could not be read: ${(err as Error).message}`;
+    }
+
+    const profile = activeProfile(o.root, o.profile);
+    return {
+        schema: 'config-cost-report/v1',
+        profile,
+        delivered: {
+            total_tokens: ledger.total_tokens,
+            rules_tokens: measured.rules_tokens,
+            skill_catalogue_tokens: measured.skill_catalogue_tokens,
+            exact_throughout: ledger.exact_throughout,
+        },
+        billable,
+        billable_reason: billableReason,
+        amplification: amplification(ledger.total_tokens, measured, readProfileDeclaration(o.root, profile)),
+        reread: rereadCost(legs),
+        summary_line: summaryLine(ledger.total_tokens, billable),
+    };
+}
+
+export function renderText(r: CostReport): string {
+    const out: string[] = [];
+    const n = (v: number): string => String(v);
+    out.push('Config-cost report — what this configuration costs per session');
+    out.push(`  profile: ${r.profile}`);
+    out.push(
+        `  delivered standing payload: ${n(r.delivered.total_tokens)} tok ` +
+            `(rules ${n(r.delivered.rules_tokens)} · skill catalogue ${n(r.delivered.skill_catalogue_tokens)})` +
+            `${r.delivered.exact_throughout ? '' : ' — MIXED measurement, some rows fell back to the chars/4 proxy'}`,
+    );
+    out.push('');
+    out.push('billable_input = fresh input + cache read + cache creation');
+    if (r.billable === null) {
+        out.push(`  unavailable — ${r.billable_reason ?? 'no reason recorded'}`);
+        out.push('  (a stated reason, never zeros standing in for absence)');
+    } else {
+        const b = r.billable;
+        out.push(`  fresh input:    ${n(b.fresh_input_tokens)} tok`);
+        out.push(`  cache read:     ${n(b.cache_read_tokens)} tok`);
+        out.push(`  cache creation: ${n(b.cache_creation_tokens)} tok`);
+        out.push(`  billable total: ${n(b.billable_input_tokens)} tok`);
+        out.push(
+            `  cache-read share: ${b.cache_read_share === null ? 'unavailable (nothing was billed)' : `${(b.cache_read_share * 100).toFixed(1)}%`}`,
+        );
+    }
+    out.push('');
+    out.push('payload amplification (delivered ÷ profile-declared)');
+    out.push(`  verdict: ${r.amplification.verdict}`);
+    out.push(`  ratio:   ${r.amplification.ratio === null ? 'not computed' : r.amplification.ratio.toFixed(2)}`);
+    out.push(`  ${r.amplification.reason}`);
+    out.push('');
+    out.push('  This measures AMPLIFICATION, not net value. It never observes what the payload');
+    out.push('  returned, so it informs the question of whether the configuration earns its cost');
+    out.push('  and is not allowed to answer it.');
+    if (r.reread.legs.length > 0) {
+        out.push('');
+        out.push('re-read cost (content paid for twice)');
+        out.push(`  wasted: ${n(r.reread.wasted_tokens)} tok across ${n(r.reread.legs.length)} file(s)`);
+        if (r.reread.worst_file !== null) out.push(`  worst:  ${r.reread.worst_file}`);
+    }
+    out.push('');
+    out.push(r.summary_line);
+    return out.join('\n') + '\n';
+}
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+    const o = parseArgs(argv);
+    let report: CostReport;
+    try {
+        report = buildReport(o);
+    } catch (err) {
+        process.stderr.write(`❌  config_cost_report: ${(err as Error).message}\n`);
+        return 2;
+    }
+    if (report.delivered.total_tokens === 0) {
+        process.stderr.write(
+            '❌  config_cost_report: no standing asset measured. The rule and skill trees are\n' +
+                '    generated (`task sync && task generate-tools`); a checkout that has not run them\n' +
+                '    has no payload to price. Stated, not reported as a cost of zero.\n',
+        );
+        return 2;
+    }
+    if (o.summaryOnly) {
+        process.stdout.write(report.summary_line + '\n');
+        return 0;
+    }
+    process.stdout.write(o.format === 'json' ? JSON.stringify(report, null, 2) + '\n' : renderText(report));
+    return 0;
+}
+
+if (process.argv[1] !== undefined && import.meta.url === `file://${process.argv[1]}`) {
+    process.exit(main());
+}

package/src/scripts/consumer_matrix.ts

@@ -344,7 +344,80 @@ interface MissingModule {
  * deliberately ignores bare package specifiers (`from 'commander'`) so the
  * walk never leaves the package's own `dist/` tree.
  */
-export function parseRelativeSpecifiers(source: string): string[] {
+/**
+ * Strip comments before scanning for import specifiers.
+ *
+ * A doc comment can contain a perfectly well-formed `export { X } from './X'`
+ * as an EXAMPLE, and the scanner had no way to tell one from a real import —
+ * `src/cli/commands/uiAudit.ts` carries exactly that line, and the built output
+ * keeps it, so the gate reported `commands/uiAudit.js → missing ./X` for a
+ * module nobody imports. That is a false red on a completeness gate, which is
+ * the worst kind: it says the shipped tarball is broken when it is not.
+ *
+ * ## Why the string state resets at every newline
+ *
+ * The first version carried quote state across the whole file, and it did not
+ * survive contact with that very comment: prose says `module's body`, and an
+ * apostrophe inside a comment is only inert while the lexer KNOWS it is inside
+ * one. One desync — a regex literal, an unpaired apostrophe reached in the
+ * wrong mode — and every subsequent `/*` reads as string content, so the doc
+ * comment is scanned as code and the false red survives the fix. Measured: the
+ * fix shipped, CI stayed red on the identical message.
+ *
+ * So block-comment state is tracked ACROSS lines (a block comment is the thing
+ * being removed) while quote state is tracked WITHIN one line and discarded at
+ * the newline. A desync then costs the remainder of one line instead of the
+ * remainder of the file. A multi-line template literal containing a relative
+ * specifier would be read as code — a false red, the same direction the gate
+ * already errs, and no such literal exists in the compiled output this walks.
+ */
+export function stripComments(source: string): string {
+    const out: string[] = [];
+    let inBlock = false;
+    for (const rawLine of source.split('\n')) {
+        let line = '';
+        let i = 0;
+        let quote: string | null = null;
+        while (i < rawLine.length) {
+            const c = rawLine[i] as string;
+            const next = rawLine[i + 1];
+            if (inBlock) {
+                if (c === '*' && next === '/') {
+                    inBlock = false;
+                    i += 2;
+                    continue;
+                }
+                i += 1;
+                continue;
+            }
+            if (quote !== null) {
+                line += c;
+                if (c === '\\' && next !== undefined) {
+                    line += next;
+                    i += 2;
+                    continue;
+                }
+                if (c === quote) quote = null;
+                i += 1;
+                continue;
+            }
+            if (c === '/' && next === '/') break;
+            if (c === '/' && next === '*') {
+                inBlock = true;
+                i += 2;
+                continue;
+            }
+            if (c === "'" || c === '"' || c === '`') quote = c;
+            line += c;
+            i += 1;
+        }
+        out.push(line);
+    }
+    return out.join('\n');
+}
+
+export function parseRelativeSpecifiers(rawSource: string): string[] {
+    const source = stripComments(rawSource);
     const out = new Set<string>();
     const patterns = [
         /\bfrom\s*["']([^"']+)["']/g,

package/src/scripts/cost/budget.mjs

@@ -2,9 +2,16 @@
 // cost-budget — set / get / check the project's cost budget against
 // accumulated session spend in agents/cost-tracking/sessions.jsonl.
 //
-// Forked from ruvnet/ruflo plugins/ruflo-cost-tracker/scripts/budget.mjs.
-// Local-JSONL swap replaces the upstream `mcp__claude-flow__memory_store`
-// dependency. Budget config lives next to the sessions store as budget.json.
+// Derived work. The upstream, its MIT terms and the reproduced copyright and
+// permission notice are in CREDITS.md; the transformation record is in
+// docs/THIRD-PARTY-NOTICES.md, generated from provenance/borrows.jsonl. The
+// first two ship with the package, which is what discharges the obligation for
+// a consumer who receives this file from npm. The source is not named here
+// because a source name in a tracked source file is what
+// `source-confidentiality` forbids, and MIT discharges through a distributed
+// notice rather than an in-file one.
+// Local-JSONL swap replaces the upstream MCP memory-store dependency. Budget
+// config lives next to the sessions store as budget.json.
 //
 // Usage: node scripts/cost/budget.mjs {set <usd>|get|check}
 // Env: BUDGET_STORE, BUDGET_CONFIG, BUDGET_PERIOD={today|week|month|all}, BUDGET_QUIET=1

package/src/scripts/cost/track.mjs

@@ -2,9 +2,16 @@
 // cost-track — auto-capture token usage from a Claude Code session jsonl
 // and append a structured record to agents/cost-tracking/sessions.jsonl.
 //
-// Forked from ruvnet/ruflo plugins/ruflo-cost-tracker/scripts/track.mjs.
-// Local-JSONL swap replaces the upstream `mcp__claude-flow__memory_store`
-// dependency. Pricing constants are kept in sync with REFERENCE.md.
+// Derived work. The upstream, its MIT terms and the reproduced copyright and
+// permission notice are in CREDITS.md; the transformation record is in
+// docs/THIRD-PARTY-NOTICES.md, generated from provenance/borrows.jsonl. The
+// first two ship with the package, which is what discharges the obligation for
+// a consumer who receives this file from npm. The source is not named here
+// because a source name in a tracked source file is what
+// `source-confidentiality` forbids, and MIT discharges through a distributed
+// notice rather than an in-file one.
+// Local-JSONL swap replaces the upstream MCP memory-store dependency. Pricing
+// constants are kept in sync with REFERENCE.md.
 //
 // Dedup + main/subagent split, and the logic driving them, are mirrored
 // (not imported) from `src/scripts/_lib/cc_transcript.ts`: this file ships

package/src/scripts/council_cli.ts

@@ -26,6 +26,7 @@ import {
     bundle_roadmap,
 } from './ai_council/bundler.js';
 import { select_chairman } from './ai_council/chairman.js';
+import { warnIfRecounciled } from './ai_council/recouncil_guard.js';
 import { jaccardSimilarity } from './_lib/text_similarity.js';
 import type { ChairmanCandidate } from './ai_council/chairman.js';
 import { synthesis_template } from './ai_council/prompts.js';
@@ -137,19 +138,23 @@ import {
     run_debate,
     run_peer_review,
 } from './ai_council/orchestrator.js';
+import { serializeResponses } from './ai_council/response_record.js';
 import {
     type PriceTable,
     downgrade_coupling,
-    estimate_cost,
+    allSeatsNonBillable,
     estimate_input_tokens,
     load_prices,
     prices_file_for,
+    sumBillableCost,
 } from './ai_council/pricing.js';
 import { detect_project_context } from './ai_council/project_context.js';
 import {
     DecisionReplayInputs,
     render_decision_replay,
 } from './ai_council/replay.js';
+import type { FindingsExtraction } from './ai_council/consensus.js';
+import { harvest_inline_findings, inlineFindingsActive } from './ai_council/inline_findings.js';
 import {
     Finding as ConsensusFinding,
     FindingScore as ConsensusFindingScore,
@@ -471,8 +476,6 @@ function load_settings(
     return settings;
 }
 
-
-
 // ── member construction ─────────────────────────────────────────────
 
 interface BuildMembersOptions {
@@ -1186,6 +1189,7 @@ function _maybe_run_consensus(
     table: PriceTable,
     project: unknown,
     args: Args,
+    inline_extractions: ReadonlyMap<string, FindingsExtraction> | null = null,
 ): ConsensusResult | null {
     const cs = (ai_cfg['consensus_scoring'] as Dict) || {};
     if (!_pyBool(cs['enabled'])) {
@@ -1196,6 +1200,7 @@ function _maybe_run_consensus(
         return null;
     }
     return run_consensus_scoring(members, responses, {
+        inline_extractions,
         budget,
         table,
         project: project as never,
@@ -1230,8 +1235,8 @@ function _serialise_consensus(consensus: ConsensusResult): Dict {
             reason: s.reason,
         })),
         metadata,
-        extraction_responses: _serialise_responses(consensus.extraction_responses),
-        scoring_responses: _serialise_responses(consensus.scoring_responses),
+        extraction_responses: serializeResponses(consensus.extraction_responses),
+        scoring_responses: serializeResponses(consensus.scoring_responses),
     };
 }
 
@@ -1478,7 +1483,7 @@ function _maybe_run_peer_review(
 
 function _serialise_peer_review(peer_review: PeerReviewResult): Dict {
     return {
-        responses: _serialise_responses(peer_review.responses),
+        responses: serializeResponses(peer_review.responses),
         label_to_source: _mapToObject(peer_review.label_to_source),
         persona_labels: _mapToObject(peer_review.persona_labels),
     };
@@ -1773,28 +1778,6 @@ function _emit_debate_estimate(
     return 0;
 }
 
-function _serialise_responses(responses: CouncilResponse[]): Dict[] {
-    const out: Dict[] = [];
-    for (const r of responses) {
-        const metadata: Dict = {};
-        for (const [k, v] of Object.entries(r.metadata || {})) {
-            metadata[k] = String(v);
-        }
-        out.push({
-            provider: r.provider,
-            model: r.model,
-            text: r.text,
-            input_tokens: r.input_tokens,
-            output_tokens: r.output_tokens,
-            cache_creation_input_tokens: r.cache_creation_input_tokens,
-            cache_read_input_tokens: r.cache_read_input_tokens,
-            latency_ms: r.latency_ms,
-            error: r.error,
-            metadata,
-        });
-    }
-    return out;
-}
 
 function _deserialise_responses(items: Dict[]): CouncilResponse[] {
     const out: CouncilResponse[] = [];
@@ -2503,6 +2486,7 @@ function cmd_run(
     const [extra_calls, extra_usd] = _consensus_cost_delta(ai_cfg, question.mode, estimates, billable.length);
     const [ch_calls, ch_usd] = _chairman_cost_delta(ai_cfg, estimates);
     const [pr_extra_calls, pr_extra_usd] = _peer_review_cost_delta(ai_cfg, args, estimates, billable.length);
+    warnIfRecounciled(REPO_ROOT, artefact, question.user_prompt, members, _resolve_rounds(args, ai_cfg), _stdout);
     if (!args.confirm) _stdout('council:run · DRY PASS — estimate only, no seat is contacted. Add --confirm to run.\n');
     _stdout(
         `council:run · mode=${question.mode} · members=${members.length} ` +
@@ -2623,6 +2607,9 @@ function cmd_run(
         rounds,
         advisor_plans,
         stance_tally: stance_tally_on,
+        // Phase 1B — the same predicate the harvest below reads, so a member is asked
+        // for the block exactly when the consensus round intends to read one.
+        inline_findings: inlineFindingsActive(ai_cfg, question.mode),
         member_prompt_suffix,
         no_project_context_members,
         // Mid-flight cli→api fallback (ai-council-config.md § failure-class-
@@ -2706,6 +2693,9 @@ function cmd_run(
     // this is always additive, never a fabricated decision.
     const handoff: HandoffEnvelope = buildHandoffFromStanceTally(stance_tally_result);
     const persona_labels = build_persona_labels(advisor_plans, billable);
+    // Phase 1B — BEFORE peer review, chairman synthesis and rendering read
+    // `responses`; the block is scaffolding, not argument. Off → null, nothing touched.
+    const inline_extractions = inlineFindingsActive(ai_cfg, question.mode) ? harvest_inline_findings(members, responses) : null;
     const peer_review = _maybe_run_peer_review(
         ai_cfg,
         args,
@@ -2717,7 +2707,7 @@ function cmd_run(
         project,
         { persona_labels },
     );
-    const consensus = _maybe_run_consensus(ai_cfg, question, members, responses, budget, table, project, args);
+    const consensus = _maybe_run_consensus(ai_cfg, question, members, responses, budget, table, project, args, inline_extractions);
     // Rendered attendance, re-derived after the parser. The event does not move.
     quorum_out.result = annotateRenderedQuorum(quorum_out.result, consensus?.parse_outcomes);
     const chairman = _maybe_run_chairman(
@@ -2761,13 +2751,10 @@ function cmd_run(
         all_responses.push(chairman.response);
     }
     all_responses.push(...stance_repairs);
-    for (const r of all_responses) {
-        if (r.error) {
-            continue;
-        }
-        const ce = estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, table);
-        actual_total += ce.input_usd + ce.output_usd;
-    }
+    // Billable-aware: a subscription-CLI seat spent nothing, so pricing it at
+    // API rates and calling the figure "actual" is a false statement about
+    // money. See pricing.ts § billable-aware aggregation.
+    actual_total += sumBillableCost(all_responses, table);
     const payload: Dict = {
         schema_version: SCHEMA_VERSION,
         mode: question.mode,
@@ -2784,7 +2771,7 @@ function cmd_run(
         stances: stances_on,
         blind_chairman: blind_chairman_on,
         chairman_fields: chairman_fields_on,
-        responses: _serialise_responses(responses),
+        responses: serializeResponses(responses),
     };
     if (peer_review !== null) {
         payload['peer_review'] = _serialise_peer_review(peer_review);
@@ -2819,9 +2806,16 @@ function cmd_run(
     });
     fs.mkdirSync(path.dirname(_resolveTarget(out_path)), { recursive: true });
     fs.writeFileSync(_resolveTarget(out_path), _jsonDumpsIndent2(payload) + '\n', { encoding: 'utf-8' });
+    // The trailing note is not decoration. Before 2026-08-27 this line read
+    // `actual $0.1055` on a run whose every seat was subscription-authed, two
+    // lines below a `TOTAL: $0.0000` from the pre-run path — and an operator
+    // reading the tail of the output saw only the wrong one. When every seat is
+    // non-billable the figure is now 0 and says why, so the two lines agree.
+    const _all_subscription = allSeatsNonBillable(all_responses);
     _stdout(
         `\ncouncil:run · wrote ${out_path} ` +
-            `(estimated $${_pyFixed(estimated_total, 4)} / actual $${_pyFixed(actual_total, 4)})\n`,
+            `(estimated $${_pyFixed(estimated_total, 4)} / spent $${_pyFixed(actual_total, 4)}` +
+            `${_all_subscription ? ' — all seats subscription-authed, nothing billed' : ''})\n`,
     );
     const replay_path = _maybe_write_decision_replay({
         ai_cfg,
@@ -2863,14 +2857,9 @@ function _write_debate_round(
     },
 ): string {
     fs.mkdirSync(_resolveTarget(out_dir), { recursive: true });
-    let actual_total = 0.0;
-    for (const r of responses) {
-        if (r.error) {
-            continue;
-        }
-        const ce = estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, opts.table);
-        actual_total += ce.input_usd + ce.output_usd;
-    }
+    // Billable-aware, same reason as the sibling site above: a subscription
+    // seat contributes nothing to `cost_usd_actual`.
+    const actual_total = sumBillableCost(responses, opts.table);
     const payload: Dict = {
         schema_version: SCHEMA_VERSION,
         mode: opts.question.mode,
@@ -2884,7 +2873,7 @@ function _write_debate_round(
         rounds: 1,
         cost_usd_actual: _pyRound(actual_total, 6),
         prompt_cache_round_gap_ms: opts.cache_gap_ms_since_previous_round ?? null,
-        responses: _serialise_responses(responses),
+        responses: serializeResponses(responses),
     };
     const out_path = path.join(_resolveTarget(out_dir), _debate_round_filename(round_number));
     fs.writeFileSync(out_path, _jsonDumpsIndent2(payload) + '\n', { encoding: 'utf-8' });
@@ -3220,13 +3209,7 @@ function cmd_debate(
 
     let actual_total = 0.0;
     for (const rnd of [...all_rounds, restate_responses]) {
-        for (const r of rnd) {
-            if (r.error) {
-                continue;
-            }
-            const ce = estimate_cost(r.provider, r.model, r.input_tokens, r.output_tokens, table);
-            actual_total += ce.input_usd + ce.output_usd;
-        }
+        actual_total += sumBillableCost(rnd, table);
     }
     _stdout(
         `\ncouncil:debate · ${all_rounds.length} round(s) complete · ` +