@event4u/agent-config 9.9.0 → 9.10.0

package/src/scripts/_lib/anchor_eval.ts

@@ -0,0 +1,311 @@
+/**
+ * Constrained anchor evaluation with frozen verdicts (ADR-202, amended).
+ *
+ * ADR-202 originally called this "deterministic anchor-scoring against
+ * must_include / must_not" and claimed the scorer is "a pure function of
+ * (answer, anchors)". Measured against the corpus that claim is FALSE: 0 of 255
+ * `must_include` anchors carry a literal token or code span, and 17% are
+ * behavioural predicates ("mentions that UI redesign is outside scope"). A
+ * substring match over those measures nothing.
+ *
+ * What is deterministic is everything BELOW the verdict: aggregation, the
+ * per-rule floor, the non-inferiority arithmetic, κ, and the conservative
+ * disagreement resolution — all pure functions over frozen verdicts, all unit
+ * tested here without an API. The verdict itself is a constrained binary
+ * classification per (answer, anchor) by two independent evaluator models. That
+ * is far narrower than the pairwise preference judging which closed by
+ * diagnosis, and — the point — it restores a MEASURABLE κ, whose absence is the
+ * exact reason a single human judge was ruled inadmissible.
+ *
+ * Reproducibility comes from freezing, not from pinning: generate once, freeze
+ * the transcripts AND the verdicts as artefacts, and re-score over the frozen
+ * corpus. A re-generation is a new experiment, never a re-run of this one.
+ */
+
+export type AnchorKind = 'must_include' | 'must_not';
+export type Arm = 'thin' | 'eager';
+
+/** One evaluator's call on one anchor. `true` = satisfied (include) / violated (not). */
+export interface AnchorVerdict {
+    task_id: string;
+    arm: Arm;
+    kind: AnchorKind;
+    /** Index into the task's anchor list for that kind — stable across evaluators. */
+    index: number;
+    anchor: string;
+    hit: boolean;
+}
+
+/** Build the evaluator prompt for one (task, arm): every anchor in one call. */
+export function eval_prompt(
+    prompt: string,
+    answer: string,
+    must_include: readonly string[],
+    must_not: readonly string[],
+): string {
+    const lines: string[] = [
+        'You are grading ONE answer against a fixed checklist. For each checklist',
+        'item, decide only whether the answer satisfies it. Judge the answer on its',
+        'own — do not compare it to anything, do not reward or penalise length, and',
+        'do not grade style.',
+        '',
+        '## The request the answer responds to',
+        '',
+        prompt,
+        '',
+        '## The answer',
+        '',
+        answer,
+        '',
+        '## Checklist',
+        '',
+    ];
+    must_include.forEach((a, i) => lines.push(`I${i}. MUST BE PRESENT: ${a}`));
+    must_not.forEach((a, i) => lines.push(`N${i}. MUST BE ABSENT: ${a}`));
+    lines.push(
+        '',
+        '## Output format — structured, one object per checklist item',
+        '',
+        'Output a JSON array and NOTHING else. Exactly one object per checklist',
+        'item, in the order listed, using the item id as `anchor_id`:',
+        '',
+        '  [{"anchor_id":"I0","verdict":"yes"},{"anchor_id":"N0","verdict":"no"}]',
+        '',
+        '`verdict` is "yes" or "no".',
+        '  For I items: "yes" = the answer satisfies it.',
+        '  For N items: "yes" = the answer DOES the forbidden thing.',
+        '',
+        `Every one of the ${must_include.length + must_not.length} items must appear. No prose, no markdown fence.`,
+    );
+    return lines.join('\n');
+}
+
+/**
+ * Parse an evaluator reply into verdicts. Unparseable or missing items are
+ * returned as `null` so the caller resolves them conservatively rather than
+ * silently scoring them as passes.
+ */
+export function parse_eval(
+    reply: string,
+    must_include_len: number,
+    must_not_len: number,
+): { include: Array<boolean | null>; not: Array<boolean | null>; complete: boolean } {
+    const include: Array<boolean | null> = new Array(must_include_len).fill(null);
+    const not: Array<boolean | null> = new Array(must_not_len).fill(null);
+
+    const put = (tag: string, idx: number, val: boolean): void => {
+        if (tag === 'I') {
+            if (idx < include.length) include[idx] = val;
+        } else if (idx < not.length) not[idx] = val;
+    };
+
+    // Primary: structured objects. Tolerates a surrounding array, a fence, or
+    // one object per line — the shape matters, the packaging does not.
+    const obj = /\{\s*"anchor_id"\s*:\s*"([IN])(\d+)"\s*,\s*"verdict"\s*:\s*"(yes|no)"\s*\}/gi;
+    let m: RegExpExecArray | null;
+    let structured = 0;
+    while ((m = obj.exec(reply)) !== null) {
+        put(m[1]!.toUpperCase(), Number(m[2]), m[3]!.toLowerCase() === 'yes');
+        structured += 1;
+    }
+
+    // Fallback: the flat `I0=yes` form, so a model that ignores the JSON
+    // instruction is still read rather than silently scored as unfavourable.
+    if (structured === 0) {
+        const flat = /\b([IN])(\d+)\s*=\s*(yes|no)\b/gi;
+        while ((m = flat.exec(reply)) !== null) {
+            put(m[1]!.toUpperCase(), Number(m[2]), m[3]!.toLowerCase() === 'yes');
+        }
+    }
+
+    const complete = include.every((v) => v !== null) && not.every((v) => v !== null);
+    return { include, not, complete };
+}
+
+/**
+ * One evaluator call, with exactly one retry when the reply is incomplete or
+ * unparseable (attempt-2 mechanical change). A persistent failure is NOT retried
+ * further and NOT excluded — its `null`s flow into `resolve`, which reads them
+ * as the unfavourable verdict. A model that cannot answer must not be able to
+ * make a corpus look cleaner by staying silent.
+ */
+export function eval_with_retry(
+    ask: (user: string) => string,
+    prompt: string,
+    must_include_len: number,
+    must_not_len: number,
+): { include: Array<boolean | null>; not: Array<boolean | null>; complete: boolean; retried: boolean } {
+    const first = parse_eval(ask(prompt), must_include_len, must_not_len);
+    if (first.complete) return { ...first, retried: false };
+    const second = parse_eval(ask(prompt), must_include_len, must_not_len);
+    return { ...second, retried: true };
+}
+
+/**
+ * Resolve two evaluators conservatively (ADR-202 (c)): a `must_include` counts
+ * only when BOTH say satisfied; a `must_not` counts as violated when EITHER says
+ * violated. `null` (unparsed) is treated as the unfavourable reading, so a
+ * malformed reply can never become a pass.
+ */
+export function resolve(kind: AnchorKind, a: boolean | null, b: boolean | null): boolean {
+    if (kind === 'must_include') return a === true && b === true;
+    return a === true || b === true || a === null || b === null;
+}
+
+export interface TaskAnchors {
+    id: string;
+    rules: readonly string[];
+    must_include: readonly string[];
+    must_not: readonly string[];
+}
+
+export interface ScoreInput {
+    tasks: readonly TaskAnchors[];
+    /** Resolved verdicts, keyed `${task_id}|${arm}|${kind}|${index}` → hit. */
+    resolved: ReadonlyMap<string, boolean>;
+}
+
+export interface ArmScore {
+    include_pass: number;
+    include_total: number;
+    /** include_pass / include_total */
+    rate: number;
+    must_not_violations: Array<{ task_id: string; anchor: string }>;
+}
+
+export function key(task_id: string, arm: Arm, kind: AnchorKind, index: number): string {
+    return `${task_id}|${arm}|${kind}|${index}`;
+}
+
+export function score_arm(input: ScoreInput, arm: Arm): ArmScore {
+    let pass = 0;
+    let total = 0;
+    const violations: Array<{ task_id: string; anchor: string }> = [];
+    for (const t of input.tasks) {
+        t.must_include.forEach((_, i) => {
+            total += 1;
+            if (input.resolved.get(key(t.id, arm, 'must_include', i)) === true) pass += 1;
+        });
+        t.must_not.forEach((anchor, i) => {
+            if (input.resolved.get(key(t.id, arm, 'must_not', i)) === true) {
+                violations.push({ task_id: t.id, anchor });
+            }
+        });
+    }
+    return {
+        include_pass: pass,
+        include_total: total,
+        rate: total === 0 ? 0 : pass / total,
+        must_not_violations: violations,
+    };
+}
+
+/** Per-rule include-pass counts, for the registered floor. */
+export function per_rule_passes(input: ScoreInput, arm: Arm): Map<string, number> {
+    const out = new Map<string, number>();
+    for (const t of input.tasks) {
+        let n = 0;
+        t.must_include.forEach((_, i) => {
+            if (input.resolved.get(key(t.id, arm, 'must_include', i)) === true) n += 1;
+        });
+        for (const r of t.rules) out.set(r, (out.get(r) ?? 0) + n);
+    }
+    return out;
+}
+
+/**
+ * δ proposal from the observed spread: the standard deviation of the per-task
+ * `must_include` pass-rate difference (thin − eager), in percentage points.
+ * Derived from the FROZEN corpus and recorded before scoring — a property of the
+ * corpus, never of the verdict.
+ */
+export function delta_from_spread(input: ScoreInput): number {
+    const diffs: number[] = [];
+    for (const t of input.tasks) {
+        if (t.must_include.length === 0) continue;
+        let thin = 0;
+        let eager = 0;
+        t.must_include.forEach((_, i) => {
+            if (input.resolved.get(key(t.id, 'thin', 'must_include', i)) === true) thin += 1;
+            if (input.resolved.get(key(t.id, 'eager', 'must_include', i)) === true) eager += 1;
+        });
+        diffs.push((thin - eager) / t.must_include.length);
+    }
+    if (diffs.length === 0) return 0;
+    const mean = diffs.reduce((a, b) => a + b, 0) / diffs.length;
+    const varr = diffs.reduce((a, b) => a + (b - mean) ** 2, 0) / diffs.length;
+    return Math.sqrt(varr) * 100;
+}
+
+export interface Verdict {
+    kappa: number;
+    kappa_floor: number;
+    instrument_ok: boolean;
+    delta_pp: number;
+    delta_ceiling_pp: number;
+    delta_registered: boolean;
+    thin: ArmScore;
+    eager: ArmScore;
+    /** rate_thin − rate_eager, percentage points. */
+    rate_gap_pp: number;
+    must_not_ok: boolean;
+    non_inferiority_ok: boolean;
+    per_rule_floor_ok: boolean;
+    per_rule_floor_breaches: string[];
+    pass: boolean;
+}
+
+export interface VerdictOptions {
+    kappa: number;
+    kappa_floor?: number;
+    delta_ceiling_pp?: number;
+}
+
+/** Apply every registered threshold. Pure — the whole decision, no I/O. */
+export function verdict(input: ScoreInput, opts: VerdictOptions): Verdict {
+    const kappa_floor = opts.kappa_floor ?? 0.8;
+    const delta_ceiling_pp = opts.delta_ceiling_pp ?? 3;
+    const thin = score_arm(input, 'thin');
+    const eager = score_arm(input, 'eager');
+    const delta_pp = delta_from_spread(input);
+    const delta_registered = delta_pp <= delta_ceiling_pp;
+    const rate_gap_pp = (thin.rate - eager.rate) * 100;
+
+    // Registered: thin introduces NO must_not violation that eager avoids.
+    const eagerViolated = new Set(eager.must_not_violations.map((v) => `${v.task_id}|${v.anchor}`));
+    const introduced = thin.must_not_violations.filter((v) => !eagerViolated.has(`${v.task_id}|${v.anchor}`));
+    const must_not_ok = introduced.length === 0;
+
+    const effective_delta = Math.min(delta_pp, delta_ceiling_pp);
+    const non_inferiority_ok = rate_gap_pp >= -effective_delta;
+
+    const thinRule = per_rule_passes(input, 'thin');
+    const eagerRule = per_rule_passes(input, 'eager');
+    const breaches: string[] = [];
+    for (const [rule, e] of eagerRule) {
+        if (e >= 1 && (thinRule.get(rule) ?? 0) === 0) breaches.push(rule);
+    }
+
+    const instrument_ok = opts.kappa >= kappa_floor;
+    return {
+        kappa: opts.kappa,
+        kappa_floor,
+        instrument_ok,
+        delta_pp,
+        delta_ceiling_pp,
+        delta_registered,
+        thin,
+        eager,
+        rate_gap_pp,
+        must_not_ok,
+        non_inferiority_ok,
+        per_rule_floor_ok: breaches.length === 0,
+        per_rule_floor_breaches: breaches.sort(),
+        pass:
+            instrument_ok &&
+            delta_registered &&
+            must_not_ok &&
+            non_inferiority_ok &&
+            breaches.length === 0,
+    };
+}

