@genesislcap/ai-assistant 15.6.2 → 15.7.0-ts7.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

@@ -137,7 +137,8 @@ export function recordTurnRetry(key, reason, detail) {
 }
 /** Returns the meta-event timeline for `key`, or an empty array if none recorded. */
 export function getMetaEvents(key) {
-    var _a, _b;
+    var _a;
+    var _b;
     return (_b = (_a = registry.get(key)) === null || _a === void 0 ? void 0 : _a.events) !== null && _b !== void 0 ? _b : [];
 }
 /**
@@ -189,7 +190,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 +207,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-persister.js

@@ -137,7 +137,8 @@ export class SessionPersister {
      */
     persistSession() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g;
+            var _a, _b, _c, _d;
+            var _e, _f, _g;
             const { provider, enabled } = this.deps.getPersistence();
             if (!enabled || !provider)
                 return;
@@ -149,7 +150,7 @@ export class SessionPersister {
             const s = ref.store.aiAssistant;
             // Strip the display-only restore notices (restored / couldn't-restore) so they
             // never persist or accumulate across reload→save→reload cycles.
-            const messages = ((_b = (_a = driver === null || driver === void 0 ? void 0 : driver.getRawHistory) === null || _a === void 0 ? void 0 : _a.call(driver)) !== null && _b !== void 0 ? _b : s.messages).filter((m) => !isSessionNoticeMarker(m));
+            const messages = ((_e = (_a = driver === null || driver === void 0 ? void 0 : driver.getRawHistory) === null || _a === void 0 ? void 0 : _a.call(driver)) !== null && _e !== void 0 ? _e : s.messages).filter((m) => !isSessionNoticeMarker(m));
             if (!messages.length)
                 return; // nothing worth persisting (e.g. a just-cleared session)
             // Serialize the live active agent from the DRIVER (the instance whose
@@ -157,7 +158,7 @@ export class SessionPersister {
             // mints fresh configs (the showcase) would otherwise hand us a never-activated
             // closure whose `serialize()` returns undefined.
             const liveSnapshots = {};
-            const liveActive = (_c = driver === null || driver === void 0 ? void 0 : driver.getActiveAgent) === null || _c === void 0 ? void 0 : _c.call(driver);
+            const liveActive = (_b = driver === null || driver === void 0 ? void 0 : driver.getActiveAgent) === null || _b === void 0 ? void 0 : _b.call(driver);
             if (liveActive === null || liveActive === void 0 ? void 0 : liveActive.serialize) {
                 try {
                     const snap = liveActive.serialize();
@@ -222,7 +223,7 @@ export class SessionPersister {
                     sessionKey: key,
                     host: window.location.host,
                     messages: keepThroughLastUserMessage(messages),
-                    activeAgentName: (_d = s.activeAgent) === null || _d === void 0 ? void 0 : _d.name,
+                    activeAgentName: (_c = s.activeAgent) === null || _c === void 0 ? void 0 : _c.name,
                     pinnedAgentName: s.pinnedAgentName,
                     flowOwnerAgentName: null,
                     sessionCostUsd: s.sessionUsage.costUsd,
@@ -233,7 +234,7 @@ export class SessionPersister {
                     agentSnapshots: {},
                 });
                 this.logMeta('persistence.suppressed', {
-                    agent: (_e = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _e !== void 0 ? _e : null,
+                    agent: (_f = liveActive === null || liveActive === void 0 ? void 0 : liveActive.name) !== null && _f !== void 0 ? _f : null,
                     isFlowOwner: s.flowOwnerAgentName === (liveActive === null || liveActive === void 0 ? void 0 : liveActive.name),
                     frozeAtMessages: frozen.messages.length,
                     custom: !!(liveActive === null || liveActive === void 0 ? void 0 : liveActive.notResumableMessage),
@@ -253,7 +254,7 @@ export class SessionPersister {
                 sessionKey: key,
                 host: window.location.host,
                 messages: [...messages],
-                activeAgentName: (_f = s.activeAgent) === null || _f === void 0 ? void 0 : _f.name,
+                activeAgentName: (_d = s.activeAgent) === null || _d === void 0 ? void 0 : _d.name,
                 pinnedAgentName: s.pinnedAgentName,
                 flowOwnerAgentName: s.flowOwnerAgentName,
                 sessionCostUsd: s.sessionUsage.costUsd,
@@ -291,7 +292,8 @@ export class SessionPersister {
      */
     restore() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
+            var _a, _b;
+            var _c, _d, _e;
             const { provider } = this.deps.getPersistence();
             if (!provider)
                 return;
@@ -351,7 +353,7 @@ export class SessionPersister {
                 // actually came back (meta events reset on reload, so this is the only window
                 // onto the saved→loaded handoff).
                 this.logMeta('persistence.restored', {
-                    agents: Object.keys((_b = snapshot.agentSnapshots) !== null && _b !== void 0 ? _b : {}),
+                    agents: Object.keys((_c = snapshot.agentSnapshots) !== null && _c !== void 0 ? _c : {}),
                     agentSnapshots: snapshot.agentSnapshots,
                     pinnedAgentName: snapshot.pinnedAgentName,
                     flowOwnerAgentName: snapshot.flowOwnerAgentName,
@@ -419,7 +421,7 @@ export class SessionPersister {
                 }
                 const messages = [...trimmed, ...trailers];
                 ref.actions.aiAssistant.loadSession(toLoadSessionPayload(Object.assign(Object.assign({}, snapshot), { messages })));
-                (_c = driver === null || driver === void 0 ? void 0 : driver.loadHistory) === null || _c === void 0 ? void 0 : _c.call(driver, [...messages]);
+                (_b = driver === null || driver === void 0 ? void 0 : driver.loadHistory) === null || _b === void 0 ? void 0 : _b.call(driver, [...messages]);
                 // Interrupted flow (§5.9): pre-fill the composer with the prompt that started
                 // the flow so "send it again" is one keystroke, and record it for observability.
                 if (snapshot.interrupted) {
@@ -538,7 +540,8 @@ export class SessionPersister {
      * diagnostics-capable provider, so it's free for other consumers.
      */
     scheduleDiagnostics() {
-        var _a, _b;
+        var _a;
+        var _b;
         const { provider } = this.deps.getPersistence();
         if (!(provider === null || provider === void 0 ? void 0 : provider.appendDiagnostics))
             return;

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

@@ -44,10 +44,11 @@ export function createPersistedSession(input) {
  * @internal
  */
 export function resolveNonResumableNotice(input) {
-    var _a, _b;
+    var _a;
+    var _b;
     const custom = input.notResumableMessage;
     const resumeMessage = custom && custom.trim() ? custom : input.defaultMessage;
-    const resumePrompt = (_a = input.flowActivationPrompt) !== null && _a !== void 0 ? _a : (_b = input.messages[lastUserMessageIndex(input.messages)]) === null || _b === void 0 ? void 0 : _b.content;
+    const resumePrompt = (_b = input.flowActivationPrompt) !== null && _b !== void 0 ? _b : (_a = input.messages[lastUserMessageIndex(input.messages)]) === null || _a === void 0 ? void 0 : _a.content;
     return { resumeMessage, resumePrompt };
 }
 /**

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/collect-session-models.test.js

@@ -28,7 +28,8 @@ suite('resolves vendor from providerStatuses when messages lack provider', () =>
     assert.is((_a = models[0]) === null || _a === void 0 ? void 0 : _a.provider, 'gemini');
 });
 suite('does not persist registry tier names as provider', () => {
-    var _a, _b;
+    var _a;
+    var _b;
     const models = collectSessionModels([assistantMsg({ model: 'gemini-3.1-flash-lite', providerName: 'low' })], []);
     assert.is((_a = models[0]) === null || _a === void 0 ? void 0 : _a.provider, undefined);
     assert.is('providerName' in ((_b = models[0]) !== null && _b !== void 0 ? _b : {}), false);

package/dist/esm/utils/condense-history.js

@@ -115,7 +115,8 @@ function marksDiscontinuity(kind) {
  * @param onCondensed - Invoked once per payload at its full→stub transition.
  */
 export function applyCondensation(history, policies, ctx, onCondensed) {
-    var _a, _b;
+    var _a;
+    var _b;
     if (policies.size === 0)
         return history;
     const triggersOf = (entry) => Array.isArray(entry.policy.on) ? entry.policy.on : [entry.policy.on];
@@ -126,7 +127,7 @@ export function applyCondensation(history, policies, ctx, onCondensed) {
     // Batch boundary: the collapse set is resolved as of this model-call and stays put
     // until the next boundary, so the prefix is append-only in between. `batchCalls` of 1
     // (the default) makes this `ctx.modelCall` — i.e. no batching.
-    const batchCalls = Math.max(1, Math.floor((_a = ctx.batchCalls) !== null && _a !== void 0 ? _a : 1));
+    const batchCalls = Math.max(1, Math.floor((_b = ctx.batchCalls) !== null && _b !== void 0 ? _b : 1));
     const asOf = batchCalls === 1 ? ctx.modelCall : Math.floor(ctx.modelCall / batchCalls) * batchCalls;
     // A call made after the boundary is invisible to this pass in BOTH directions: it
     // cannot supersede an older call (which would collapse the older payload early), and
@@ -137,7 +138,7 @@ export function applyCondensation(history, policies, ctx, onCondensed) {
     const latestByKey = new Map();
     const nameById = new Map();
     for (const msg of history) {
-        if (!((_b = msg.toolCalls) === null || _b === void 0 ? void 0 : _b.length))
+        if (!((_a = msg.toolCalls) === null || _a === void 0 ? void 0 : _a.length))
             continue;
         for (const tc of msg.toolCalls) {
             nameById.set(tc.id, tc.name);
@@ -174,7 +175,8 @@ export function applyCondensation(history, policies, ctx, onCondensed) {
     // and the event label. `undefined` means the payload stays full.
     const firstFired = (toolCallId, entry) => triggersOf(entry).find((t) => (marksDiscontinuity(t.kind) || withinBatch(entry)) && triggerFires(toolCallId, entry, t));
     return history.map((msg) => {
-        var _a, _b, _c, _d;
+        var _a, _b;
+        var _c, _d;
         // Tool-call ARGS live on the assistant message.
         if ((_a = msg.toolCalls) === null || _a === void 0 ? void 0 : _a.length) {
             let changed = false;

package/dist/esm/utils/condense-history.test.js

@@ -9,27 +9,21 @@ const toolMsg = (toolCallId, content) => ({
     content: '',
     toolResult: { toolCallId, content },
 });
-const reg = (policy, clocks = {}) => {
-    var _a, _b, _c, _d;
-    return ({
-        policy,
-        iteration: (_a = clocks.iteration) !== null && _a !== void 0 ? _a : 1,
-        turn: (_b = clocks.turn) !== null && _b !== void 0 ? _b : 1,
-        activation: (_c = clocks.activation) !== null && _c !== void 0 ? _c : 1,
-        phaseEpoch: (_d = clocks.phaseEpoch) !== null && _d !== void 0 ? _d : 1,
-    });
-};
+const reg = (policy, clocks = {}) => { var _a, _b, _c, _d; return ({
+    policy,
+    iteration: (_a = clocks.iteration) !== null && _a !== void 0 ? _a : 1,
+    turn: (_b = clocks.turn) !== null && _b !== void 0 ? _b : 1,
+    activation: (_c = clocks.activation) !== null && _c !== void 0 ? _c : 1,
+    phaseEpoch: (_d = clocks.phaseEpoch) !== null && _d !== void 0 ? _d : 1,
+}); };
 /** A CondenseContext for the pure transform. Defaults fire nothing; override per test. */
-const ctx = (o = {}) => {
-    var _a, _b, _c, _d;
-    return ({
-        modelCall: (_a = o.modelCall) !== null && _a !== void 0 ? _a : 0,
-        turn: (_b = o.turn) !== null && _b !== void 0 ? _b : 0,
-        activationEnded: (_c = o.activationEnded) !== null && _c !== void 0 ? _c : (() => false),
-        phaseEnded: (_d = o.phaseEnded) !== null && _d !== void 0 ? _d : (() => false),
-        batchCalls: o.batchCalls,
-    });
-};
+const ctx = (o = {}) => { var _a, _b, _c, _d; return ({
+    modelCall: (_a = o.modelCall) !== null && _a !== void 0 ? _a : 0,
+    turn: (_b = o.turn) !== null && _b !== void 0 ? _b : 0,
+    activationEnded: (_c = o.activationEnded) !== null && _c !== void 0 ? _c : (() => false),
+    phaseEnded: (_d = o.phaseEnded) !== null && _d !== void 0 ? _d : (() => false),
+    batchCalls: o.batchCalls,
+}); };
 const sink = () => {
     const events = [];
     return { events, on: (d) => events.push(d) };
@@ -353,7 +347,7 @@ const reReadLoop = (n) => {
     return { history, policies };
 };
 /** Result content of every tool message, in order. */
-const results = (out) => out.filter((m) => m.role === 'tool').map((m) => { var _a, _b; return (_b = (_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.content) !== null && _b !== void 0 ? _b : ''; });
+const results = (out) => out.filter((m) => m.role === 'tool').map((m) => { var _a; var _b; return (_b = (_a = m.toolResult) === null || _a === void 0 ? void 0 : _a.content) !== null && _b !== void 0 ? _b : ''; });
 batch('without batching every superseded read collapses immediately', () => {
     const { history, policies } = reReadLoop(4);
     const out = results(applyCondensation(history, policies, ctx({ modelCall: 4 }), sink().on));

package/dist/esm/utils/flatten-sub-agent-messages.js

@@ -30,9 +30,10 @@
  */
 export function flattenSubAgentMessages(messages, prefix = '', depth = 0, subAgentOf) {
     return messages.flatMap((m) => {
-        var _a, _b, _c;
-        const breadcrumb = prefix ? `${prefix} › ${(_a = m.agentName) !== null && _a !== void 0 ? _a : '?'}` : m.agentName;
-        const traceCalls = (_c = (_b = m.toolCalls) === null || _b === void 0 ? void 0 : _b.filter((tc) => { var _a; return (_a = tc.subAgentTrace) === null || _a === void 0 ? void 0 : _a.length; })) !== null && _c !== void 0 ? _c : [];
+        var _a;
+        var _b, _c;
+        const breadcrumb = prefix ? `${prefix} › ${(_b = m.agentName) !== null && _b !== void 0 ? _b : '?'}` : m.agentName;
+        const traceCalls = (_c = (_a = m.toolCalls) === null || _a === void 0 ? void 0 : _a.filter((tc) => { var _a; return (_a = tc.subAgentTrace) === null || _a === void 0 ? void 0 : _a.length; })) !== null && _c !== void 0 ? _c : [];
         const entry = Object.assign(Object.assign(Object.assign({ kind: 'message' }, m), (traceCalls.length > 0 && {
             toolCalls: m.toolCalls.map((tc) => tc.subAgentTrace ? Object.assign(Object.assign({}, tc), { subAgentTrace: undefined }) : tc),
         })), (depth > 0 && {

package/dist/esm/utils/history-transform.js

@@ -130,7 +130,8 @@ export function normalizeForProvider(history) {
 }
 /** Human-facing divider label for a `compacted-summary` message. */
 export function compactionDividerLabel(m) {
-    var _a, _b;
+    var _a;
+    var _b;
     const n = (_b = (_a = m.compaction) === null || _a === void 0 ? void 0 : _a.compactedCount) !== null && _b !== void 0 ? _b : 0;
     return `Compacted ${n} earlier message${n === 1 ? '' : 's'}`;
 }

package/dist/esm/utils/resolve-cost-history-config.js

@@ -1,6 +1,7 @@
 /** Resolve `chatConfig.costHistory` with defaults applied. */
 export function resolveCostHistoryConfig(chatConfig) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
+    var _d;
     const cost = chatConfig.costHistory;
     return {
         enabled: (cost === null || cost === void 0 ? void 0 : cost.enabled) === true,
@@ -8,7 +9,7 @@ export function resolveCostHistoryConfig(chatConfig) {
         scope: ((_b = cost === null || cost === void 0 ? void 0 : cost.scope) === null || _b === void 0 ? void 0 : _b.trim()) || undefined,
         showCost: (cost === null || cost === void 0 ? void 0 : cost.showCost) !== false,
         showTokens: (cost === null || cost === void 0 ? void 0 : cost.showTokens) !== false,
-        badgeLabel: (_c = cost === null || cost === void 0 ? void 0 : cost.badgeLabel) !== null && _c !== void 0 ? _c : 'Currently building',
-        summaryHint: ((_d = cost === null || cost === void 0 ? void 0 : cost.summaryHint) === null || _d === void 0 ? void 0 : _d.trim()) || undefined,
+        badgeLabel: (_d = cost === null || cost === void 0 ? void 0 : cost.badgeLabel) !== null && _d !== void 0 ? _d : 'Currently building',
+        summaryHint: ((_c = cost === null || cost === void 0 ? void 0 : cost.summaryHint) === null || _c === void 0 ? void 0 : _c.trim()) || undefined,
     };
 }

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

@@ -20,7 +20,8 @@ import { resolveExclusiveLoadingStyle } from './animation-exclusivity';
  * @internal
  */
 export function resolvePreferenceBaseline(ui, stored) {
-    var _a, _b;
+    var _a;
+    var _b;
     const u = ui !== null && ui !== void 0 ? ui : {};
     // Layer 1 — chatConfig.ui defaults.
     const baseline = {

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

@@ -91,7 +91,8 @@ function addInto(into, from) {
  * per-message allocation is worth avoiding.
  */
 function accumulate(messages, into) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a;
+    var _b, _c, _d, _e, _f;
     for (const m of messages) {
         // Provider/LLM cost plus any non-LLM cost a widget reported for its own
         // external service calls. Both are real spend on this session.
@@ -99,20 +100,20 @@ function accumulate(messages, into) {
             into.costUsd += m.cost;
         if (m.externalCostUsd != null)
             into.costUsd += m.externalCostUsd;
-        const cacheRead = (_a = m.cacheReadTokens) !== null && _a !== void 0 ? _a : 0;
-        const cacheWrite = (_b = m.cacheWriteTokens) !== null && _b !== void 0 ? _b : 0;
+        const cacheRead = (_b = m.cacheReadTokens) !== null && _b !== void 0 ? _b : 0;
+        const cacheWrite = (_c = m.cacheWriteTokens) !== null && _c !== void 0 ? _c : 0;
         into.cacheReadTokens += cacheRead;
         into.cacheWriteTokens += cacheWrite;
         // The uncached remainder of the prompt. Clamped at zero so malformed or
         // hand-edited history whose buckets exceed the prompt total can't drive the
         // session total negative — a wrong-but-plausible number is worse than a
         // conservative one here, since this feeds a cost display.
-        into.uncachedInputTokens += Math.max(0, ((_c = m.inputTokens) !== null && _c !== void 0 ? _c : 0) - cacheRead - cacheWrite);
-        into.outputTokens += (_d = m.outputTokens) !== null && _d !== void 0 ? _d : 0;
+        into.uncachedInputTokens += Math.max(0, ((_d = m.inputTokens) !== null && _d !== void 0 ? _d : 0) - cacheRead - cacheWrite);
+        into.outputTokens += (_e = m.outputTokens) !== null && _e !== void 0 ? _e : 0;
         // Spend banked by a compaction on this summary's behalf. NOTE: deliberately
         // not `compaction.tokensBefore` — that is a one-turn context-window reading,
         // not cumulative spend, and counting it here would inflate the total.
-        const rolled = (_e = m.compaction) === null || _e === void 0 ? void 0 : _e.rolledUpUsage;
+        const rolled = (_a = m.compaction) === null || _a === void 0 ? void 0 : _a.rolledUpUsage;
         if (rolled)
             addInto(into, rolled);
         for (const tc of (_f = m.toolCalls) !== null && _f !== void 0 ? _f : []) {