@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/dist/esm/utils/resolve-preference-baseline.test.js

@@ -1,69 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { resolvePreferenceBaseline } from './resolve-preference-baseline';
-// GENC-1351 #2: the preference baseline resolves with precedence
-//   slice defaults  <  chatConfig.ui defaults  <  stored user preferences.
-// The regression this guards: when stored prefs are absent (first load / wiped
-// backend) the result must fall through to the chatConfig.ui defaults, NOT to
-// everything-disabled.
-const FULL_UI = {
-    showToolCalls: true,
-    showThinkingSteps: true,
-    showNarration: true,
-    showAgentSwitchIndicator: true,
-    animations: { userConfigurable: true },
-};
-const Suite = createLogicSuite('resolvePreferenceBaseline');
-Suite('with no stored prefs, falls back to chatConfig.ui defaults (the nuke case)', () => {
-    const r = resolvePreferenceBaseline(FULL_UI, null);
-    assert.is(r.showToolCalls, true);
-    assert.is(r.showThinkingSteps, true);
-    assert.is(r.showNarration, true);
-    assert.is(r.showAgentSwitchIndicator, true);
-    assert.ok(r.enabledAnimations.length > 0, 'config animations enabled by default');
-    assert.is(r.enabled, undefined, 'no stored enabled → leave host default untouched');
-});
-Suite('with no stored prefs AND empty/unbound chatConfig, everything is off', () => {
-    // The transient state during connect before chatConfig binds — all-false is
-    // correct HERE; the element re-runs the baseline once chatConfig arrives.
-    const r = resolvePreferenceBaseline(undefined, null);
-    assert.equal([r.showToolCalls, r.showThinkingSteps, r.showNarration, r.showAgentSwitchIndicator], [false, false, false, false]);
-    assert.equal(r.enabledAnimations, []);
-});
-Suite('stored prefs override the config defaults field-by-field', () => {
-    const stored = {
-        enabled: true,
-        showToolCalls: false,
-        showThinkingSteps: false,
-        showNarration: true,
-        showAgentSwitchIndicator: false,
-        animations: ['halo'],
-    };
-    const r = resolvePreferenceBaseline(FULL_UI, stored);
-    assert.is(r.showToolCalls, false, 'stored false beats config true');
-    assert.is(r.showThinkingSteps, false);
-    assert.is(r.showNarration, true);
-    assert.is(r.showAgentSwitchIndicator, false);
-    assert.equal(r.enabledAnimations, ['halo'], 'stored animations applied as-is');
-    assert.is(r.enabled, true, 'stored enabled surfaces');
-});
-Suite('a partial stored blob overrides only present fields; others keep config default', () => {
-    const stored = { showToolCalls: false };
-    const r = resolvePreferenceBaseline(FULL_UI, stored);
-    assert.is(r.showToolCalls, false, 'present field overridden');
-    assert.is(r.showThinkingSteps, true, 'absent field keeps config default');
-    assert.is(r.showAgentSwitchIndicator, true);
-    assert.is(r.enabled, undefined, 'absent enabled stays undefined');
-});
-Suite('stored prefs over an empty config still apply (config layer is all-false)', () => {
-    const stored = { showToolCalls: true, showThinkingSteps: true };
-    const r = resolvePreferenceBaseline(undefined, stored);
-    assert.is(r.showToolCalls, true);
-    assert.is(r.showThinkingSteps, true);
-    assert.is(r.showNarration, false, 'not in stored, not in config → false');
-});
-Suite('de-dupes stored animations (heals blobs from the old settings-modal append bug)', () => {
-    const stored = { animations: ['loading', 'halo', 'loading', 'halo'] };
-    const r = resolvePreferenceBaseline(FULL_UI, stored);
-    assert.equal(r.enabledAnimations, ['loading', 'halo'], 'duplicates collapsed, order preserved');
-});
-Suite.run();

package/dist/esm/utils/strip-agent-handlers.test.js

