@genesislcap/ai-assistant 15.19.0 → 15.19.1

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

@@ -1,256 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { PERSISTED_SESSION_VERSION, createPersistedSession, isRestorableSession, reconcileAgentSnapshots, resolveNonResumableNotice, toLoadSessionPayload, keepThroughLastUserMessage, trimToRestorableBoundary, unknownAgentSnapshots, } from './session-snapshot';
-const asMsg = (o) => o;
-// GENC-1351 §5.1: the PersistedSession schema + its pure (de)serialize helpers.
-// These have no DOM/storage deps, so they run straight in Node.
-const Suite = createLogicSuite('persisted-session-schema');
-const base = () => createPersistedSession({
-    sessionKey: 'k',
-    host: 'app.example',
-    messages: [],
-    pinnedAgentName: 'A',
-    flowOwnerAgentName: null,
-    sessionCostUsd: 2,
-    contextTokens: 10,
-    contextLimit: 100,
-    activeModel: 'm',
-    activeProviderName: 'p',
-    activeAgentName: 'A',
-    agentSnapshots: { A: { machine: { state: 'x', context: {} } } },
-});
-Suite('createPersistedSession stamps version + savedAt and keeps agentSnapshots', () => {
-    const s = base();
-    assert.is(s.version, PERSISTED_SESSION_VERSION);
-    assert.is(typeof s.savedAt, 'string');
-    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',
-        host: 'h',
-        messages: [],
-        pinnedAgentName: null,
-        flowOwnerAgentName: null,
-        sessionCostUsd: 0,
-    });
-    assert.equal(s.agentSnapshots, {});
-});
-Suite('isRestorableSession accepts a matching version + host', () => {
-    assert.ok(isRestorableSession(base(), { host: 'app.example' }));
-});
-Suite('isRestorableSession rejects version mismatch, cross-host, and malformed input', () => {
-    assert.ok(!isRestorableSession(Object.assign(Object.assign({}, base()), { version: 999 }), { host: 'app.example' }));
-    assert.ok(!isRestorableSession(base(), { host: 'other.example' }));
-    assert.ok(!isRestorableSession(null, { host: 'h' }));
-    assert.ok(!isRestorableSession({ version: PERSISTED_SESSION_VERSION, host: 'h' }, { host: 'h' }), 'missing messages array → not restorable');
-});
-Suite('toLoadSessionPayload projects only the redux-restorable fields', () => {
-    const p = toLoadSessionPayload(base());
-    assert.is(p.pinnedAgentName, 'A');
-    assert.is(p.flowOwnerAgentName, null);
-    // Cost is deliberately NOT projected — the slice re-derives it (and the token
-    // buckets) from `messages`, so a stored counter would be a second, divergeable
-    // source of truth.
-    assert.is(p.sessionCostUsd, undefined);
-    assert.is(p.contextTokens, 10);
-    assert.is(p.contextLimit, 100);
-    assert.is(p.activeModel, 'm');
-    assert.is(p.activeProviderName, 'p');
-    assert.equal(p.messages, []);
-    // agentSnapshots + activeAgentName are applied by the host, not via the slice.
-    assert.ok(!('agentSnapshots' in p));
-    assert.ok(!('activeAgentName' in p));
-});
-Suite('trimToRestorableBoundary returns a clean transcript unchanged (same ref)', () => {
-    const clean = [
-        asMsg({ role: 'user', content: 'hi' }),
-        asMsg({ role: 'assistant', content: 'hello' }),
-    ];
-    assert.is(trimToRestorableBoundary(clean), clean);
-    assert.is(trimToRestorableBoundary([]).length, 0);
-});
-Suite('trimToRestorableBoundary drops a trailing unresolved interaction, keeps a resolved one', () => {
-    const user = asMsg({ role: 'user', content: 'hi' });
-    const pending = asMsg({
-        role: 'assistant',
-        content: '',
-        interaction: { interactionId: '2', componentName: 'x', data: {} },
-    });
-    const resolved = asMsg({
-        role: 'assistant',
-        content: '',
-        interaction: {
-            interactionId: '1',
-            componentName: 'x',
-            data: {},
-            resolved: { status: 'approved' },
-        },
-    });
-    assert.is(trimToRestorableBoundary([user, pending]).length, 1);
-    assert.is(trimToRestorableBoundary([user, resolved]).length, 2);
-});
-Suite('trimToRestorableBoundary drops dangling + partially-answered tool calls', () => {
-    const user = asMsg({ role: 'user', content: 'do x' });
-    const callAB = asMsg({
-        role: 'assistant',
-        content: '',
-        toolCalls: [
-            { id: 'a', name: 'f', args: {} },
-            { id: 'b', name: 'g', args: {} },
-        ],
-    });
-    const resultA = asMsg({
-        role: 'tool',
-        content: '',
-        toolResult: { toolCallId: 'a', content: 'ra' },
-    });
-    const resultB = asMsg({
-        role: 'tool',
-        content: '',
-        toolResult: { toolCallId: 'b', content: 'rb' },
-    });
-    // No results → drop the whole round back to [user].
-    assert.is(trimToRestorableBoundary([user, callAB]).length, 1);
-    // Only A answered → B orphaned → drop the round back to [user].
-    assert.is(trimToRestorableBoundary([user, callAB, resultA]).length, 1);
-    // Both answered → kept (ends on a balanced tool result).
-    assert.is(trimToRestorableBoundary([user, callAB, resultA, resultB]).length, 4);
-});
-Suite('trimToRestorableBoundary drops a trailing empty assistant placeholder', () => {
-    const user = asMsg({ role: 'user', content: 'hi' });
-    const placeholder = asMsg({ role: 'assistant', content: '' });
-    assert.is(trimToRestorableBoundary([user, placeholder]).length, 1);
-});
-// GENC-1351: orphaned agent snapshots (dynamic agent arrays — e.g. genesis-create).
-Suite('unknownAgentSnapshots flags saved agents missing from the configured set', () => {
-    const snap = {
-        agentSnapshots: { 'Guided Booking': {}, Bootstrap: {} },
-    };
-    // Bootstrap gone from the current set → flagged; Guided Booking is known.
-    assert.equal(unknownAgentSnapshots(snap, ['Guided Booking', 'Trades']), ['Bootstrap']);
-    // All known → none flagged.
-    assert.equal(unknownAgentSnapshots(snap, ['Guided Booking', 'Bootstrap']), []);
-    // Empty known set → can't classify yet → none (avoids false positives mid-init).
-    assert.equal(unknownAgentSnapshots(snap, []), []);
-});
-// GENC-1351 §6 — `reconcileAgentSnapshots`: the save-time guard against a
-// post-restore autosave wiping a mid-flow machine. The bug (regression #1): a
-// restore reads a good snapshot, then the restore's own history change fires an
-// autosave BEFORE the agent re-activates, so the live capture is empty and, left
-// unguarded, `{}` overwrites the machine → the flow resets on the next reload.
-const MACHINE = { machine: { value: 'pickInstrument', context: { counterparty: { id: 'c1' } } } };
-Suite('reconcileAgentSnapshots: REGRESSION — carries the flow-owner forward when live capture is empty', () => {
-    // Post-restore, pre-activation: getActiveAgent() is undefined → live is {}, but
-    // a flow is owned and the good image sits in the cache (seeded on restore).
-    const { snapshots, cache } = reconcileAgentSnapshots({}, 'Guided Booking', {
-        'Guided Booking': MACHINE,
-    });
-    assert.equal(snapshots['Guided Booking'], MACHINE, 'the flow-owner machine is preserved, NOT wiped to {}');
-    assert.equal(cache['Guided Booking'], MACHINE, 'cache keeps the good image');
-});
-Suite('reconcileAgentSnapshots: a live capture wins and advances the cache', () => {
-    const FRESH = { machine: { value: 'enterDetails', context: {} } };
-    const { snapshots, cache } = reconcileAgentSnapshots({ 'Guided Booking': FRESH }, 'Guided Booking', {
-        'Guided Booking': MACHINE, // stale cached value
-    });
-    assert.equal(snapshots['Guided Booking'], FRESH, 'live image is used (never the stale cache)');
-    assert.equal(cache['Guided Booking'], FRESH, 'cache advances to the freshly-captured image');
-});
-Suite('reconcileAgentSnapshots: no flow owner → empty stays empty (no stale carry-forward)', () => {
-    // Idle / stateless save: nothing to carry, even if the cache holds an old image.
-    const { snapshots, cache } = reconcileAgentSnapshots({}, null, { 'Guided Booking': MACHINE });
-    assert.equal(snapshots, {}, 'nothing carried forward without a flow owner');
-    assert.equal(cache['Guided Booking'], MACHINE, 'an empty save never erases the cache');
-});
-Suite('reconcileAgentSnapshots: flow owner set but nothing cached → cannot fabricate state', () => {
-    const { snapshots } = reconcileAgentSnapshots({}, 'Guided Booking', {});
-    assert.is(snapshots['Guided Booking'], undefined, 'no image to carry → left absent, not invented');
-});
-Suite('reconcileAgentSnapshots: carries the flow owner while keeping a co-captured other agent', () => {
-    const OTHER = { machine: { value: 'x' } };
-    const { snapshots } = reconcileAgentSnapshots({ Other: OTHER }, 'Guided Booking', {
-        'Guided Booking': MACHINE,
-    });
-    assert.equal(snapshots.Other, OTHER, 'the live non-owner image is kept');
-    assert.equal(snapshots['Guided Booking'], MACHINE, 'the missing flow-owner is carried forward');
-});
-Suite('reconcileAgentSnapshots: does not mutate its inputs', () => {
-    const live = {};
-    const cacheIn = { 'Guided Booking': MACHINE };
-    reconcileAgentSnapshots(live, 'Guided Booking', cacheIn);
-    assert.equal(live, {}, 'live input untouched');
-    assert.equal(Object.keys(cacheIn), ['Guided Booking'], 'cache input untouched');
-});
-// GENC-1351 §5.9: the pure notice-resolution helper (message + pre-fill prompt).
-// The freeze/marker mechanics live on the element (integration), not here.
-Suite('resolveNonResumableNotice: custom message wins, blank falls back to default', () => {
-    const msgs = [
-        asMsg({ role: 'user', content: 'first' }),
-        asMsg({ role: 'assistant', content: 'x' }),
-    ];
-    assert.is(resolveNonResumableNotice({
-        notResumableMessage: 'custom',
-        messages: msgs,
-        defaultMessage: 'D',
-    }).resumeMessage, 'custom');
-    assert.is(resolveNonResumableNotice({ notResumableMessage: '   ', messages: msgs, defaultMessage: 'D' })
-        .resumeMessage, 'D', 'a blank custom message falls back to the default');
-    assert.is(resolveNonResumableNotice({ messages: msgs, defaultMessage: 'D' }).resumeMessage, 'D', 'no custom message → default');
-});
-Suite('resolveNonResumableNotice: prompt prefers the captured flow prompt, else last user msg', () => {
-    const msgs = [
-        asMsg({ role: 'user', content: 'earlier' }),
-        asMsg({ role: 'assistant', content: 'x' }),
-        asMsg({ role: 'user', content: 'latest user' }),
-    ];
-    assert.is(resolveNonResumableNotice({
-        flowActivationPrompt: 'the flow prompt',
-        messages: msgs,
-        defaultMessage: 'D',
-    }).resumePrompt, 'the flow prompt', 'captured flow-activating prompt takes precedence');
-    assert.is(resolveNonResumableNotice({ flowActivationPrompt: null, messages: msgs, defaultMessage: 'D' })
-        .resumePrompt, 'latest user', 'no flow prompt → falls back to the last user message');
-    assert.is(resolveNonResumableNotice({ messages: [], defaultMessage: 'D' }).resumePrompt, undefined, 'no flow prompt and no user message → undefined');
-});
-// GENC-1351 §5.9: the freeze fallback keeps the transcript through the last user
-// message, dropping the agent's in-flight turns (issue #3).
-Suite('keepThroughLastUserMessage drops trailing agent turns, keeps through the last user msg', () => {
-    const u1 = asMsg({ role: 'user', content: 'book a flight' });
-    const a1 = asMsg({ role: 'assistant', content: 'ok' });
-    const u2 = asMsg({ role: 'user', content: 'show fills for T1' });
-    const plan = asMsg({
-        role: 'assistant',
-        content: '',
-        toolCalls: [{ id: 'a', name: 'f', args: {} }],
-    });
-    const res = asMsg({ role: 'tool', content: '' });
-    // Trailing agent turns after the last user message → dropped.
-    assert.equal(keepThroughLastUserMessage([u1, a1, u2, plan, res]), [u1, a1, u2]);
-    // Already ends on a user message → unchanged (same ref).
-    const endsUser = [u1, a1, u2];
-    assert.is(keepThroughLastUserMessage(endsUser), endsUser);
-    // No user message at all → unchanged (nothing to trim to).
-    const noUser = [a1, res];
-    assert.is(keepThroughLastUserMessage(noUser), noUser);
-    assert.equal(keepThroughLastUserMessage([]).length, 0);
-});
-Suite.run();

