@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/dist/esm/main/popout-interaction-gate.test.js

@@ -1,54 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { FoundationAiAssistant } from './main';
-// Hold a reference so the custom-element registration isn't tree-shaken.
-FoundationAiAssistant;
-// GENC-1351 §5.11 (PR review): the single-element popout refactor removed the
-// `claimSideEffect` first-writer latch, so the only thing preventing a pending
-// interaction widget from being re-instantiated (and re-firing its side effect) on a
-// dock/undock move is that the popout control is disabled while an interaction is
-// pending — the template binds `?disabled=${x.hasActivePendingInteraction}`
-// (`main.template.ts`). This suite pins the GATE LOGIC (`hasActivePendingInteraction`)
-// that binding depends on, so a change to when the gate opens/closes is caught.
-//
-// Note: this deliberately does NOT mount the assistant. Mounting runs `connectedCallback`,
-// which subscribes to `agenticActivityBus` — opening a cross-tab `BroadcastChannel` in a browser
-// env and leaving the runner's event loop open. A getter-level test needs no mount and stays fast
-// + reliable. `document.createElement` only upgrades the element (constructor) — it does not
-// connect — so nothing subscribes, and the bus opens its channel lazily on first use, so none is
-// ever created here (no teardown needed).
-const Suite = createLogicSuite('FoundationAiAssistant popout interaction gate');
-/** A fresh (unconnected) element with a fake session store wired in. */
-function elementWith(state, messages) {
-    const el = document.createElement('foundation-ai-assistant');
-    el._sessionRef = {
-        store: { aiAssistant: { state, messages } },
-    };
-    return el;
-}
-const withInteraction = (resolved) => [
-    { role: 'user', content: 'hi' },
-    {
-        role: 'assistant',
-        content: resolved ? 'done' : '',
-        interaction: { interactionId: '1', componentName: 'x', data: {}, resolved },
-    },
-];
-Suite('is true only while a turn is running AND a pending interaction is the last message', () => {
-    // Gated: a turn is running and the last message is an unresolved interaction. This is
-    // the state during which the popout/dock control MUST be disabled.
-    assert.is(elementWith('loading', withInteraction(false)).hasActivePendingInteraction, true, 'busy + unresolved interaction → gated');
-    // `cancelling` counts as busy too (a stop was requested but the turn is winding down).
-    assert.is(elementWith('cancelling', withInteraction(false)).hasActivePendingInteraction, true, 'cancelling + unresolved interaction → gated');
-});
-Suite('is false when idle, when the interaction is resolved, or when there is none', () => {
-    // Not busy → never gated, even with an unresolved interaction present.
-    assert.is(elementWith('idle', withInteraction(false)).hasActivePendingInteraction, false, 'idle → not gated');
-    // Busy but the interaction has resolved → the widget is answered, nothing to strand.
-    assert.is(elementWith('loading', withInteraction({ value: 'ok' })).hasActivePendingInteraction, false, 'resolved interaction → not gated');
-    // Busy but the last message is not an interaction at all.
-    assert.is(elementWith('loading', [{ role: 'assistant', content: 'thinking' }])
-        .hasActivePendingInteraction, false, 'no interaction → not gated');
-    // No session / empty transcript.
-    assert.is(elementWith('loading', []).hasActivePendingInteraction, false, 'empty transcript → not gated');
-});
-Suite.run();

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