@@ -1,81 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { stripAgentHandlers } from './strip-agent-handlers';
-const cfg = (overrides) => (Object.assign({ name: 'agent' }, overrides));
-/** Mirrors what redux's serializable-state check does: find any function anywhere. */
-const hasFunctionDeep = (value) => {
-    if (typeof value === 'function')
-        return true;
-    if (Array.isArray(value))
-        return value.some(hasFunctionDeep);
-    if (value !== null && typeof value === 'object') {
-        return Object.values(value).some(hasFunctionDeep);
-    }
-    return false;
-};
-const suite = createLogicSuite('stripAgentHandlers');
-suite('drops object-form toolHandlers (the redux-leak regression)', () => {
-    const stripped = stripAgentHandlers(cfg({ toolHandlers: { vfs_list: () => __awaiter(void 0, void 0, void 0, function* () { return 'x'; }), vfs_read: () => __awaiter(void 0, void 0, void 0, function* () { return 'y'; }) } }));
-    // The whole handler bag is gone — not left behind with live functions inside.
-    assert.not.ok(stripped.toolHandlers);
-    assert.not.ok(hasFunctionDeep(stripped));
-});
-suite('drops factory-function toolHandlers and the lifecycle/dispatch hooks', () => {
-    const stripped = stripAgentHandlers(cfg({
-        toolHandlers: () => ({ t: () => __awaiter(void 0, void 0, void 0, function* () { return 'x'; }) }),
-        onActivate: () => __awaiter(void 0, void 0, void 0, function* () { }),
-        onDeactivate: () => __awaiter(void 0, void 0, void 0, function* () { }),
-        getDebugSnapshot: () => ({}),
-        onUnresolvedTool: () => 'redirect',
-    }));
-    assert.not.ok(stripped.toolHandlers);
-    assert.not.ok(stripped.onActivate);
-    assert.not.ok(stripped.onDeactivate);
-    assert.not.ok(stripped.getDebugSnapshot);
-    assert.not.ok(stripped.onUnresolvedTool);
-});
-suite('drops function-form resolvers but keeps static forms and plain data', () => {
-    const stripped = stripAgentHandlers(cfg({
-        systemPrompt: () => 'dynamic', // function → dropped
-        displayName: 'Static Name', // string → kept
-        temperature: 0.5, // number → kept
-        toolChoice: 'auto', // string → kept
-        toolDefinitions: [{ name: 'x', description: 'd', parameters: {} }], // data array → kept
-        manualSelection: { enabled: true, hint: 'pick me' }, // data object → kept
-    }));
-    assert.not.ok(stripped.systemPrompt);
-    assert.is(stripped.displayName, 'Static Name');
-    assert.is(stripped.temperature, 0.5);
-    assert.is(stripped.toolChoice, 'auto');
-    assert.equal(stripped.toolDefinitions, [{ name: 'x', description: 'd', parameters: {} }]);
-    assert.equal(stripped.manualSelection, { enabled: true, hint: 'pick me' });
-});
-suite('recurses into subAgents, stripping their object-form toolHandlers', () => {
-    const stripped = stripAgentHandlers(cfg({
-        name: 'boss',
-        toolHandlers: () => ({}),
-        subAgents: [
-            cfg({
-                name: 'worker',
-                toolHandlers: { vfs_list: () => __awaiter(void 0, void 0, void 0, function* () { return 'x'; }), vfs_read: () => __awaiter(void 0, void 0, void 0, function* () { return 'y'; }) },
-            }),
-        ],
-    }));
-    const subs = stripped.subAgents;
-    assert.is(subs.length, 1);
-    assert.is(subs[0].name, 'worker');
-    assert.not.ok(subs[0].toolHandlers, 'sub-agent toolHandlers must be stripped (the reported bug)');
-    // Nothing function-valued survives anywhere in the projection.
-    assert.not.ok(hasFunctionDeep(stripped));
-});
-suite('produces a projection with no function at any depth', () => {
-    const stripped = stripAgentHandlers(cfg({
-        name: 'boss',
-        onActivate: () => __awaiter(void 0, void 0, void 0, function* () { }),
-        subAgents: [cfg({ name: 'w', toolHandlers: { t: () => __awaiter(void 0, void 0, void 0, function* () { }) } })],
-    }));
-    assert.not.ok(hasFunctionDeep(stripped));
-    // Round-trips to the expected serializable shape.
-    assert.equal(JSON.parse(JSON.stringify(stripped)), { name: 'boss', subAgents: [{ name: 'w' }] });
-});
-suite.run();