package/src/scripts/_lib/cc_transcript.ts

@@ -0,0 +1,316 @@
+/**
+ * Claude Code transcript reader — replay-dedup, main/subagent classification,
+ * and token-usage aggregation.
+ *
+ * Metric definition (load-bearing — every consumer of this module computes
+ * cost/weight against this, not against `usage.input_tokens` alone):
+ *
+ *     billable_input = input_tokens + cache_read_input_tokens
+ *                       + cache_creation_input_tokens
+ *
+ * Anthropic's `usage.input_tokens` field EXCLUDES cache tokens — it is only
+ * the uncached portion of the prompt. A cost or volume figure built from
+ * `input_tokens` alone silently drops the cache-read and cache-write legs.
+ *
+ * Replay dedup: Claude Code can write the same assistant turn into more than
+ * one transcript file (a resumed/checkpointed session re-persists prior
+ * turns into a new session file; a subagent's own transcript can duplicate
+ * turns also visible from its parent). On this repo's real
+ * `~/.claude/projects/` tree, 50.8% of `type: "assistant"` records with a
+ * `usage` block are such replays — an un-deduped sum overstates real spend
+ * by roughly 2x. `message.id` + `requestId` together are the closest thing
+ * to a stable identity for one real API call.
+ *
+ * Subagent classification: a record is a subagent leg iff its top-level
+ * `agentId` is present, or `isSidechain === true`. Both signals are checked
+ * because subagent transcripts observed under
+ * `<project>/<sessionId>/subagents/agent-*.jsonl` carry both, but a future
+ * or differently-configured transcript could carry only one.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+
+/** Default base directory holding one subdirectory per Claude Code project. */
+export const DEFAULT_PROJECTS_ROOT = path.join(homedir(), '.claude', 'projects');
+
+export type TranscriptBucket = 'main' | 'subagent';
+
+/** The six token counters every downstream metric (cost, weight, share) is built from. */
+export interface TokenCounts {
+    input_tokens: number;
+    cache_read_input_tokens: number;
+    cache_creation_input_tokens: number;
+    output_tokens: number;
+    /** Subset of `cache_creation_input_tokens` written under the 5-minute TTL. */
+    ephemeral_5m_input_tokens: number;
+    /** Subset of `cache_creation_input_tokens` written under the 1-hour TTL. */
+    ephemeral_1h_input_tokens: number;
+}
+
+/** One deduped assistant turn. */
+export interface TranscriptRecord {
+    bucket: TranscriptBucket;
+    agentId: string | null;
+    model: string;
+    /** Raw `timestamp` field from the record, or null when absent. */
+    timestamp: string | null;
+    usage: TokenCounts;
+}
+
+export interface ScanOptions {
+    /** Base directory to walk (default {@link DEFAULT_PROJECTS_ROOT}). Injectable for tests. */
+    root?: string;
+    /**
+     * Restrict the walk to one subdirectory of `root` — either an absolute
+     * path or a name relative to `root` (e.g. the encoded-cwd project dir
+     * `findProjectDir()` style callers already compute). Omit to scan every
+     * project under `root`.
+     */
+    projectDir?: string;
+    /** Skip `.jsonl` files whose mtime is older than this many days. */
+    maxAgeDays?: number;
+    /** Clock used to evaluate `maxAgeDays` — injectable for tests. */
+    now?: Date;
+}
+
+export interface ScanResult {
+    records: TranscriptRecord[];
+    /** Count of `type: "assistant"` + `usage`-bearing lines seen, before dedup. */
+    totalSeen: number;
+    /** `records.length` — the count after dedup. */
+    dedupedCount: number;
+    /** Fraction of seen records that were replays: `(totalSeen - dedupedCount) / totalSeen`. */
+    dedup_ratio: number;
+}
+
+/** Per-bucket rollup: call count, the four raw token sums, the TTL write split, and two derived metrics. */
+export interface BucketAggregate extends TokenCounts {
+    bucket: TranscriptBucket;
+    calls: number;
+    /** `cache_read_input_tokens / billable_input` — 0 when billable_input is 0. */
+    read_share: number;
+    /** Cost-shaped weight: uncached input 1.0x, cache read 0.1x, 5m write 1.25x, 1h write 2.0x. */
+    weighted_input_units: number;
+}
+
+/** `input_tokens + cache_read_input_tokens + cache_creation_input_tokens` — see module doc comment. */
+export function billableInputTokens(u: Pick<TokenCounts, 'input_tokens' | 'cache_read_input_tokens' | 'cache_creation_input_tokens'>): number {
+    return u.input_tokens + u.cache_read_input_tokens + u.cache_creation_input_tokens;
+}
+
+/**
+ * Cost-shaped weight across the four input classes. `cache_creation_input_tokens`
+ * that exceeds the known 5m/1h split (older records predating the TTL
+ * breakdown, or a partial breakdown) is treated as a 5m write — Anthropic's
+ * default cache TTL — rather than silently dropped.
+ */
+export function weightedInputUnits(u: TokenCounts): number {
+    const knownSplit = u.ephemeral_5m_input_tokens + u.ephemeral_1h_input_tokens;
+    const unaccounted = Math.max(0, u.cache_creation_input_tokens - knownSplit);
+    return (
+        u.input_tokens * 1.0 +
+        u.cache_read_input_tokens * 0.1 +
+        (u.ephemeral_5m_input_tokens + unaccounted) * 1.25 +
+        u.ephemeral_1h_input_tokens * 2.0
+    );
+}
+
+function numOr0(value: unknown): number {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+interface RawCacheCreation {
+    ephemeral_5m_input_tokens?: unknown;
+    ephemeral_1h_input_tokens?: unknown;
+}
+
+interface RawUsage {
+    input_tokens?: unknown;
+    cache_read_input_tokens?: unknown;
+    cache_creation_input_tokens?: unknown;
+    output_tokens?: unknown;
+    cache_creation?: RawCacheCreation;
+}
+
+interface RawAssistantRecord {
+    type?: unknown;
+    message?: { id?: unknown; model?: unknown; usage?: RawUsage };
+    requestId?: unknown;
+    agentId?: unknown;
+    isSidechain?: unknown;
+    timestamp?: unknown;
+}
+
+function toTokenCounts(raw: RawUsage | undefined): TokenCounts {
+    const cc = raw?.cache_creation ?? {};
+    return {
+        input_tokens: numOr0(raw?.input_tokens),
+        cache_read_input_tokens: numOr0(raw?.cache_read_input_tokens),
+        cache_creation_input_tokens: numOr0(raw?.cache_creation_input_tokens),
+        output_tokens: numOr0(raw?.output_tokens),
+        ephemeral_5m_input_tokens: numOr0(cc.ephemeral_5m_input_tokens),
+        ephemeral_1h_input_tokens: numOr0(cc.ephemeral_1h_input_tokens),
+    };
+}
+
+/** Subagent iff a non-empty top-level `agentId` OR `isSidechain === true` — see module doc comment. */
+function classifyBucket(raw: RawAssistantRecord): TranscriptBucket {
+    const hasAgentId = typeof raw.agentId === 'string' && raw.agentId.length > 0;
+    return hasAgentId || raw.isSidechain === true ? 'subagent' : 'main';
+}
+
+/** `message.id` + `requestId`, NUL-joined so no string content can forge a collision. */
+function dedupKey(raw: RawAssistantRecord): string {
+    const id = typeof raw.message?.id === 'string' ? raw.message.id : '';
+    const reqId = typeof raw.requestId === 'string' ? raw.requestId : '';
+    return `${id}\u0000${reqId}`;
+}
+
+function parseLine(line: string): RawAssistantRecord | null {
+    if (line.trim().length === 0) return null;
+    try {
+        return JSON.parse(line) as RawAssistantRecord;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * List every `*.jsonl` file under `opts.root` (or `opts.root/opts.projectDir`
+ * when given), recursively — this is what makes `<project>/<sessionId>/
+ * subagents/agent-*.jsonl` visible alongside the flat `<project>/*.jsonl`
+ * session files without a second code path.
+ */
+export function listTranscriptFiles(opts: ScanOptions = {}): string[] {
+    const root = opts.root ?? DEFAULT_PROJECTS_ROOT;
+    const base = opts.projectDir
+        ? (path.isAbsolute(opts.projectDir) ? opts.projectDir : path.join(root, opts.projectDir))
+        : root;
+    if (!fs.existsSync(base)) return [];
+
+    const cutoffMs = opts.maxAgeDays !== undefined
+        ? (opts.now ?? new Date()).getTime() - opts.maxAgeDays * 24 * 60 * 60 * 1000
+        : null;
+
+    const out: string[] = [];
+    const stack: string[] = [base];
+    while (stack.length > 0) {
+        const dir = stack.pop() as string;
+        let entries: fs.Dirent[];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+            if (cutoffMs !== null) {
+                let mtimeMs: number;
+                try {
+                    mtimeMs = fs.statSync(full).mtimeMs;
+                } catch {
+                    continue;
+                }
+                if (mtimeMs < cutoffMs) continue;
+            }
+            out.push(full);
+        }
+    }
+    return out.sort();
+}
+
+/**
+ * Read every listed transcript file, keep only `type: "assistant"` records
+ * carrying a `usage` block, and dedup by {@link dedupKey}. First occurrence
+ * of a dedup key wins — replays carry the same usage, so occurrence order
+ * has no effect on the aggregated totals.
+ */
+export function scanTranscripts(opts: ScanOptions = {}): ScanResult {
+    const files = listTranscriptFiles(opts);
+    const seen = new Set<string>();
+    const records: TranscriptRecord[] = [];
+    let totalSeen = 0;
+
+    for (const file of files) {
+        let text: string;
+        try {
+            text = fs.readFileSync(file, 'utf-8');
+        } catch {
+            continue;
+        }
+        for (const line of text.split('\n')) {
+            const raw = parseLine(line);
+            if (!raw || raw.type !== 'assistant' || !raw.message?.usage) continue;
+
+            totalSeen += 1;
+            const key = dedupKey(raw);
+            if (seen.has(key)) continue;
+            seen.add(key);
+
+            records.push({
+                bucket: classifyBucket(raw),
+                agentId: typeof raw.agentId === 'string' ? raw.agentId : null,
+                model: typeof raw.message.model === 'string' ? raw.message.model : 'unknown',
+                timestamp: typeof raw.timestamp === 'string' ? raw.timestamp : null,
+                usage: toTokenCounts(raw.message.usage),
+            });
+        }
+    }
+
+    const dedupedCount = records.length;
+    return {
+        records,
+        totalSeen,
+        dedupedCount,
+        dedup_ratio: totalSeen > 0 ? (totalSeen - dedupedCount) / totalSeen : 0,
+    };
+}
+
+function emptyAggregate(bucket: TranscriptBucket): BucketAggregate {
+    return {
+        bucket,
+        calls: 0,
+        input_tokens: 0,
+        cache_read_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+        output_tokens: 0,
+        ephemeral_5m_input_tokens: 0,
+        ephemeral_1h_input_tokens: 0,
+        read_share: 0,
+        weighted_input_units: 0,
+    };
+}
+
+/** Roll deduped records up into a `main` / `subagent` pair of {@link BucketAggregate}. */
+export function aggregateByBucket(records: readonly TranscriptRecord[]): Record<TranscriptBucket, BucketAggregate> {
+    const buckets: Record<TranscriptBucket, BucketAggregate> = {
+        main: emptyAggregate('main'),
+        subagent: emptyAggregate('subagent'),
+    };
+
+    for (const rec of records) {
+        const agg = buckets[rec.bucket];
+        agg.calls += 1;
+        agg.input_tokens += rec.usage.input_tokens;
+        agg.cache_read_input_tokens += rec.usage.cache_read_input_tokens;
+        agg.cache_creation_input_tokens += rec.usage.cache_creation_input_tokens;
+        agg.output_tokens += rec.usage.output_tokens;
+        agg.ephemeral_5m_input_tokens += rec.usage.ephemeral_5m_input_tokens;
+        agg.ephemeral_1h_input_tokens += rec.usage.ephemeral_1h_input_tokens;
+    }
+
+    for (const bucket of Object.values(buckets)) {
+        const billable = billableInputTokens(bucket);
+        bucket.read_share = billable > 0 ? bucket.cache_read_input_tokens / billable : 0;
+        bucket.weighted_input_units = weightedInputUnits(bucket);
+    }
+
+    return buckets;
+}