@@ -1,229 +0,0 @@
-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, 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', () => {
-    let start = createDefaultSessionState();
-    start = reduce(start, setState('loading')); // prove it overrides any prior state
-    const payload = {
-        // Usage rides on the message: `loadSession` derives the session totals from the
-        // restored transcript rather than from a stored counter, so the cost has to be in
-        // the messages for the assertion below to see it.
-        messages: [
-            { role: 'user', content: 'hi', cost: 1.25, inputTokens: 100, outputTokens: 20 },
-        ],
-        pinnedAgentName: 'Guided Booking',
-        flowOwnerAgentName: 'Guided Booking',
-        contextTokens: 1200,
-        contextLimit: 200000,
-        activeModel: 'claude-sonnet-4-6',
-        activeProviderName: 'anthropic',
-    };
-    const next = reduce(start, loadSession(payload));
-    assert.is(next.messages.length, 1);
-    assert.is(next.pinnedAgentName, 'Guided Booking');
-    assert.is(next.flowOwnerAgentName, 'Guided Booking');
-    assert.is(next.sessionUsage.costUsd, 1.25);
-    // Derived from the same walk: 100 prompt tokens with no cache split reported, so all
-    // of it is uncached input, plus the 20 generated.
-    assert.is(next.sessionUsage.uncachedInputTokens, 100);
-    assert.is(next.sessionUsage.outputTokens, 20);
-    assert.is(next.contextTokens, 1200);
-    assert.is(next.contextLimit, 200000);
-    assert.is(next.activeModel, 'claude-sonnet-4-6');
-    assert.is(next.activeProviderName, 'anthropic');
-    assert.is(next.state, 'idle');
-});
-Suite('resetSession wipes back to a fresh default', () => {
-    let state = createDefaultSessionState();
-    state = reduce(state, setMessages([{ role: 'user', content: 'x' }]));
-    state = reduce(state, loadSession({
-        messages: [],
-        pinnedAgentName: 'A',
-        flowOwnerAgentName: 'A',
-        contextTokens: 5,
-        contextLimit: 10,
-        activeModel: 'm',
-        activeProviderName: 'p',
-    }));
-    const cleared = reduce(state, resetSession());
-    assert.is(cleared.messages.length, 0);
-    assert.is(cleared.sessionUsage.costUsd, 0);
-    assert.is(cleared.pinnedAgentName, null);
-    assert.is(cleared.flowOwnerAgentName, null);
-    assert.is(cleared.contextTokens, undefined);
-    assert.is(cleared.state, 'idle');
-});
-Suite('resetSession preserves the user display preferences (they survive Clear)', () => {
-    // Display prefs are settings, not conversation state — Clear/New-chat must keep them
-    // (GENC-1351 #10). Turn several on, plus an animation, then reset.
-    let state = createDefaultSessionState();
-    state = reduce(state, setShowToolCalls(true));
-    state = reduce(state, setShowThinkingSteps(true));
-    state = reduce(state, setShowNarration(true));
-    state = reduce(state, setShowAgentSwitchIndicator(true));
-    state = reduce(state, setEnabledAnimations(['halo']));
-    state = reduce(state, setMessages([{ role: 'user', content: 'x' }]));
-    const cleared = reduce(state, resetSession());
-    // Conversation wiped…
-    assert.is(cleared.messages.length, 0, 'conversation cleared');
-    // …but the display prefs kept.
-    assert.is(cleared.showToolCalls, true);
-    assert.is(cleared.showThinkingSteps, true);
-    assert.is(cleared.showNarration, true);
-    assert.is(cleared.showAgentSwitchIndicator, true);
-    assert.equal(cleared.enabledAnimations, ['halo']);
-});
-Suite('createDefaultSessionState returns independent collections', () => {
-    // No aliasing between instances — resetSession must hand back a clean slate.
-    assert.ok(createDefaultSessionState().messages !== createDefaultSessionState().messages);
-});
-// GENC-1351 Phase 3: the lifecycle (session) menu open/close flag.
-Suite('setSessionMenuOpen toggles the lifecycle-menu flag; resetSession clears it', () => {
-    let state = createDefaultSessionState();
-    assert.is(state.sessionMenuOpen, false);
-    state = reduce(state, setSessionMenuOpen(true));
-    assert.is(state.sessionMenuOpen, true);
-    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.test.js

@@ -1,117 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-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', () => {
-    clearMetaEventRegistry();
-    mergeMetaEvents('k', []);
-    assert.is(getMetaEvents('k').length, 0);
-});
-suite('mergeMetaEvents preserves each event timestamp and re-indexes monotonically', () => {
-    clearMetaEventRegistry();
-    mergeMetaEvents('k', [
-        event({ index: 7, timestamp: '2026-06-19T16:00:01.000Z', detail: { a: 1 } }),
-        event({ index: 99, timestamp: '2026-06-19T16:00:02.000Z', detail: { b: 2 } }),
-    ]);
-    const out = getMetaEvents('k');
-    assert.is(out.length, 2);
-    // original timestamps kept (not re-stamped) ...
-    assert.is(out[0].timestamp, '2026-06-19T16:00:01.000Z');
-    assert.is(out[1].timestamp, '2026-06-19T16:00:02.000Z');
-    // ... indices re-assigned from the target's counter, not carried from source.
-    assert.is(out[0].index, 0);
-    assert.is(out[1].index, 1);
-    assert.equal(out[0].detail, { a: 1 });
-});
-suite('mergeMetaEvents appends after existing events with a continuing index', () => {
-    clearMetaEventRegistry();
-    recordMetaEvent('k', 'turn.start'); // index 0, real timestamp
-    mergeMetaEvents('k', [event({ type: 'turn.error', importance: 'high' })]);
-    const out = getMetaEvents('k');
-    assert.is(out.length, 2);
-    assert.is(out[0].type, 'turn.start');
-    assert.is(out[1].type, 'turn.error');
-    assert.is(out[1].index, 1); // continues the monotonic counter
-});
-suite('mergeMetaEvents into a fresh key creates the bucket', () => {
-    clearMetaEventRegistry();
-    mergeMetaEvents('brand-new', [event()]);
-    assert.is(getMetaEvents('brand-new').length, 1);
-});
-suite('mergeMetaEvents evicts oldest non-high events past the cap but keeps every high', () => {
-    clearMetaEventRegistry();
-    const highStamp = '2026-06-19T16:30:00.000Z';
-    // One `high` failure first, then a flood of `normal` events well past the cap.
-    const batch = [
-        event({ type: 'turn.error', importance: 'high', timestamp: highStamp }),
-    ];
-    for (let i = 0; i < 2000; i += 1) {
-        batch.push(event({ type: 'turn.retry', importance: 'normal' }));
-    }
-    mergeMetaEvents('k', batch);
-    const out = getMetaEvents('k');
-    // Eviction ran (bounded below what we merged) ...
-    assert.ok(out.length < 2001);
-    // ... and the lone high-importance failure was never dropped.
-    assert.is(out.filter((e) => e.importance === 'high').length, 1);
-    assert.ok(out.some((e) => e.timestamp === highStamp));
-});
-suite('clearSession drops one key without touching others', () => {
-    clearMetaEventRegistry();
-    recordMetaEvent('child', 'turn.retry');
-    recordMetaEvent('parent', 'turn.start');
-    clearSession('child');
-    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,
-    'provider-refused': 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,
-    provider_refused: 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/driver-registry.test.js

@@ -1,55 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { clearDriverRegistry, deleteDriver, getDriver, getDriverAgentsKey, getOrCreateDriver, } from './driver-registry';
-// Minimal stub — the registry only stores and returns the reference; it never
-// invokes driver methods, so an opaque object is sufficient.
-const stub = (id) => ({ id });
-const suite = createLogicSuite('driver-registry agents-key tracking');
-suite('getOrCreateDriver creates once and records the agents key', () => {
-    clearDriverRegistry();
-    const d = stub('a');
-    const created = getOrCreateDriver('k', 'agentsKeyA', () => d);
-    assert.is(created, d);
-    assert.is(getDriver('k'), d);
-    assert.is(getDriverAgentsKey('k'), 'agentsKeyA');
-});
-suite('reuse returns the existing driver and keeps its original agents key', () => {
-    clearDriverRegistry();
-    const first = stub('first');
-    getOrCreateDriver('k', 'agentsKeyA', () => first);
-    // A second component sharing the key, even with a different desired agents
-    // fingerprint, must NOT replace the driver or overwrite the recorded key.
-    let factoryCalled = false;
-    const reused = getOrCreateDriver('k', 'agentsKeyB', () => {
-        factoryCalled = true;
-        return stub('second');
-    });
-    assert.is(reused, first);
-    assert.is(factoryCalled, false);
-    assert.is(getDriverAgentsKey('k'), 'agentsKeyA');
-});
-suite('deleteDriver clears both the driver and its recorded agents key', () => {
-    clearDriverRegistry();
-    getOrCreateDriver('k', 'agentsKeyA', () => stub('a'));
-    deleteDriver('k');
-    assert.is(getDriver('k'), undefined);
-    assert.is(getDriverAgentsKey('k'), undefined);
-});
-suite('a rebuild under the same key records the new agents key (the adopt signal)', () => {
-    clearDriverRegistry();
-    // Initial driver, built for the old agent set.
-    getOrCreateDriver('k', 'old', () => stub('d-old'));
-    // Rebuild: the host deletes then recreates with the new fingerprint.
-    deleteDriver('k');
-    const rebuilt = stub('d-new');
-    getOrCreateDriver('k', 'new', () => rebuilt);
-    // GENC-1388: a sibling sharing the key can now detect that the registry driver
-    // already matches its desired agents and adopt `rebuilt`, rather than
-    // recreating (which would orphan a driver mid-turn).
-    assert.is(getDriver('k'), rebuilt);
-    assert.is(getDriverAgentsKey('k'), 'new');
-});
-suite('getDriverAgentsKey is undefined for an unknown key', () => {
-    clearDriverRegistry();
-    assert.is(getDriverAgentsKey('missing'), undefined);
-});
-suite.run();

package/dist/esm/state/interaction-context.test.js

@@ -1,78 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { createInteractionContext } from './interaction-context';
-const suite = createLogicSuite('interaction-context factory');
-suite('once runs the factory a single time and memoises the result', () => {
-    const { context } = createInteractionContext('id-1');
-    let calls = 0;
-    const first = context.once('ws', () => {
-        calls += 1;
-        return { socket: true };
-    });
-    const second = context.once('ws', () => {
-        calls += 1;
-        return { socket: false };
-    });
-    assert.is(calls, 1, 'factory ran once');
-    assert.is(second, first, 'the memoised value is returned on the second call');
-});
-suite('subscribe/notify fans out to listeners; unsubscribe stops them', () => {
-    const { context } = createInteractionContext('id-2');
-    let a = 0;
-    let b = 0;
-    const unsubA = context.subscribe(() => (a += 1));
-    context.subscribe(() => (b += 1));
-    context.notify();
-    assert.is(a, 1);
-    assert.is(b, 1);
-    unsubA();
-    context.notify();
-    assert.is(a, 1, 'unsubscribed listener no longer fires');
-    assert.is(b, 2, 'remaining listener still fires');
-});
-suite('a throwing subscriber does not stop the others', () => {
-    const { context } = createInteractionContext('id-3');
-    let reached = false;
-    context.subscribe(() => {
-        throw new Error('boom');
-    });
-    context.subscribe(() => (reached = true));
-    context.notify();
-    assert.ok(reached, 'later subscriber still ran after an earlier one threw');
-});
-suite('dispose runs every onDispose callback once, then is idempotent', () => {
-    const { context, dispose } = createInteractionContext('id-4');
-    let count = 0;
-    context.onDispose(() => (count += 1));
-    context.onDispose(() => (count += 1));
-    dispose();
-    assert.is(count, 2, 'both disposers ran');
-    dispose();
-    assert.is(count, 2, 'a second dispose is a no-op');
-});
-suite('onDispose registered after dispose runs immediately', () => {
-    const { context, dispose } = createInteractionContext('id-5');
-    dispose();
-    let ran = false;
-    context.onDispose(() => (ran = true));
-    assert.ok(ran, 'late onDispose runs immediately so no resource leaks');
-});
-suite('notify after dispose is a no-op (listeners cleared)', () => {
-    const { context, dispose } = createInteractionContext('id-6');
-    let fired = 0;
-    context.subscribe(() => (fired += 1));
-    dispose();
-    context.notify();
-    assert.is(fired, 0, 'no listeners fire after dispose');
-});
-suite('once after dispose returns null without running the factory', () => {
-    const { context, dispose } = createInteractionContext('id-7');
-    dispose();
-    let calls = 0;
-    const result = context.once('late', () => {
-        calls += 1;
-        return { socket: true };
-    });
-    assert.is(calls, 0, 'the factory never ran on an ended interaction (no leaked resource)');
-    assert.is(result, null, 'once returns null after dispose');
-});
-suite.run();

package/dist/esm/state/persistence/diagnostics-cursors.test.js

@@ -1,30 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { clearDiagnosticsCursorRegistry, deleteDiagnosticsCursorsFor, getDiagnosticsCursors, resetDiagnosticsCursorsFor, } from './diagnostics-cursors';
-// GENC-1351 §5.8/§5.12 (#9): the forward-capture cursors, and the crucial difference
-// between the Clear reset (keep the event high-water) and the in-place-switch delete
-// (fresh cursors, because the meta-event buffer is torn down and its indices restart).
-const KEY = 'session-1';
-const Suite = createLogicSuite('diagnostics-cursors');
-Suite.before.each(() => {
-    clearDiagnosticsCursorRegistry();
-});
-Suite('resetDiagnosticsCursorsFor KEEPS lastEventIndex (Clear: meta buffer keeps climbing)', () => {
-    const c = getDiagnosticsCursors(KEY);
-    c.lastEventIndex = 40;
-    c.emittedMsgKeys.add('m');
-    c.restoredMsgKeys.add('r');
-    resetDiagnosticsCursorsFor(KEY);
-    const after = getDiagnosticsCursors(KEY);
-    assert.is(after.lastEventIndex, 40, 'event high-water kept — Clear does not reset the meta buffer');
-    assert.is(after.emittedMsgKeys.size, 0, 'per-conversation message cursors restarted');
-    assert.is(after.restoredMsgKeys.size, 0, 'restore watermark restarted');
-});
-Suite('deleteDiagnosticsCursorsFor RESETS lastEventIndex (switch: meta buffer restarts at 0)', () => {
-    const c = getDiagnosticsCursors(KEY);
-    c.lastEventIndex = 40;
-    deleteDiagnosticsCursorsFor(KEY);
-    // A later return re-creates fresh cursors on first access.
-    const after = getDiagnosticsCursors(KEY);
-    assert.is(after.lastEventIndex, -1, 'fresh cursor — a returning session whose events restart at 0 is NOT skipped');
-});
-Suite.run();