package/dist/esm/utils/sum-costs.test.js

@@ -1,114 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { sumCosts } from './sum-costs';
-const userMsg = (overrides = {}) => (Object.assign({ role: 'user', content: '' }, overrides));
-const assistantMsg = (overrides = {}) => (Object.assign({ role: 'assistant', content: '' }, overrides));
-const suite = createLogicSuite('sumCosts');
-suite('returns 0 for an empty message list', () => {
-    assert.is(sumCosts([]), 0);
-});
-suite('returns 0 when no message carries cost (e.g. all from a no-usage provider)', () => {
-    assert.is(sumCosts([userMsg(), assistantMsg({ content: 'hi' })]), 0);
-});
-suite('sums top-level message costs', () => {
-    // Use integer-cents arithmetic to avoid float-equality flake; the production
-    // path only ever adds floats here, so any rounding lives in display, not sum.
-    const cost = sumCosts([
-        assistantMsg({ cost: 0.5 }),
-        assistantMsg({ cost: 1.5 }),
-        userMsg(), // no cost — ignored
-    ]);
-    assert.is(cost, 2);
-});
-suite('includes sub-agent trace costs attached to a tool call', () => {
-    const parentToolCallMsg = assistantMsg({
-        cost: 0.1,
-        toolCalls: [
-            {
-                id: 'tc1',
-                name: 'spawn_sub',
-                args: {},
-                subAgentTrace: [assistantMsg({ cost: 0.5 }), assistantMsg({ cost: 0.4 })],
-            },
-        ],
-    });
-    // 0.1 (parent) + 0.5 + 0.4 (sub) = 1.0
-    assert.is(sumCosts([parentToolCallMsg]), 1);
-});
-suite('recurses into nested sub-agent traces', () => {
-    const innerTrace = [assistantMsg({ cost: 0.25 })];
-    const middleTrace = [
-        assistantMsg({
-            cost: 0.5,
-            toolCalls: [{ id: 'inner', name: 'spawn_inner', args: {}, subAgentTrace: innerTrace }],
-        }),
-    ];
-    const top = assistantMsg({
-        cost: 1,
-        toolCalls: [{ id: 'middle', name: 'spawn_middle', args: {}, subAgentTrace: middleTrace }],
-    });
-    // 1 + 0.5 + 0.25 = 1.75
-    assert.is(sumCosts([top]), 1.75);
-});
-suite('handles a mix of tool calls with and without subAgentTrace', () => {
-    const cost = sumCosts([
-        assistantMsg({
-            cost: 1,
-            toolCalls: [
-                { id: 'a', name: 'plain_tool', args: {} }, // no trace — skipped
-                {
-                    id: 'b',
-                    name: 'sub_tool',
-                    args: {},
-                    subAgentTrace: [assistantMsg({ cost: 2 })],
-                },
-            ],
-        }),
-    ]);
-    assert.is(cost, 3);
-});
-suite('ignores missing cost fields inside an otherwise-populated trace', () => {
-    const cost = sumCosts([
-        assistantMsg({
-            toolCalls: [
-                {
-                    id: 'tc',
-                    name: 'sub',
-                    args: {},
-                    subAgentTrace: [
-                        userMsg(), // role=user, no cost
-                        assistantMsg({ content: 'partial', cost: 0.3 }),
-                        assistantMsg({ content: 'unbilled' }), // no cost field
-                    ],
-                },
-            ],
-        }),
-    ]);
-    assert.is(cost, 0.3);
-});
-suite('adds widget-reported externalCostUsd alongside provider cost', () => {
-    // A message can carry both: provider LLM `cost` and a widget's `externalCostUsd`.
-    const cost = sumCosts([
-        assistantMsg({ cost: 0.5 }), // provider only
-        assistantMsg({ externalCostUsd: 0.25 }), // external only (e.g. an interaction message)
-        assistantMsg({ cost: 0.1, externalCostUsd: 0.4 }), // both
-        userMsg(), // neither — ignored
-    ]);
-    // 0.5 + 0.25 + 0.1 + 0.4 = 1.25
-    assert.is(cost, 1.25);
-});
-suite('includes externalCostUsd inside a sub-agent trace', () => {
-    const cost = sumCosts([
-        assistantMsg({
-            toolCalls: [
-                {
-                    id: 'tc',
-                    name: 'sub',
-                    args: {},
-                    subAgentTrace: [assistantMsg({ cost: 0.5, externalCostUsd: 0.5 })],
-                },
-            ],
-        }),
-    ]);
-    assert.is(cost, 1);
-});
-suite.run();