package/dist/esm/state/persistence/stateful-restore.e2e.test.js

@@ -1,158 +0,0 @@
-import { __awaiter } from "tslib";
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-// Side-effect import — MUST precede the driver import so it subclasses jsdom's
-// EventTarget (CustomEvent dispatch then works in node).
-import '../../components/chat-driver/align-event-globals';
-import { OrchestratingDriver } from '../../components/orchestrating-driver/orchestrating-driver';
-import { clearDiagnosticsCursorRegistry } from './diagnostics-cursors';
-import { clearPersisterRegistry } from './persister-registry';
-import { SessionPersister } from './session-persister';
-// GENC-1351 — end-to-end save→restore→route→re-activate proof. The persister unit
-// tests exercise `persistSession`/`restore` against a FAKE driver; the driver pin/
-// flow-owner tests exercise routing against a real driver. NOTHING wired the two
-// together — the exact integration that broke once (bug #2: the live agent's
-// `serialize()` was read via `driver.getActiveAgent()` — a host minting fresh
-// configs handed back a never-activated closure whose `serialize()` returned
-// undefined, so the machine reset on reload). This test closes that gap with a REAL
-// `OrchestratingDriver` + a REAL `SessionPersister` + an in-memory provider:
-//   persist (capture the LIVE agent's state) → restore (prime + re-lock routing) →
-//   send (route back to the flow-owner without re-classifying) → re-activate aligned.
-// `Planner` is `excludeFromClassifier` AND never pinned, so a turn landing on it after
-// restore proves the RESTORED flow-owner lock (not the pin, not the classifier) routed
-// it — the `setFlowOwner`-on-restore half of the fix.
-const KEY = 'e2e-session';
-const makeRegistry = (provider) => ({
-    get: () => provider,
-    default: () => provider,
-    defaultName: () => 'test',
-    names: () => ['test'],
-    getStatus: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
-    listStatuses: () => __awaiter(void 0, void 0, void 0, function* () { return []; }),
-});
-/** A provider that ends every turn immediately with a plain-text reply (no tools). */
-const noToolProvider = () => ({
-    chat: (_history, _userMessage, _options) => __awaiter(void 0, void 0, void 0, function* () { return ({ role: 'assistant', content: 'ok' }); }),
-});
-const agentCfg = (overrides) => (Object.assign({ description: 'test agent' }, overrides));
-/** In-memory persistence provider (single session), enough for one save + one load. */
-function makeMemoryProvider() {
-    let stored = null;
-    return {
-        saveDebounceMs: 0,
-        save: (_k, snap) => __awaiter(this, void 0, void 0, function* () {
-            stored = snap;
-        }),
-        load: () => __awaiter(this, void 0, void 0, function* () { return stored; }),
-        clear: () => __awaiter(this, void 0, void 0, function* () {
-            stored = null;
-        }),
-        get current() {
-            return stored;
-        },
-    };
-}
-/** The functional store shape the persister reads scalars from / hydrates into. */
-function makeStoreFake(over = {}) {
-    return {
-        store: {
-            aiAssistant: Object.assign({ messages: [], flowOwnerAgentName: null, flowActivationPrompt: null, activeAgent: undefined, pinnedAgentName: null, 
-                // The persister reads `sessionUsage.costUsd` when building a snapshot, so this
-                // has to be the object rather than a bare cost scalar.
-                sessionUsage: {
-                    costUsd: 0,
-                    uncachedInputTokens: 0,
-                    cacheReadTokens: 0,
-                    cacheWriteTokens: 0,
-                    outputTokens: 0,
-                }, contextTokens: 0, contextLimit: 0, activeModel: undefined, activeProviderName: undefined, restoring: false }, over),
-        },
-        actions: {
-            aiAssistant: {
-                loadSession: () => { },
-                setInputValue: () => { },
-            },
-        },
-    };
-}
-function makePersister(driver, storeFake, provider) {
-    const deps = {
-        stateKey: KEY,
-        getPersistence: () => ({ enabled: true, provider: provider }),
-        getAgentNames: () => ['Genesis Assistant', 'Planner'],
-        getDriver: () => driver,
-        getStore: () => storeFake,
-        getDiagnosticEntries: () => [],
-    };
-    return new SessionPersister(deps);
-}
-const tick = () => new Promise((r) => {
-    setTimeout(r, 0);
-});
-const Suite = createLogicSuite('stateful-restore-e2e');
-Suite.before.each(() => {
-    clearPersisterRegistry();
-    clearDiagnosticsCursorRegistry();
-});
-Suite('a flow-owned stateful agent survives persist → restore → resume, routing back without re-classifying', () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const provider = makeMemoryProvider();
-    // ── Persist side ────────────────────────────────────────────────────────────
-    // `stateA` is the Planner's live state bag; `serialize` closes over it, exactly
-    // like a real stateful agent's machine snapshot.
-    let stateA = { cursor: 0 };
-    const planner1 = agentCfg({
-        name: 'Planner',
-        excludeFromClassifier: true,
-        onActivate: (_a) => __awaiter(void 0, [_a], void 0, function* ({ restored }) {
-            if (restored !== undefined)
-                stateA = restored;
-        }),
-        serialize: () => stateA,
-        systemPrompt: () => 'planner',
-    });
-    const driver1 = new OrchestratingDriver(makeRegistry(noToolProvider()), [agentCfg({ name: 'Genesis Assistant' }), planner1], { sessionKey: KEY });
-    // Flow-owned but NOT pinned, then run a turn: the flow-owner lock routes the
-    // Planner (it's excludeFromClassifier, so the classifier could never pick it).
-    driver1.setFlowOwner('Planner');
-    yield driver1.sendMessage('go');
-    assert.is((_a = driver1.getActiveAgent()) === null || _a === void 0 ? void 0 : _a.name, 'Planner', 'flow-owner routed the Planner on persist side');
-    // The flow advances — mutate the SAME object `serialize()` returns.
-    stateA.cursor = 3;
-    // The store mirrors what main.ts keeps: the flow-owner lock lives in the store
-    // (that's the scalar `persistSession` reads).
-    const storeFake1 = makeStoreFake({ flowOwnerAgentName: 'Planner' });
-    const persister1 = makePersister(driver1, storeFake1, provider);
-    persister1.scheduleSave();
-    yield tick();
-    yield tick();
-    const saved = provider.current;
-    assert.ok(saved, 'a snapshot was persisted');
-    assert.is(saved.flowOwnerAgentName, 'Planner', 'flow-owner lock persisted');
-    // Bug-#2 assertion: the LIVE (activated) agent's serialize was captured via
-    // driver.getActiveAgent(), so the advanced state is in the snapshot.
-    assert.equal(saved.agentSnapshots.Planner, { cursor: 3 }, "live agent's advanced state captured (not a never-activated closure)");
-    // ── Restore side (fresh instances share the same in-memory provider) ──────────
-    let stateB = { cursor: -1 }; // sentinel; restore must overwrite
-    const planner2 = agentCfg({
-        name: 'Planner',
-        excludeFromClassifier: true,
-        onActivate: (_a) => __awaiter(void 0, [_a], void 0, function* ({ restored }) {
-            if (restored !== undefined)
-                stateB = restored;
-        }),
-        serialize: () => stateB,
-        systemPrompt: () => 'planner',
-    });
-    const driver2 = new OrchestratingDriver(makeRegistry(noToolProvider()), [agentCfg({ name: 'Genesis Assistant' }), planner2], { sessionKey: KEY });
-    const storeFake2 = makeStoreFake();
-    const persister2 = makePersister(driver2, storeFake2, provider);
-    yield persister2.restore();
-    // The restored flow-owner lock (setFlowOwner-on-restore) routes the next turn
-    // back to the Planner without re-classifying.
-    yield driver2.sendMessage('again');
-    assert.is((_b = driver2.getActiveAgent()) === null || _b === void 0 ? void 0 : _b.name, 'Planner', 'restored flow-owner routed the Planner (excludeFromClassifier + unpinned ⇒ only the restored lock could have)');
-    // primeRestoredAgentState → onActivate({ restored }) fed the snapshot back, so
-    // the fresh Planner resumed exactly where the persisted one left off.
-    assert.equal(stateB, { cursor: 3 }, 'restored agent re-activated aligned to the persisted state');
-}));
-Suite.run();

