@genesislcap/ai-assistant 15.6.2 → 15.7.1

package/dist/esm/state/ai-assistant-slice.test.js

@@ -1,7 +1,7 @@
 import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
 import { aiAssistantSlice, createDefaultSessionState, } from './ai-assistant-slice';
 // GENC-1351 §5.6 / Phase 1: the new bulk loadSession + resetSession reducers.
-const { loadSession, resetSession, setMessages, setState, setSessionMenuOpen, setShowToolCalls, setShowThinkingSteps, setShowNarration, setShowAgentSwitchIndicator, setEnabledAnimations, } = aiAssistantSlice.actions;
+const { loadSession, resetSession, setBlocked, setBlockedReason, setVendorBlocked, setInputValue, setMessages, setState, setSessionMenuOpen, setShowToolCalls, setShowThinkingSteps, setShowNarration, setShowAgentSwitchIndicator, setEnabledAnimations, } = aiAssistantSlice.actions;
 const reduce = aiAssistantSlice.reducer;
 const Suite = createLogicSuite('ai-assistant-slice-persistence');
 Suite('loadSession hydrates the restorable fields and forces idle', () => {
@@ -89,4 +89,141 @@ Suite('setSessionMenuOpen toggles the lifecycle-menu flag; resetSession clears i
     const cleared = reduce(state, resetSession());
     assert.is(cleared.sessionMenuOpen, false);
 });
+// GENC-1464: the backend-blocked latch (exhausted AI budget).
+Suite('setBlocked latches the flag and its reason', () => {
+    let state = createDefaultSessionState();
+    assert.is(state.blocked, false);
+    assert.is(state.blockedReason, null);
+    state = reduce(state, setBlocked({ blocked: true }));
+    assert.is(state.blocked, true);
+    assert.is(state.blockedReason, null, 'no reason given → null, so the element uses its default');
+    state = reduce(state, setBlocked({ blocked: true, reason: 'Budget exhausted — contact billing' }));
+    assert.is(state.blockedReason, 'Budget exhausted — contact billing');
+});
+Suite('unblocking always clears the reason', () => {
+    // A stale explanation must never outlive the condition it described.
+    let state = reduce(createDefaultSessionState(), setBlocked({ blocked: true, reason: 'gone' }));
+    state = reduce(state, setBlocked({ blocked: false }));
+    assert.is(state.blocked, false);
+    assert.is(state.blockedReason, null);
+});
+Suite('resetSession preserves the block — "New chat" does not refill the budget', () => {
+    // Deliberately unlike sessionMenuOpen/compacting above: this is a backend
+    // condition, not conversation state, so Clear must not hand the user a
+    // working-looking composer that fails on the next send.
+    let state = reduce(createDefaultSessionState(), setBlocked({ blocked: true, reason: 'no funds' }));
+    state = reduce(state, setMessages([{ role: 'user', content: 'x' }]));
+    const cleared = reduce(state, resetSession());
+    assert.is(cleared.messages.length, 0, 'the transcript is still cleared');
+    assert.is(cleared.blocked, true, 'the block survives Clear');
+    assert.is(cleared.blockedReason, 'no funds', 'and so does its reason');
+});
+Suite('re-latching without a reason preserves the host explanation', () => {
+    // The race this fixes is deterministic, not theoretical: `tool-loop-end` is
+    // published from the driver's `finally`, i.e. BEFORE `sendMessage()` resolves.
+    // So a bus-subscribed host (what the migration guide's Option C recommends)
+    // writes its detailed copy first, and the element's own latch — which may have
+    // no figures to offer — lands a moment later. Treating an OMITTED reason as
+    // "clear it" replaced the host's copy with generic copy every single time.
+    let state = reduce(createDefaultSessionState(), setBlocked({ blocked: true, reason: 'contact ops@acme.com' }));
+    state = reduce(state, setBlocked({ blocked: true }));
+    assert.is(state.blocked, true);
+    assert.is(state.blockedReason, 'contact ops@acme.com', 'the host copy survives the re-latch');
+});
+Suite('reason:null clears the explanation while staying blocked', () => {
+    // The explicit escape hatch the omitted case gives up: `null` still clears.
+    let state = reduce(createDefaultSessionState(), setBlocked({ blocked: true, reason: 'stale copy' }));
+    state = reduce(state, setBlocked({ blocked: true, reason: null }));
+    assert.is(state.blocked, true);
+    assert.is(state.blockedReason, null, 'the banner falls back to the default copy');
+});
+Suite('resetSession still resets everything NOT on the preserved list', () => {
+    // Pins the boundary from the other side, so the preserved list cannot quietly
+    // grow: these are conversation/UI state and Clear must wipe them.
+    let state = reduce(createDefaultSessionState(), setBlocked({ blocked: true, reason: 'r' }));
+    state = reduce(state, setSessionMenuOpen(true));
+    state = reduce(state, setInputValue('half-typed message'));
+    const cleared = reduce(state, resetSession());
+    assert.is(cleared.inputValue, '', 'the composer draft is reset');
+    assert.is(cleared.sessionMenuOpen, false, 'the panel flag is reset');
+    assert.is(cleared.blocked, true, '…while the block is still preserved');
+});
+// ── Per-vendor latches (GENC-1464 per-vendor budgets) ──────────────────────────
+Suite('setVendorBlocked walls one vendor and keeps the wall order', () => {
+    let state = reduce(createDefaultSessionState(), setVendorBlocked({ vendor: 'anthropic', blocked: true, reason: 'anthropic copy' }));
+    assert.equal(state.blockedVendors, ['anthropic']);
+    assert.equal(state.blockedVendorReasons, { anthropic: 'anthropic copy' });
+    assert.is(state.blocked, false, 'the vendor-agnostic flag is untouched');
+    state = reduce(state, setVendorBlocked({ vendor: 'gemini', blocked: true }));
+    assert.equal(state.blockedVendors, ['anthropic', 'gemini'], 'order is the order they were walled');
+});
+Suite('walling an already-walled vendor is idempotent', () => {
+    let state = reduce(createDefaultSessionState(), setVendorBlocked({ vendor: 'gemini', blocked: true, reason: 'first' }));
+    state = reduce(state, setVendorBlocked({ vendor: 'gemini', blocked: true, reason: 'second' }));
+    assert.equal(state.blockedVendors, ['gemini'], 'no duplicate entry');
+    assert.is(state.blockedVendorReasons.gemini, 'second');
+});
+Suite('the per-vendor reason honours the same three cases as setBlocked', () => {
+    // The same two-writer race (driver latch landing after a bus-subscribed host)
+    // applies per vendor, so "omitted keeps" has to hold here too.
+    let state = reduce(createDefaultSessionState(), setVendorBlocked({ vendor: 'anthropic', blocked: true, reason: 'host copy' }));
+    state = reduce(state, setVendorBlocked({ vendor: 'anthropic', blocked: true }));
+    assert.is(state.blockedVendorReasons.anthropic, 'host copy', 'omitted keeps');
+    state = reduce(state, setVendorBlocked({ vendor: 'anthropic', blocked: true, reason: null }));
+    assert.is(state.blockedVendorReasons.anthropic, undefined, 'null clears');
+});
+Suite('releasing a vendor drops it and its copy', () => {
+    let state = reduce(createDefaultSessionState(), setVendorBlocked({ vendor: 'anthropic', blocked: true, reason: 'r' }));
+    state = reduce(state, setVendorBlocked({ vendor: 'gemini', blocked: true }));
+    state = reduce(state, setVendorBlocked({ vendor: 'anthropic', blocked: false }));
+    assert.equal(state.blockedVendors, ['gemini']);
+    assert.is(state.blockedVendorReasons.anthropic, undefined);
+});
+Suite('setBlocked(false) also clears every per-vendor latch', () => {
+    // THE back-compat rule. A host asserting "the wall is gone" after its own
+    // pre-flight (migration-GENC-1464 Option B) must not be overruled by a driver
+    // latch it cannot see — without this, per-vendor would silently make the
+    // documented unblock stop working.
+    let state = reduce(createDefaultSessionState(), setVendorBlocked({ vendor: 'anthropic', blocked: true, reason: 'r' }));
+    state = reduce(state, setBlocked({ blocked: true, reason: 'global' }));
+    state = reduce(state, setBlocked({ blocked: false }));
+    assert.is(state.blocked, false);
+    assert.is(state.blockedReason, null);
+    assert.equal(state.blockedVendors, []);
+    assert.equal(state.blockedVendorReasons, {});
+});
+Suite('setBlockedReason writes the copy without disturbing any latch', () => {
+    // It exists precisely so the element's `blockedReason` setter cannot route
+    // through `setBlocked(false, …)` — which would now clear the vendor latches.
+    let state = reduce(createDefaultSessionState(), setVendorBlocked({ vendor: 'gemini', blocked: true }));
+    state = reduce(state, setBlockedReason('host copy'));
+    assert.is(state.blockedReason, 'host copy');
+    assert.is(state.blocked, false, 'the vendor-agnostic flag is untouched');
+    assert.equal(state.blockedVendors, ['gemini'], 'and so are the per-vendor latches');
+});
+Suite('resetSession preserves the per-vendor latches too', () => {
+    let state = reduce(createDefaultSessionState(), setVendorBlocked({ vendor: 'anthropic', blocked: true, reason: 'no funds' }));
+    state = reduce(state, setMessages([{ role: 'user', content: 'hi' }]));
+    const cleared = reduce(state, resetSession());
+    assert.equal(cleared.messages, [], 'the conversation is wiped');
+    assert.equal(cleared.blockedVendors, ['anthropic'], 'Clear does not refill a vendor budget');
+    assert.equal(cleared.blockedVendorReasons, { anthropic: 'no funds' });
+});
+// `resetSession` preserves its keys through `Object.assign`, whose source parameter
+// is structurally permissive: a typo like `blockedResaon` would compile clean,
+// silently stop preserving the real key, AND leak a junk key into serialised state.
+// The reducer therefore annotates its literal `satisfies
+// Partial<AiAssistantSessionState>`, which is a COMPILE-time guarantee — so the
+// durable proof is a type fixture, not a runtime assertion.
+//
+// This mirrors the reducer's clause on the same typo. If `satisfies` ever stopped
+// rejecting excess properties (a TS behaviour change, or someone widening the
+// annotated type), the `@ts-expect-error` below becomes unused and the BUILD fails
+// — which is exactly the signal wanted. The runtime suites above are its
+// behavioural companions: they pin the preserved list from both sides.
+const _typoIsRejectedAtCompileTime = {
+    // @ts-expect-error — an excess/misspelled key must be rejected by `satisfies`
+    blockedResaon: null,
+};
+void _typoIsRejectedAtCompileTime;
 Suite.run();

package/dist/esm/state/debug-event-log.js

@@ -189,7 +189,12 @@ export function clearSession(key) {
  * Human/agent-facing guide emitted as the first key of the exported debug log,
  * so whoever opens the JSON (often an AI agent) knows how to read it without
  * reverse-engineering the shape. Kept here next to the event catalogue it
- * describes so the two stay in sync.
+ * describes — but proximity alone demonstrably did NOT keep the two in sync
+ * (`refusal` was missing from both reason lists for a whole release), so
+ * `debug-event-log.test.ts` now asserts that every `TurnFailureReason` and every
+ * `SubAgentFailureReason` is named here, and fails the build when one is added
+ * without a matching sentence. Enumerations below read as exhaustive and WILL be
+ * trusted by an agent reading the JSON — keep them so.
  */
 export const DEBUG_LOG_README = [
     'This is an exported debug log for the Genesis AI assistant. Read it top-to-bottom.',
@@ -201,7 +206,7 @@ export const DEBUG_LOG_README = [
     "kind:'turn'.`agentSnapshot` — the active agent's own view of its internal state, captured at that turn. An agent opts into this by exposing a `getDebugSnapshot()` that returns JSON-serializable per-state info; stateful/flow agents wire it automatically, so you can watch a flow advance turn-by-turn (e.g. current step, cursor, collected fields, pending changes). Absent for agents that don't expose one.",
     "kind:'event' — a meta/lifecycle event. `type` names it (see below); `detail` carries structured data. `detail.placement` is the emitting UI instance: 'bubble' (collapsed), 'panel' (popped-out), or 'standalone'.",
     "Each 'event' also has an `importance`: 'high' (failures/limits — turn.error, tool.failed, subagent.failed, file.read-failed, suggestions.failed, context.threshold-crossed), 'normal' (session flow — connects, turns, retries, handoffs, agent/provider changes, interactions, sub-agent start/complete), or 'low' (skippable UI/bookkeeping noise — panel.toggled, attachment.added, driver.wired/unwired, context.updated, context.condensed). To skim, ignore importance:'low'; to triage a failure, filter to importance:'high' then read the nearby messages and turns. A 'high' turn.error is often preceded by one or more 'normal' turn.retry events for the same reason — read them together to see how many attempts were made before bailing. 'message' and 'turn' entries carry no importance — they are the substance, always read them.",
-    'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), provider.selected (model/provider for the upcoming turns), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
+    'Event types: assistant.connected/disconnected (mount + placement + whether the session was created or restored), assistant.popout/popin (window placement), driver.created/wired/unwired (which driver is live and why it stops/starts responding across a popout), state.changed (idle↔loading), turn.start/turn.end (turn boundary; turn.end carries durationMs), turn.retry (a recoverable in-turn retry — detail.reason plus attempt/maxAttempts; for malformed calls also finishMessage; for empty responses also the provider finishReason + thoughtsTokens + parts breakdown), turn.error (a turn failed or hit a guardrail — detail.reason is one of exception/malformed-function-call/empty-response/unknown-tool-limit/max-iterations/response-truncated/refusal/budget-exhausted, plus reason-specific diagnostics: attempts (for empty-response also finishReason + thoughtsTokens + a parts breakdown, distinguishing a thinking-only STOP from a truly empty turn), finishMessage, for response-truncated the model + maxTokens + outputTokens + tools, unknownTools (split into staleTools — real earlier this activation but retired by the current state or hidden behind an open exclusive fold — and hallucinatedTools — never advertised) + availableTools, iterations + limit, for budget-exhausted the budgetUsd + spentUsd figures reported by the proxy plus the resolved vendor, or name + message for exceptions), tool.failed (a tool threw), tool.unresolved (the model called a tool that could not be dispatched — detail.kind is folded/fold-hidden/stale/unknown, plus tool + agent and, for the counted kinds, the consecutive streak; the recurring lead-up to an unknown-tool-limit turn.error), subagent.started/completed/failed (the lifecycle of a `requestSubAgent` delegation — detail.agent names the sub-agent; these bracket the sub-agent turns that appear as kind:turn entries with an N-M `turnIndex`; subagent.failed also carries detail.reason, one of max_iterations/malformed_tool_call/empty_response/unknown_tool_limit/timeout/response_truncated/refusal/budget_exhausted; budget_exhausted is terminal for the PARENT turn too — the parent stops rather than calling the model again into the same wall), agent.handoff (routing; from=null is the initial activation), agent.pinned/unpinned (forced routing), provider.selected (model/provider for the upcoming turns), interaction.requested/resolved (blocking user widgets — explain quiet gaps; note that when a sub-agent opens a widget, detail.agent — and the agentName on the interaction message — is the HOST agent that owns the widget, NOT the sub-agent that asked, because widgets render and resolve on the host driver), context.updated/threshold-crossed (token + cost), context.condensed (a stale tool payload was collapsed out of the model-bound history by a `condenseWhen` declaration on the tool — detail.tool + toolCallId, target args|response, trigger (superseded:<key> or age:<n>), stubLen, and an estimated tokensSaved; stored history and this log keep the FULL payload, so the model-visible slice at any point is the full history minus the condensations recorded up to then), panel.toggled, attachment.added, file.read-failed, suggestions.failed.',
     'Sub-agent meta events: a sub-agent\'s own turn.retry/turn.error/tool.failed/tool.unresolved events are merged into this same timeline, tagged with `detail.subAgent` — a `"<parent> › <sub-agent>"` breadcrumb that composes when nested (e.g. `"UI Builder › Planner › Grounding"`) — and interleaved by their original timestamps within the subagent.started→completed/failed bracket. These are the per-attempt/per-failure signals that do NOT appear among the sub-agent\'s (hoisted) messages: a malformed/empty attempt that gets retried produces no message, and the stale-vs-hallucinated split and streak counts live only on the event. A sub-agent\'s high-volume, message-derivable events (turn.start/turn.end, provider.selected, context.updated) are intentionally NOT merged — read its hoisted messages for model/tokens/cost and turn-by-turn activity, and the bracketing subagent.* events for the run\'s span.',
     "`meta` holds context captured at export time: agentSummary (full agent configs), context (active model, token usage, session cost), activeDebugSnapshot (the active agent's `getDebugSnapshot()` taken fresh at export — reflects state NOW, which may have advanced beyond the last turn's agentSnapshot), debug (optional host-supplied debug state), host, and the export timestamp.",
     'To debug a failure: find the last turn.error or tool.failed, then read upward for the user message, the turn(s), and the agent/provider/state events that led into it.',

package/dist/esm/state/debug-event-log.test.js

@@ -1,5 +1,5 @@
 import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { clearMetaEventRegistry, clearSession, getMetaEvents, mergeMetaEvents, recordMetaEvent, } from './debug-event-log';
+import { clearMetaEventRegistry, clearSession, DEBUG_LOG_README, getMetaEvents, mergeMetaEvents, recordMetaEvent, } from './debug-event-log';
 const event = (overrides = {}) => (Object.assign({ index: 0, timestamp: '2026-06-19T16:00:00.000Z', type: 'turn.retry', importance: 'normal' }, overrides));
 const suite = createLogicSuite('debug-event-log merge/clear');
 suite('mergeMetaEvents is a no-op for an empty batch', () => {
@@ -64,4 +64,52 @@ suite('clearSession drops one key without touching others', () => {
     assert.is(getMetaEvents('child').length, 0);
     assert.is(getMetaEvents('parent').length, 1);
 });
+// ── README ↔ taxonomy sync (GENC-1464) ─────────────────────────────────────────
+// DEBUG_LOG_README is emitted as the FIRST key of the exported debug log
+// specifically so an agent reading the JSON does not have to reverse-engineer it.
+// Its reason enumerations therefore read as exhaustive and will be trusted — but
+// they had already drifted twice (`refusal` was missing from both) before anyone
+// noticed, because "the doc lives next to the catalogue" is not enforcement.
+//
+// The `Record<..., true>` below is the enforcement: adding a union member without
+// listing it here is a COMPILE error, and listing it without documenting it is a
+// test failure. So the next added reason fails in the one place the drift keeps
+// happening.
+const ALL_TURN_FAILURE_REASONS = Object.keys({
+    exception: true,
+    'malformed-function-call': true,
+    'empty-response': true,
+    'unknown-tool-limit': true,
+    'max-iterations': true,
+    'response-truncated': true,
+    refusal: true,
+    'budget-exhausted': true,
+});
+const ALL_SUB_AGENT_FAILURE_REASONS = Object.keys({
+    max_iterations: true,
+    malformed_tool_call: true,
+    empty_response: true,
+    unknown_tool_limit: true,
+    timeout: true,
+    response_truncated: true,
+    refusal: true,
+    budget_exhausted: true,
+});
+const README_TEXT = DEBUG_LOG_README.join('\n');
+suite('DEBUG_LOG_README enumerates every TurnFailureReason', () => {
+    for (const reason of ALL_TURN_FAILURE_REASONS) {
+        assert.ok(README_TEXT.includes(reason), `turn.error reason '${reason}' is missing from DEBUG_LOG_README`);
+    }
+});
+suite('DEBUG_LOG_README enumerates every SubAgentFailureReason', () => {
+    for (const reason of ALL_SUB_AGENT_FAILURE_REASONS) {
+        assert.ok(README_TEXT.includes(reason), `subagent.failed reason '${reason}' is missing from DEBUG_LOG_README`);
+    }
+});
+suite('DEBUG_LOG_README documents the budget diagnostics that ride turn.error', () => {
+    // `recordTurnError('budget-exhausted', …)` attaches these; an agent triaging a
+    // support ticket needs to know to look for them.
+    assert.ok(README_TEXT.includes('budgetUsd'));
+    assert.ok(README_TEXT.includes('spentUsd'));
+});
 suite.run();

package/dist/esm/state/persistence/session-snapshot.test.js

@@ -25,6 +25,24 @@ Suite('createPersistedSession stamps version + savedAt and keeps agentSnapshots'
     assert.ok(s.savedAt.length > 0);
     assert.equal(s.agentSnapshots, { A: { machine: { state: 'x', context: {} } } });
 });
+// GENC-1464 — the blocked latch is deliberately NOT persisted. The snapshot is
+// per-stateKey and long-lived, so a persisted latch would survive an out-of-band
+// budget raise with no in-element way to clear it: the user would return to a
+// permanently dead composer against a budget that has headroom. Re-deriving the
+// state (host pre-flight on mount, or the next 402) is strictly safer than
+// remembering it. This test exists so a future "helpful" addition trips here and
+// has to read that reasoning first — see `FoundationAiAssistant.blocked`'s
+// Lifetime paragraph and docs/migration-GENC-1464.md §Scope.
+Suite('the blocked latch is deliberately not persisted', () => {
+    const s = base();
+    assert.not.ok('blocked' in s, 'blocked must not enter the persisted snapshot');
+    assert.not.ok('blockedReason' in s, 'blockedReason must not enter the persisted snapshot');
+    // The per-vendor latches inherit the same lifetime, so they inherit the same
+    // rule — a persisted per-vendor wall is exactly as stale as a persisted global
+    // one, just harder to notice because only one vendor looks broken.
+    assert.not.ok('blockedVendors' in s, 'blockedVendors must not enter the persisted snapshot');
+    assert.not.ok('blockedVendorReasons' in s, 'blockedVendorReasons must not enter the persisted snapshot');
+});
 Suite('createPersistedSession defaults agentSnapshots to {}', () => {
     const s = createPersistedSession({
         sessionKey: 'k',

package/dist/esm/utils/banked-usage-baselines.js

@@ -0,0 +1,84 @@
+/**
+ * Per-session banked baselines for the cost ledger (GENC-1475) — the spend a project had
+ * accrued *before* the transcript currently in memory. Module-level and keyed by the session
+ * `stateKey`, exactly like the diagnostics cursors and the meta-event buffer.
+ *
+ * The lifetime is the point of this module. A baseline is only meaningful paired with the
+ * transcript it complements: `row.usage = baseline + whatever that transcript proves`. The
+ * transcript lives in the per-key session store, so the baseline must live and die with that
+ * store — which means module state keyed the same way, NOT element state.
+ *
+ * Held on the element it silently double-counted. Element instances are created and destroyed
+ * many times inside one session (the assistant is remounted as the host re-renders its layout,
+ * and a popped-out bubble and a docked panel can be wired to the same session at once), and each
+ * new instance re-derived the baseline from the ledger rows. By then those rows contain the
+ * instance-before-last's own upserts, whose `usage` already includes the live transcript — so
+ * where the transcript is NOT restored on load (`resolveBankedUsage`'s "bank the whole prior
+ * total" branch, i.e. persistence off) the live session was banked as its own baseline. Lifetime
+ * then jumped by the whole session-to-date on every remount while the live figure kept climbing
+ * normally, which is the "the two totals went up by different amounts" report.
+ *
+ * Module state dies with the JS realm, so a real page reload starts clean — exactly right, since
+ * that is also when the transcript starts over.
+ *
+ * @internal
+ */
+const baselinesByKey = new Map();
+/**
+ * The baseline resolved for `key`, or `undefined` when this session has not resolved one yet.
+ *
+ * `undefined` rather than an empty usage: "nothing banked" is a legitimate resolved value (a
+ * project's first ever session), and it must not be mistaken for "not resolved", or every write
+ * would re-derive and hit the double-count above.
+ *
+ * Returns a copy — see `setBankedBaseline` for why both ends of this map are cloned.
+ *
+ * @internal
+ */
+export function getBankedBaseline(key) {
+    const usage = baselinesByKey.get(key);
+    return usage ? Object.assign({}, usage) : undefined;
+}
+/**
+ * Record the baseline for `key`, replacing any previous one.
+ *
+ * Stores a copy, and `getBankedBaseline` hands back a copy, so nothing outside this module can
+ * reach the object the map holds. Both ends have to clone, because a baseline is aliased at both:
+ * `resolveBankedUsage` returns a *reference into a ledger row* (`row.banked` or `row.usage`),
+ * which is what gets stored here, and the caller then assigns what it reads back onto the NEXT
+ * row's `banked` field. Uncloned, one object is reachable from page-global state, two rows, and —
+ * since the row list is public and gets handed to a host's `saveCostHistory` — from host code.
+ * Whoever mutated it would silently rewrite this project's baseline for the rest of the page.
+ *
+ * A shallow spread is a complete copy: `AggregateUsage` is five flat numbers, no nested state.
+ *
+ * @internal
+ */
+export function setBankedBaseline(key, usage) {
+    baselinesByKey.set(key, Object.assign({}, usage));
+}
+/**
+ * Drop the baseline for `key`, so the next write re-derives it from the ledger rows.
+ *
+ * For when the pairing is broken deliberately at the *row* end — the row this baseline came from
+ * has been deleted, or the whole ledger cleared — and for a session teardown, where the store
+ * (and with it the transcript) is disposed and a later return re-restores from scratch.
+ *
+ * NOT for a mid-session reload of the rows: those rows already include this session's own
+ * upserts, so re-deriving from them folds the live transcript into its own baseline.
+ *
+ * @internal
+ */
+export function deleteBankedBaseline(key) {
+    baselinesByKey.delete(key);
+}
+/**
+ * Forget every baseline — the page-load boundary, which production gets for free from module
+ * state dying with the realm. Exists so tests can model separate page loads (and so one test's
+ * session key cannot leak a baseline into the next).
+ *
+ * @internal
+ */
+export function resetBankedBaselines() {
+    baselinesByKey.clear();
+}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/chat-driver-node.ts","../src/index.ts","../src/channel/ai-activity-bus.ts","../src/channel/ai-activity-channel.ts","../src/components/flowing-waves-indicator.ts","../src/components/halo-overlay.ts","../src/components/plasma-orb-indicator.ts","../src/components/waves-indicator.ts","../src/components/activity-halo/activity-halo.ts","../src/components/agent-picker/agent-picker.constants.ts","../src/components/agent-picker/agent-picker.styles.ts","../src/components/agent-picker/agent-picker.template.ts","../src/components/agent-picker/agent-picker.ts","../src/components/agent-picker/index.ts","../src/components/ai-driver/ai-driver.ts","../src/components/ai-driver/index.ts","../src/components/chat-bubble/chat-bubble.styles.ts","../src/components/chat-bubble/chat-bubble.template.ts","../src/components/chat-bubble/chat-bubble.ts","../src/components/chat-bubble/index.ts","../src/components/chat-driver/align-event-globals.ts","../src/components/chat-driver/chat-driver.compact.test.ts","../src/components/chat-driver/chat-driver.test.ts","../src/components/chat-driver/chat-driver.ts","../src/components/chat-driver/index.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.styles.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.template.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.test.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.ts","../src/components/chat-interaction-wrapper/index.ts","../src/components/chat-markdown/chat-markdown.ts","../src/components/chat-markdown/index.ts","../src/components/orchestrating-driver/index.ts","../src/components/orchestrating-driver/orchestrating-driver.pin.test.ts","../src/components/orchestrating-driver/orchestrating-driver.ts","../src/components/popout-manager/index.ts","../src/components/popout-manager/popout-manager.ts","../src/components/settings-modal/index.ts","../src/components/settings-modal/settings-modal.styles.ts","../src/components/settings-modal/settings-modal.template.ts","../src/config/config.ts","../src/config/define-stateful-agent.test.ts","../src/config/define-stateful-agent.ts","../src/config/fallback-agents.ts","../src/config/index.ts","../src/config/validate-providers.test.ts","../src/config/validate-providers.ts","../src/main/cost-session-banking.test.ts","../src/main/index.ts","../src/main/main.styles.ts","../src/main/main.template.ts","../src/main/main.ts","../src/main/main.types.ts","../src/main/popout-interaction-gate.test.ts","../src/provider/ai-provider-switcher.ts","../src/provider/assistant-app-settings.ts","../src/state/ai-assistant-slice.test.ts","../src/state/ai-assistant-slice.ts","../src/state/debug-event-log.test.ts","../src/state/debug-event-log.ts","../src/state/driver-registry.test.ts","../src/state/driver-registry.ts","../src/state/interaction-context.test.ts","../src/state/interaction-context.ts","../src/state/session-store.ts","../src/state/persistence/build-timeline-entries.ts","../src/state/persistence/diagnostics-cursors.test.ts","../src/state/persistence/diagnostics-cursors.ts","../src/state/persistence/diagnostics.test.ts","../src/state/persistence/diagnostics.ts","../src/state/persistence/index.ts","../src/state/persistence/persister-registry.ts","../src/state/persistence/session-persistence-provider.test.ts","../src/state/persistence/session-persistence-provider.ts","../src/state/persistence/session-persistence.integration.test.ts","../src/state/persistence/session-persister.test.ts","../src/state/persistence/session-persister.ts","../src/state/persistence/session-snapshot.test.ts","../src/state/persistence/session-snapshot.ts","../src/state/persistence/stateful-restore.e2e.test.ts","../src/styles/ai-colours.ts","../src/styles/settings-section.ts","../src/suggestions/chat-suggestions.ts","../src/tags/index.ts","../src/types/ai-chat-widget.ts","../src/types/interaction-context.ts","../src/utils/animated-panel-toggle.ts","../src/utils/animation-exclusivity.test.ts","../src/utils/animation-exclusivity.ts","../src/utils/collect-session-models.test.ts","../src/utils/collect-session-models.ts","../src/utils/condense-history.test.ts","../src/utils/condense-history.ts","../src/utils/cost-session-history.test.ts","../src/utils/cost-session-history.ts","../src/utils/derive-cost-session-title.test.ts","../src/utils/derive-cost-session-title.ts","../src/utils/flatten-sub-agent-messages.test.ts","../src/utils/flatten-sub-agent-messages.ts","../src/utils/history-transform.test.ts","../src/utils/history-transform.ts","../src/utils/index.ts","../src/utils/logger.ts","../src/utils/message-partition.test.ts","../src/utils/message-partition.ts","../src/utils/resolve-cost-history-config.test.ts","../src/utils/resolve-cost-history-config.ts","../src/utils/resolve-preference-baseline.test.ts","../src/utils/resolve-preference-baseline.ts","../src/utils/strip-agent-handlers.test.ts","../src/utils/strip-agent-handlers.ts","../src/utils/sum-costs.test.ts","../src/utils/sum-costs.ts","../src/utils/sum-tokens.test.ts","../src/utils/sum-tokens.ts","../src/utils/sum-usage.test.ts","../src/utils/sum-usage.ts","../src/utils/tool-fold.ts","../src/utils/with-timeout.ts"],"version":"5.9.2"}
+{"root":["../src/chat-driver-node.ts","../src/index.ts","../src/channel/ai-activity-bus.ts","../src/channel/ai-activity-channel.ts","../src/components/flowing-waves-indicator.ts","../src/components/halo-overlay.ts","../src/components/plasma-orb-indicator.ts","../src/components/waves-indicator.ts","../src/components/activity-halo/activity-halo.ts","../src/components/agent-picker/agent-picker.constants.ts","../src/components/agent-picker/agent-picker.styles.ts","../src/components/agent-picker/agent-picker.template.ts","../src/components/agent-picker/agent-picker.ts","../src/components/agent-picker/index.ts","../src/components/ai-driver/ai-driver.ts","../src/components/ai-driver/index.ts","../src/components/chat-bubble/chat-bubble.styles.ts","../src/components/chat-bubble/chat-bubble.template.ts","../src/components/chat-bubble/chat-bubble.ts","../src/components/chat-bubble/index.ts","../src/components/chat-driver/align-event-globals.ts","../src/components/chat-driver/chat-driver.compact.test.ts","../src/components/chat-driver/chat-driver.test.ts","../src/components/chat-driver/chat-driver.ts","../src/components/chat-driver/index.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.styles.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.template.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.test.ts","../src/components/chat-interaction-wrapper/chat-interaction-wrapper.ts","../src/components/chat-interaction-wrapper/index.ts","../src/components/chat-markdown/chat-markdown.ts","../src/components/chat-markdown/index.ts","../src/components/orchestrating-driver/index.ts","../src/components/orchestrating-driver/orchestrating-driver.budget.test.ts","../src/components/orchestrating-driver/orchestrating-driver.pin.test.ts","../src/components/orchestrating-driver/orchestrating-driver.ts","../src/components/popout-manager/index.ts","../src/components/popout-manager/popout-manager.ts","../src/components/settings-modal/index.ts","../src/components/settings-modal/settings-modal.styles.ts","../src/components/settings-modal/settings-modal.template.ts","../src/config/config.ts","../src/config/define-stateful-agent.test.ts","../src/config/define-stateful-agent.ts","../src/config/fallback-agents.ts","../src/config/index.ts","../src/config/validate-providers.test.ts","../src/config/validate-providers.ts","../src/main/blocked-state.test.ts","../src/main/cost-session-banking.test.ts","../src/main/index.ts","../src/main/main.styles.test.ts","../src/main/main.styles.ts","../src/main/main.template.ts","../src/main/main.ts","../src/main/main.types.ts","../src/main/popout-interaction-gate.test.ts","../src/provider/ai-provider-switcher.ts","../src/provider/assistant-app-settings.ts","../src/state/ai-assistant-slice.test.ts","../src/state/ai-assistant-slice.ts","../src/state/debug-event-log.test.ts","../src/state/debug-event-log.ts","../src/state/driver-registry.test.ts","../src/state/driver-registry.ts","../src/state/interaction-context.test.ts","../src/state/interaction-context.ts","../src/state/session-store.ts","../src/state/persistence/build-timeline-entries.ts","../src/state/persistence/diagnostics-cursors.test.ts","../src/state/persistence/diagnostics-cursors.ts","../src/state/persistence/diagnostics.test.ts","../src/state/persistence/diagnostics.ts","../src/state/persistence/index.ts","../src/state/persistence/persister-registry.ts","../src/state/persistence/session-persistence-provider.test.ts","../src/state/persistence/session-persistence-provider.ts","../src/state/persistence/session-persistence.integration.test.ts","../src/state/persistence/session-persister.test.ts","../src/state/persistence/session-persister.ts","../src/state/persistence/session-snapshot.test.ts","../src/state/persistence/session-snapshot.ts","../src/state/persistence/stateful-restore.e2e.test.ts","../src/styles/ai-colours.ts","../src/styles/settings-section.ts","../src/suggestions/chat-suggestions.ts","../src/tags/index.ts","../src/types/ai-chat-widget.ts","../src/types/interaction-context.ts","../src/utils/animated-panel-toggle.ts","../src/utils/animation-exclusivity.test.ts","../src/utils/animation-exclusivity.ts","../src/utils/banked-usage-baselines.ts","../src/utils/collect-session-models.test.ts","../src/utils/collect-session-models.ts","../src/utils/condense-history.test.ts","../src/utils/condense-history.ts","../src/utils/cost-session-history.test.ts","../src/utils/cost-session-history.ts","../src/utils/derive-cost-session-title.test.ts","../src/utils/derive-cost-session-title.ts","../src/utils/flatten-sub-agent-messages.test.ts","../src/utils/flatten-sub-agent-messages.ts","../src/utils/history-transform.test.ts","../src/utils/history-transform.ts","../src/utils/index.ts","../src/utils/logger.ts","../src/utils/message-partition.test.ts","../src/utils/message-partition.ts","../src/utils/resolve-cost-history-config.test.ts","../src/utils/resolve-cost-history-config.ts","../src/utils/resolve-preference-baseline.test.ts","../src/utils/resolve-preference-baseline.ts","../src/utils/strip-agent-handlers.test.ts","../src/utils/strip-agent-handlers.ts","../src/utils/sum-costs.test.ts","../src/utils/sum-costs.ts","../src/utils/sum-tokens.test.ts","../src/utils/sum-tokens.ts","../src/utils/sum-usage.test.ts","../src/utils/sum-usage.ts","../src/utils/tool-fold.ts","../src/utils/with-timeout.ts"],"version":"5.9.2"}