package/dist/esm/utils/sum-tokens.test.js

@@ -1,51 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { formatCompactTokenCount, formatCompactTokenCountSafe, sumTokens } from './sum-tokens';
-const assistantMsg = (overrides = {}) => (Object.assign({ role: 'assistant', content: '' }, overrides));
-const suite = createLogicSuite('sumTokens');
-suite('returns 0 for an empty message list', () => {
-    assert.is(sumTokens([]), 0);
-});
-suite('sums input and output tokens on top-level messages', () => {
-    assert.is(sumTokens([
-        assistantMsg({ inputTokens: 100, outputTokens: 50 }),
-        assistantMsg({ inputTokens: 200, outputTokens: 0 }),
-    ]), 350);
-});
-suite('includes sub-agent trace tokens attached to a tool call', () => {
-    assert.is(sumTokens([
-        assistantMsg({
-            inputTokens: 10,
-            outputTokens: 5,
-            toolCalls: [
-                {
-                    id: 'tc1',
-                    name: 'spawn_sub',
-                    args: {},
-                    subAgentTrace: [assistantMsg({ inputTokens: 1000, outputTokens: 400 })],
-                },
-            ],
-        }),
-    ]), 1415);
-});
-const formatSuite = createLogicSuite('formatCompactTokenCount');
-formatSuite('formats millions with one decimal when needed', () => {
-    assert.is(formatCompactTokenCount(1400000), '<span class="value">1.4</span><span class="suffix">M</span>');
-});
-formatSuite('formats whole millions without a decimal', () => {
-    assert.is(formatCompactTokenCount(2000000), '<span class="value">2</span><span class="suffix">M</span>');
-});
-formatSuite('formats thousands compactly', () => {
-    assert.is(formatCompactTokenCount(3200), '<span class="value">3.2</span><span class="suffix">K</span>');
-});
-formatSuite('formats small counts with grouping', () => {
-    assert.is(formatCompactTokenCount(842), '842');
-});
-formatSuite('rolls K suffix up to M when rounding would yield 1000K', () => {
-    assert.is(formatCompactTokenCount(999950), '<span class="value">1</span><span class="suffix">M</span>');
-    assert.is(formatCompactTokenCount(999949), '<span class="value">999.9</span><span class="suffix">K</span>');
-});
-formatSuite('safe formatter preserves compact markup', () => {
-    assert.is(formatCompactTokenCountSafe(1400000), '<span class="value">1.4</span><span class="suffix">M</span>');
-});
-suite.run();
-formatSuite.run();

package/dist/esm/utils/sum-usage.test.js