package/dist/esm/utils/animation-exclusivity.test.js

@@ -1,52 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { resolveExclusiveLoadingStyle } from './animation-exclusivity';
-const suite = createLogicSuite('resolveExclusiveLoadingStyle');
-suite('leaves a selection with only the dots loading style untouched', () => {
-    const next = ['loading', 'halo'];
-    assert.equal(resolveExclusiveLoadingStyle(next, ['halo']), ['loading', 'halo']);
-});
-suite('leaves a selection with only the waves loading style untouched', () => {
-    const next = ['waves', 'halo'];
-    assert.equal(resolveExclusiveLoadingStyle(next, ['halo']), ['waves', 'halo']);
-});
-suite('leaves a selection with no loading style untouched', () => {
-    assert.equal(resolveExclusiveLoadingStyle(['halo'], []), ['halo']);
-});
-suite('drops dots when waves was just added on top of dots', () => {
-    // Previously dots was on; user ticks waves → waves wins, dots removed.
-    const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'halo'], ['loading', 'halo']);
-    assert.equal(result, ['waves', 'halo']);
-});
-suite('drops waves when dots was just added on top of waves', () => {
-    // Previously waves was on; user ticks dots → dots wins, waves removed.
-    const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'halo'], ['waves', 'halo']);
-    assert.equal(result, ['loading', 'halo']);
-});
-suite('preserves the order of the surviving selection', () => {
-    const result = resolveExclusiveLoadingStyle(['halo', 'loading', 'waves'], ['halo', 'loading']);
-    // waves was just added → loading dropped; halo and waves keep their order.
-    assert.equal(result, ['halo', 'waves']);
-});
-suite('falls back to dots when both are present with no prior state (e.g. bad config)', () => {
-    const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'halo'], []);
-    assert.equal(result, ['loading', 'halo']);
-});
-suite('falls back to dots when both were already present (neither newly added)', () => {
-    const result = resolveExclusiveLoadingStyle(['loading', 'waves'], ['loading', 'waves', 'halo']);
-    assert.equal(result, ['loading']);
-});
-suite('handles an empty selection', () => {
-    assert.equal(resolveExclusiveLoadingStyle([], ['loading']), []);
-});
-suite('switching between any two loading styles keeps only the newly added one', () => {
-    // flowingWaves was on; user picks plasma → plasma wins, flowingWaves dropped.
-    assert.equal(resolveExclusiveLoadingStyle(['flowingWaves', 'plasma', 'halo'], ['flowingWaves', 'halo']), ['plasma', 'halo']);
-    // plasma was on; user picks the dots → dots win, plasma dropped.
-    assert.equal(resolveExclusiveLoadingStyle(['plasma', 'loading'], ['plasma']), ['loading']);
-});
-suite('drops all but the newly added style when several are somehow selected', () => {
-    const result = resolveExclusiveLoadingStyle(['loading', 'waves', 'flowingWaves', 'plasma'], ['loading', 'waves', 'plasma']);
-    // flowingWaves is the only one absent from `previous`, so it wins.
-    assert.equal(result, ['flowingWaves']);
-});
-suite.run();

package/dist/esm/utils/collect-session-models.test.js

@@ -1,53 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { collectSessionModels } from './collect-session-models';
-const assistantMsg = (overrides = {}) => (Object.assign({ role: 'assistant', content: '' }, overrides));
-const statusEntry = (name, model, provider) => ({
-    name,
-    isDefault: false,
-    status: { model, provider },
-});
-const suite = createLogicSuite('collectSessionModels');
-suite('collects unique models from assistant messages', () => {
-    var _a, _b, _c, _d;
-    const models = collectSessionModels([
-        assistantMsg({ model: 'claude-sonnet-4-6' }),
-        assistantMsg({ model: 'claude-haiku-4-5-20251001' }),
-        assistantMsg({ model: 'claude-sonnet-4-6', provider: 'anthropic' }),
-        assistantMsg({ model: 'gemini-2.5-pro', providerName: 'high', provider: 'gemini' }),
-    ], []);
-    assert.is(models.length, 3);
-    assert.is((_a = models[0]) === null || _a === void 0 ? void 0 : _a.model, 'claude-sonnet-4-6');
-    assert.is((_b = models[0]) === null || _b === void 0 ? void 0 : _b.provider, 'anthropic');
-    assert.is((_c = models[2]) === null || _c === void 0 ? void 0 : _c.model, 'gemini-2.5-pro');
-    assert.is((_d = models[2]) === null || _d === void 0 ? void 0 : _d.provider, 'gemini');
-});
-suite('resolves vendor from providerStatuses when messages lack provider', () => {
-    var _a;
-    const models = collectSessionModels([assistantMsg({ model: 'gemini-3.1-flash-lite', providerName: 'low' })], [statusEntry('low', 'gemini-3.1-flash-lite', 'gemini')]);
-    assert.is(models.length, 1);
-    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;
-    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);
-});
-suite('includes models from sub-agent traces', () => {
-    var _a;
-    const models = collectSessionModels([
-        assistantMsg({
-            toolCalls: [
-                {
-                    id: 'tc1',
-                    name: 'spawn',
-                    args: {},
-                    subAgentTrace: [assistantMsg({ model: 'claude-haiku-4-5-20251001' })],
-                },
-            ],
-        }),
-    ], []);
-    assert.is(models.length, 1);
-    assert.is((_a = models[0]) === null || _a === void 0 ? void 0 : _a.model, 'claude-haiku-4-5-20251001');
-});
-suite.run();