@@ -1,164 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { addUsage, emptyUsage, messageUsage, sumUsage, totalTokens } from './sum-usage';
-const suite = createLogicSuite('sumUsage');
-const msg = (over = {}) => (Object.assign({ role: 'assistant', content: '' }, over));
-suite('returns zeroes when no message carries usage', () => {
-    const usage = sumUsage([msg({ role: 'user', content: 'hi' })]);
-    assert.equal(usage, emptyUsage());
-    assert.is(totalTokens(usage), 0);
-});
-suite('splits the prompt into three disjoint input buckets', () => {
-    // `inputTokens` is the WHOLE prompt; the cache fields break it down. So uncached is
-    // the remainder, and the three must re-add to the prompt exactly — that identity is
-    // what stops the buckets double-counting the prompt when summed.
-    const usage = sumUsage([
-        msg({ inputTokens: 1000, cacheReadTokens: 700, cacheWriteTokens: 200, outputTokens: 50 }),
-    ]);
-    assert.is(usage.uncachedInputTokens, 100);
-    assert.is(usage.cacheReadTokens, 700);
-    assert.is(usage.cacheWriteTokens, 200);
-    assert.is(usage.outputTokens, 50);
-    assert.is(usage.uncachedInputTokens + usage.cacheReadTokens + usage.cacheWriteTokens, 1000, 'input buckets re-add to the prompt total');
-    assert.is(totalTokens(usage), 1050);
-});
-suite('treats the whole prompt as uncached when no cache split is reported', () => {
-    // Providers that report no cache breakdown (and messages persisted before the fields
-    // existed) must still contribute their full prompt, not drop it.
-    const usage = sumUsage([msg({ inputTokens: 400, outputTokens: 60 })]);
-    assert.is(usage.uncachedInputTokens, 400);
-    assert.is(usage.cacheReadTokens, 0);
-    assert.is(usage.cacheWriteTokens, 0);
-    assert.is(totalTokens(usage), 460);
-});
-suite('clamps uncached input at zero when buckets exceed the prompt total', () => {
-    // Malformed or hand-edited history must not be able to drive a cost display negative.
-    const usage = sumUsage([
-        msg({ inputTokens: 100, cacheReadTokens: 90, cacheWriteTokens: 90, outputTokens: 0 }),
-    ]);
-    assert.is(usage.uncachedInputTokens, 0);
-});
-suite('sums LLM cost and widget-reported external cost', () => {
-    const usage = sumUsage([msg({ cost: 0.25 }), msg({ externalCostUsd: 0.1, cost: 0.05 })]);
-    assert.is(Math.round(usage.costUsd * 100) / 100, 0.4);
-});
-suite('recurses into sub-agent traces', () => {
-    // A sub-agent's whole conversation is embedded in the parent's tool call, so this is
-    // the only place its spend is visible to a host total.
-    const usage = sumUsage([
-        msg({
-            toolCalls: [
-                {
-                    id: 'tc-1',
-                    name: 'delegate',
-                    args: {},
-                    subAgentTrace: [
-                        msg({ cost: 0.2, inputTokens: 300, cacheReadTokens: 100, outputTokens: 40 }),
-                    ],
-                },
-            ],
-        }),
-    ]);
-    assert.is(usage.costUsd, 0.2);
-    assert.is(usage.uncachedInputTokens, 200);
-    assert.is(usage.cacheReadTokens, 100);
-    assert.is(usage.outputTokens, 40);
-});
-suite('counts usage banked onto a compaction summary', () => {
-    // Compaction destroys the messages it summarises. Without the banked rollup, a total
-    // re-derived from the transcript would fall by whatever those turns had spent.
-    const before = sumUsage([
-        msg({ cost: 0.5, inputTokens: 1000, cacheReadTokens: 400, outputTokens: 100 }),
-        msg({ cost: 0.3, inputTokens: 500, outputTokens: 50 }),
-    ]);
-    const afterCompaction = sumUsage([
-        msg({
-            role: 'compacted-summary',
-            content: 'summary of the above',
-            compaction: {
-                compactedCount: 2,
-                createdAt: '2026-06-14T12:00:00.000Z',
-                rolledUpUsage: before,
-            },
-        }),
-    ]);
-    assert.equal(afterCompaction, before, 'compaction preserves the running total');
-});
-suite('ignores tokensBefore, which is a context reading rather than spend', () => {
-    // `tokensBefore` is one turn's context-window size. Counting it as cumulative spend
-    // would silently inflate the session total on every compaction.
-    const usage = sumUsage([
-        msg({
-            role: 'compacted-summary',
-            content: 'summary',
-            compaction: {
-                compactedCount: 3,
-                createdAt: '2026-06-14T12:00:00.000Z',
-                tokensBefore: 90000,
-            },
-        }),
-    ]);
-    assert.is(totalTokens(usage), 0);
-});
-suite('addUsage adds every bucket and mutates neither operand', () => {
-    const a = Object.assign(Object.assign({}, emptyUsage()), { costUsd: 1.5, uncachedInputTokens: 100, outputTokens: 10 });
-    const b = Object.assign(Object.assign({}, emptyUsage()), { costUsd: 0.25, cacheReadTokens: 900, outputTokens: 5 });
-    const sum = addUsage(a, b);
-    assert.is(sum.costUsd, 1.75);
-    assert.is(sum.uncachedInputTokens, 100);
-    assert.is(sum.cacheReadTokens, 900);
-    assert.is(sum.outputTokens, 15);
-    // Both operands are live state (a row's banked figure and the session total), so a
-    // caller must be able to add without either being altered underneath it.
-    assert.is(a.costUsd, 1.5);
-    assert.is(b.cacheReadTokens, 900);
-});
-suite('addUsage with an empty operand is the identity', () => {
-    const a = Object.assign(Object.assign({}, emptyUsage()), { costUsd: 3, cacheWriteTokens: 42 });
-    assert.equal(addUsage(a, emptyUsage()), a);
-    assert.equal(addUsage(emptyUsage(), a), a);
-});
-suite('messageUsage is undefined for a message reporting nothing', () => {
-    // A user turn, or a display-only reasoning/narration split. Distinct from a zeroed
-    // usage: "this call reported nothing" is not "this call cost nothing".
-    assert.is(messageUsage(msg({ role: 'user', content: 'hi' })), undefined);
-    assert.is(messageUsage(msg({ content: 'thinking…', category: 'reasoning' })), undefined);
-});
-suite('messageUsage agrees with sumUsage over the same single message', () => {
-    // The two derivations are deliberately separate — `accumulate` mutates one
-    // accumulator rather than allocating per message — so pin them together. A drift
-    // here would put one figure on a turn entry and a different one in the session
-    // total, both looking plausible.
-    const cases = [
-        { inputTokens: 1000, cacheReadTokens: 700, cacheWriteTokens: 200, outputTokens: 50, cost: 0.4 },
-        { inputTokens: 400, outputTokens: 60 },
-        { inputTokens: 100, cacheReadTokens: 90, cacheWriteTokens: 90 },
-        { cost: 0.01, externalCostUsd: 0.02 },
-    ];
-    for (const over of cases) {
-        const m = msg(over);
-        assert.equal(messageUsage(m), sumUsage([m]), `messageUsage must match sumUsage for ${JSON.stringify(over)}`);
-    }
-});
-suite('messageUsage is shallow — it prices the one request, not the tree', () => {
-    // Deliberately blind to sub-agent traces and banked compaction usage: it answers
-    // "what did this call cost", which is what a turn snapshot needs. `sumUsage` is the
-    // function that walks everything underneath.
-    const m = msg({
-        inputTokens: 100,
-        outputTokens: 10,
-        cost: 0.05,
-        toolCalls: [
-            {
-                id: 't1',
-                name: 'delegate',
-                args: {},
-                subAgentTrace: [msg({ inputTokens: 900, outputTokens: 90, cost: 0.5 })],
-            },
-        ],
-    });
-    const usage = messageUsage(m);
-    assert.is(usage.costUsd, 0.05, 'the child conversation is not folded in');
-    assert.is(usage.uncachedInputTokens, 100);
-    assert.ok(sumUsage([m]).costUsd > usage.costUsd, 'sumUsage does fold it in');
-});
-suite.run();

package/dist/esm/utils/usage-rows.test.js

@@ -1,189 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { sumUsage } from './sum-usage';
-import { usageRows } from './usage-rows';
-const msg = (over) => (Object.assign({ role: 'assistant', content: '' }, over));
-const rolled = (over) => (Object.assign({ costUsd: 0, uncachedInputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, outputTokens: 0 }, over));
-/** Every place spend can hide, in one transcript: a delegation and a compaction. */
-const richHistory = () => [
-    msg({
-        role: 'compacted-summary',
-        content: 'summary',
-        compaction: {
-            compactedCount: 4,
-            rolledUpUsage: rolled({ costUsd: 0.05, uncachedInputTokens: 400, outputTokens: 60 }),
-            // The summariser's model — NOT what the banked spend ran on.
-            model: 'claude-haiku-4-5-20251001',
-        },
-    }),
-    msg({ role: 'user', content: 'go' }),
-    msg({
-        model: 'claude-sonnet-5',
-        agentName: 'boss',
-        cost: 0.01,
-        inputTokens: 1000,
-        cacheReadTokens: 900,
-        outputTokens: 50,
-        toolCalls: [
-            {
-                id: 'tc1',
-                name: 'delegate',
-                args: {},
-                subAgentTrace: [
-                    msg({
-                        model: 'gemini-2.5-flash',
-                        agentName: 'worker',
-                        cost: 0.12,
-                        inputTokens: 500,
-                        outputTokens: 200,
-                    }),
-                ],
-            },
-        ],
-    }),
-];
-const suite = createLogicSuite('usageRows');
-suite('reconciles exactly with sumUsage over the same input', () => {
-    // THE guarantee. A per-call view that disagrees with the total is worse than none,
-    // because both look right in isolation — which is how the consumer's own copy
-    // under-reported for a month.
-    const history = richHistory();
-    const rows = usageRows(history);
-    const total = sumUsage(history);
-    const rowCost = rows.reduce((n, r) => { var _a, _b; return n + ((_a = r.costUsd) !== null && _a !== void 0 ? _a : 0) + ((_b = r.externalCostUsd) !== null && _b !== void 0 ? _b : 0); }, 0);
-    assert.ok(Math.abs(rowCost - total.costUsd) < 1e-12, `${rowCost} vs ${total.costUsd}`);
-    const bucket = (k) => rows.reduce((n, r) => n + r[k], 0);
-    assert.is(bucket('uncachedInputTokens'), total.uncachedInputTokens, 'uncached input');
-    assert.is(bucket('cacheReadTokens'), total.cacheReadTokens, 'cache read');
-    assert.is(bucket('cacheWriteTokens'), total.cacheWriteTokens, 'cache write');
-    assert.is(bucket('outputTokens'), total.outputTokens, 'output');
-});
-suite('emits a compaction row so banked spend is not lost from a per-call view', () => {
-    // The shortfall this function exists to close: the summary message carries no
-    // `cost` and no token fields of its own, so a naive per-message walk drops the
-    // spend of every turn the compaction deleted.
-    const rows = usageRows(richHistory());
-    const compactionRows = rows.filter((r) => r.source === 'compaction');
-    assert.is(compactionRows.length, 1);
-    assert.is(compactionRows[0].costUsd, 0.05);
-    assert.is(compactionRows[0].uncachedInputTokens, 400);
-    assert.is(compactionRows[0].model, undefined, 'no model — the banked spend may span several, and compaction.model is the summariser');
-});
-suite('recurses into sub-agent traces, tagging depth and the spawning call', () => {
-    const rows = usageRows(richHistory());
-    const child = rows.find((r) => r.model === 'gemini-2.5-flash');
-    assert.ok(child, 'the sub-agent turn produced a row');
-    assert.is(child.subAgentDepth, 1);
-    assert.is(child.subAgentOf, 'tc1');
-    assert.is(child.agentName, 'worker');
-    const parent = rows.find((r) => r.model === 'claude-sonnet-5');
-    assert.is(parent.subAgentDepth, 0);
-    assert.is(parent.subAgentOf, undefined);
-});
-suite('prefers the provider the driver stamped over re-deriving it from the model', () => {
-    // `ChatMessage.provider` comes from the resolved provider's own status, so it is
-    // authoritative and knows vendors the model allowlists do not. Re-deriving from the
-    // model id alone drops attribution for a server-proxied turn — exactly the rows a
-    // usage ledger cares most about getting right. PR review.
-    const rows = usageRows([
-        msg({ model: 'gpt-5', provider: 'openai', cost: 1, inputTokens: 1 }),
-        // Stamped provider disagrees with what the model id would derive: the stamp still wins.
-        msg({
-            model: 'claude-sonnet-5',
-            provider: 'chrome',
-            cost: 1,
-            inputTokens: 1,
-        }),
-    ]);
-    assert.equal(rows.map((r) => r.provider), ['openai', 'chrome']);
-});
-suite('resolves the provider from the model, and leaves it unset when unknown', () => {
-    const rows = usageRows([
-        msg({ model: 'claude-sonnet-5', cost: 1, inputTokens: 1 }),
-        msg({ model: 'gemini-2.5-flash', cost: 1, inputTokens: 1 }),
-        msg({ model: 'gpt-5', cost: 1, inputTokens: 1 }),
-        msg({ cost: 1, inputTokens: 1 }),
-    ]);
-    assert.equal(rows.map((r) => r.provider), ['anthropic', 'gemini', undefined, undefined], 'an unrecognised or absent model leaves provider unset rather than guessing');
-});
-suite('splits the prompt into buckets the same way sumUsage does', () => {
-    const [row] = usageRows([
-        msg({
-            model: 'claude-sonnet-5',
-            inputTokens: 1000,
-            cacheReadTokens: 600,
-            cacheWriteTokens: 300,
-        }),
-    ]);
-    assert.is(row.uncachedInputTokens, 100, 'the remainder, not an addition');
-    assert.is(row.cacheReadTokens, 600);
-    assert.is(row.cacheWriteTokens, 300);
-});
-suite('clamps a prompt whose cache buckets exceed the total', () => {
-    const [row] = usageRows([msg({ inputTokens: 100, cacheReadTokens: 900 })]);
-    assert.is(row.uncachedInputTokens, 0, 'never negative');
-});
-suite('leaves costUsd undefined when nothing was reported, rather than zero', () => {
-    // What the "carried usage but no cost" audit keys off. A zero here would read as a
-    // free call and the alarm would never fire.
-    const [row] = usageRows([msg({ model: 'claude-sonnet-5', inputTokens: 500, outputTokens: 10 })]);
-    assert.is(row.costUsd, undefined);
-    assert.is(row.source, 'request');
-});
-suite('records external (non-LLM) cost and counts it in the reconciliation', () => {
-    const history = [msg({ externalCostUsd: 0.4 }), msg({ model: 'claude-sonnet-5', cost: 0.1 })];
-    const rows = usageRows(history);
-    assert.is(rows.find((r) => r.externalCostUsd != null).externalCostUsd, 0.4);
-    const rowCost = rows.reduce((n, r) => { var _a, _b; return n + ((_a = r.costUsd) !== null && _a !== void 0 ? _a : 0) + ((_b = r.externalCostUsd) !== null && _b !== void 0 ? _b : 0); }, 0);
-    assert.ok(Math.abs(rowCost - sumUsage(history).costUsd) < 1e-12);
-});
-suite('produces no row for a message carrying no usage', () => {
-    assert.equal(usageRows([
-        msg({ role: 'user', content: 'hello' }),
-        msg({ content: 'thinking out loud', category: 'reasoning' }),
-    ]), []);
-});
-suite('is empty for an empty transcript', () => {
-    assert.equal(usageRows([]), []);
-});
-suite('reconciles on a nested delegation two levels deep', () => {
-    const history = [
-        msg({
-            model: 'claude-sonnet-5',
-            cost: 0.01,
-            inputTokens: 100,
-            toolCalls: [
-                {
-                    id: 'a',
-                    name: 'delegate',
-                    args: {},
-                    subAgentTrace: [
-                        msg({
-                            model: 'claude-sonnet-5',
-                            cost: 0.02,
-                            inputTokens: 200,
-                            toolCalls: [
-                                {
-                                    id: 'b',
-                                    name: 'delegate',
-                                    args: {},
-                                    subAgentTrace: [msg({ model: 'gemini-2.5-flash', cost: 0.04, inputTokens: 400 })],
-                                },
-                            ],
-                        }),
-                    ],
-                },
-            ],
-        }),
-    ];
-    const rows = usageRows(history);
-    assert.equal(rows.map((r) => r.subAgentDepth), [0, 1, 2]);
-    const rowCost = rows.reduce((n, r) => { var _a; return n + ((_a = r.costUsd) !== null && _a !== void 0 ? _a : 0); }, 0);
-    assert.ok(Math.abs(rowCost - sumUsage(history).costUsd) < 1e-12, 'still reconciles');
-});
-suite('does not mutate the transcript', () => {
-    const history = richHistory();
-    const before = JSON.stringify(history);
-    usageRows(history);
-    assert.is(JSON.stringify(history), before, 'a projection, not a transform');
-});
-suite.run();