@genesislcap/ai-assistant 15.4.1 → 15.6.0

package/dist/esm/main/cost-session-banking.test.js

@@ -0,0 +1,308 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { clearCostSessionHistory, loadCostSessionHistory, } from '../utils/cost-session-history';
+import { emptyUsage } from '../utils/sum-usage';
+import { FoundationAiAssistant } from './main';
+// Hold a reference so the custom-element registration isn't tree-shaken.
+FoundationAiAssistant;
+// GENC-1475. Pins the banking behaviour behind the Usage tab's lifetime figures: a row must
+// report a project's LIFETIME usage whether or not the transcript is restored on load, and it
+// must never grow by re-counting spend it already holds.
+//
+// Two earlier attempts at this got it wrong in opposite directions, which is what these tests
+// exist to catch:
+//   - projecting the transcript straight onto the row → the row shrank on every refresh in
+//     hosts where the transcript does not persist;
+//   - re-deriving the banked figure whenever the rows reloaded → `chatConfig` rebinding
+//     mid-session (hosts build it in a template expression) folded the live session into its
+//     own baseline, compounding on every rebind.
+//
+// Like `popout-interaction-gate.test.ts` this deliberately does NOT mount the assistant:
+// `document.createElement` upgrades the element (constructor only) without connecting, so
+// `connectedCallback` never runs, nothing subscribes to `agenticActivityBus`, and its
+// cross-tab `BroadcastChannel` — opened lazily on first use — is never created. No teardown
+// needed, and the runner's event loop stays closed.
+const Suite = createLogicSuite('FoundationAiAssistant cost session banking');
+const PROJECT = 'proj-1';
+const usage = (costUsd, outputTokens = 100) => (Object.assign(Object.assign({}, emptyUsage()), { costUsd,
+    outputTokens }));
+/**
+ * An unconnected element with just enough session state wired for `finalizeCostSession`:
+ * the live usage it projects, the transcript it titles from, and the key it upserts against.
+ */
+function element(options) {
+    var _a, _b, _c;
+    const el = document.createElement('foundation-ai-assistant');
+    const messages = [{ role: 'user', content: 'build me a blotter' }];
+    const internals = el;
+    internals._sessionRef = {
+        store: {
+            aiAssistant: {
+                state: 'idle',
+                messages,
+                sessionUsage: options.live,
+                // Redux-backed like `messages`, so it goes in the store rather than through the
+                // element setter (which would dispatch through `actions` we don't fake). Present at
+                // all to keep `collectSessionModels` from warning about an empty registry per write.
+                providerStatuses: (_a = options.providerStatuses) !== null && _a !== void 0 ? _a : [
+                    { name: 'anthropic', status: { provider: 'anthropic', model: 'sonnet' } },
+                ],
+            },
+        },
+    };
+    internals._activeStateKey = PROJECT;
+    el.chatConfig = {
+        costHistory: { enabled: true, scope: options.scope, title: 'Trade Blotter' },
+    };
+    // `persistenceActive` is `enabled && provider`; a bare object is provider enough here since
+    // no cost-history methods are on it, so the localStorage path is used for writes.
+    el.persistence = options.persistenceActive
+        ? { enabled: true, provider: {} }
+        : { enabled: false };
+    el.costSessionHistory = (_b = options.rows) !== null && _b !== void 0 ? _b : [];
+    // LAST, deliberately: assigning `chatConfig` above fires `chatConfigChanged` →
+    // `reloadCostSessionHistory`, which sets this flag itself. Setting it any earlier would be
+    // silently overwritten — which is exactly how this helper was wrong first time round.
+    internals._costHistoryLoaded = (_c = options.loaded) !== null && _c !== void 0 ? _c : true;
+    return el;
+}
+const row = (over = {}) => (Object.assign({ id: PROJECT, projectKey: PROJECT, title: 'Trade Blotter', updatedAt: '2026-08-01T00:00:00.000Z', usage: usage(10), banked: usage(4), models: [] }, over));
+Suite('writes the live session as lifetime for a project with no prior row', () => {
+    const scope = 'bank-fresh';
+    clearCostSessionHistory(scope);
+    const el = element({ scope, live: usage(3) });
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory.length, 1);
+    assert.is(el.costSessionHistory[0].usage.costUsd, 3);
+    assert.equal(el.costSessionHistory[0].banked, emptyUsage(), 'nothing came before');
+    clearCostSessionHistory(scope);
+});
+Suite('restored transcript: repeat writes are stable, not compounding', () => {
+    // The transcript is authoritative (persistence on), so it re-proves the 6 sitting on top
+    // of the 4 already banked. The row must land on 10 no matter how many times we write —
+    // this is the `chatConfig`-rebind double-count.
+    const scope = 'bank-stable';
+    clearCostSessionHistory(scope);
+    const el = element({
+        scope,
+        live: usage(6),
+        rows: [row({ usage: usage(10), banked: usage(4) })],
+        persistenceActive: true,
+    });
+    for (let write = 0; write < 3; write += 1) {
+        el.finalizeCostSession();
+        assert.is(el.costSessionHistory.length, 1, `write ${write}: still one row`);
+        assert.is(el.costSessionHistory[0].usage.costUsd, 10, `write ${write}: total held`);
+    }
+    clearCostSessionHistory(scope);
+});
+Suite('a reload mid-session does not re-bank what the row already holds', () => {
+    // The regression: `chatConfig` rebinds (a new object from a host template expression),
+    // reloadCostSessionHistory runs, and the rows it re-reads now contain our own upsert. The
+    // banked memo must survive that, or the live session is added to its own baseline.
+    const scope = 'bank-rebind';
+    clearCostSessionHistory(scope);
+    const el = element({
+        scope,
+        live: usage(6),
+        rows: [row({ usage: usage(10), banked: usage(4) })],
+        persistenceActive: true,
+    });
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 10);
+    // Rebind chatConfig exactly as a host template would — a fresh object, same values.
+    el.chatConfig = {
+        costHistory: { enabled: true, scope, title: 'Trade Blotter' },
+    };
+    el.chatConfigChanged();
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 10, 'rebind must not inflate the row');
+    clearCostSessionHistory(scope);
+});
+Suite('no restore: the prior total is absorbed so the row never shrinks', () => {
+    var _a;
+    // The mirror failure. The transcript starts empty every refresh, so this page-load's 2 must
+    // be ADDED to the 10 already recorded rather than replacing it.
+    const scope = 'bank-absorb';
+    clearCostSessionHistory(scope);
+    const el = element({
+        scope,
+        live: usage(2),
+        rows: [row({ usage: usage(10), banked: usage(4) })],
+        persistenceActive: false,
+    });
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 12);
+    assert.is((_a = el.costSessionHistory[0].banked) === null || _a === void 0 ? void 0 : _a.costUsd, 10, 'whole prior total banked');
+    clearCostSessionHistory(scope);
+});
+Suite('skips the write until the ledger has loaded', () => {
+    // A provider read is async. Banking from a ledger that simply has not arrived would read as
+    // "nothing came before" and rewrite the row down to this turn.
+    const scope = 'bank-unloaded';
+    clearCostSessionHistory(scope);
+    const el = element({ scope, live: usage(3), loaded: false });
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory.length, 0, 'no row written while unloaded');
+    el._costHistoryLoaded = true;
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory.length, 1, 'writes once loaded');
+    clearCostSessionHistory(scope);
+});
+Suite('clearing history drops the banked figure so it cannot be resurrected', () => {
+    const scope = 'bank-cleared';
+    clearCostSessionHistory(scope);
+    const el = element({
+        scope,
+        live: usage(2),
+        rows: [row({ usage: usage(10), banked: usage(4) })],
+        persistenceActive: false,
+    });
+    el.clearCostSessionHistory();
+    assert.is(el.costSessionHistory.length, 0);
+    // The next turn must start from zero, not resurrect the 10 the user just discarded.
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 2);
+    clearCostSessionHistory(scope);
+});
+Suite('deleting this project row drops its banked figure too', () => {
+    const scope = 'bank-removed';
+    clearCostSessionHistory(scope);
+    const el = element({
+        scope,
+        live: usage(2),
+        rows: [row({ usage: usage(10), banked: usage(4) })],
+        persistenceActive: false,
+    });
+    // Bank first, so the memo is populated before the removal — the ordering that matters.
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 12);
+    el.removeCostSessionFromHistory(PROJECT);
+    assert.is(el.costSessionHistory.length, 0);
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 2, 'removed spend must not return');
+    clearCostSessionHistory(scope);
+});
+Suite('lifetime usage sums every row, per bucket', () => {
+    const scope = 'bank-lifetime';
+    clearCostSessionHistory(scope);
+    const el = element({
+        scope,
+        live: usage(1),
+        rows: [
+            row({ id: 'a', projectKey: 'a', usage: usage(2, 30) }),
+            row({ id: 'b', projectKey: 'b', usage: usage(3, 40) }),
+        ],
+    });
+    assert.is(el.cumulativeUsage.costUsd, 5);
+    assert.is(el.cumulativeUsage.outputTokens, 70);
+    assert.is(el.cumulativeCostUsd, 5);
+    // Rows only — adding the live session would count the open project twice, since its own
+    // row is kept current on every transcript change.
+    assert.is(el.cumulativeCostUsd, 5, 'live session is not added on top');
+    clearCostSessionHistory(scope);
+});
+Suite('exposes build history most-recently-worked-on first', () => {
+    const el = element({
+        scope: 'bank-order',
+        live: usage(1),
+        rows: [
+            row({ id: 'stale', projectKey: 'stale', updatedAt: '2026-01-01T00:00:00.000Z' }),
+            row({ id: 'fresh', projectKey: 'fresh', updatedAt: '2026-08-04T09:00:00.000Z' }),
+        ],
+    });
+    // The raw list keeps insertion order; only the display getter reorders.
+    assert.is(el.costSessionHistory[0].id, 'stale');
+    assert.equal(el.sortedCostSessionHistory.map((r) => r.id), ['fresh', 'stale']);
+});
+Suite('lifetime usage falls back to the live session when history is off', () => {
+    const el = element({ scope: 'bank-off', live: usage(4) });
+    el.chatConfig = { costHistory: { enabled: false } };
+    assert.is(el.cumulativeUsage.costUsd, 4, 'no rows exist to sum');
+    assert.is(el.settingsCostLifetimeVisible, false, 'and the section is hidden');
+});
+Suite('lists each model once even when several registry tiers resolve to it', () => {
+    // providerStatuses has one entry per registry SLOT. A vendor configured across tiers that
+    // resolve to the same model reported it once per tier, so the chip rendered twice.
+    const el = element({
+        scope: 'models-dedupe',
+        live: usage(1),
+        providerStatuses: [
+            { name: 'low', status: { provider: 'gemini', model: 'gemini-3.5-flash' } },
+            { name: 'high', status: { provider: 'gemini', model: 'gemini-3.5-flash' } },
+            { name: 'lite', status: { provider: 'gemini', model: 'gemini-3.1-flash-lite' } },
+        ],
+    });
+    assert.equal(el.uniqueProviderModels.map((m) => m.model), ['gemini-3.5-flash', 'gemini-3.1-flash-lite']);
+    assert.is(el.uniqueProviderModels[0].provider, 'gemini', 'vendor retained for the colour');
+});
+Suite('keeps slots that report no model distinct, and recovers a missing vendor', () => {
+    const el = element({
+        scope: 'models-fallback',
+        live: usage(1),
+        providerStatuses: [
+            // No model reported: the chip falls back to the slot name, and two such slots are
+            // genuinely different things — deduping on model alone would have merged them.
+            { name: 'custom-a', status: undefined },
+            { name: 'custom-b', status: undefined },
+            // Same model twice, vendor known on only one of them.
+            { name: 'tier-1', status: { model: 'gemini-3.5-flash' } },
+            { name: 'tier-2', status: { provider: 'gemini', model: 'gemini-3.5-flash' } },
+        ],
+    });
+    assert.equal(el.uniqueProviderModels.map((m) => m.model), ['custom-a', 'custom-b', 'gemini-3.5-flash']);
+    assert.is(el.uniqueProviderModels[2].provider, 'gemini', 'vendor picked up from the other tier');
+});
+Suite('an unreadable ledger blocks writes instead of replacing it with what we could not read', () => {
+    // The review case. `saveCostHistory` REPLACES the stored list, so a failed read followed by a
+    // write would delete every other project's row and reset this project's banked total.
+    const scope = 'ledger-unreadable';
+    clearCostSessionHistory(scope);
+    const el = element({ scope, live: usage(4) });
+    const internals = el;
+    internals._ledgerUnreadable = true;
+    el.finalizeCostSession();
+    // Writes are debounced, so drive the flush directly rather than waiting on a timer.
+    internals.flushCostHistory();
+    assert.is(loadCostSessionHistory(scope).length, 0, 'nothing written back over a ledger we failed to read');
+    clearCostSessionHistory(scope);
+});
+Suite('deleting a provider row whose id differs from its projectKey still drops the memo', () => {
+    // `_bankedFor` holds a projectKey; the delete action passes a row id. A host provider can assign
+    // any id, so comparing across the two namespaces skipped the reset and the next turn resurrected
+    // the deleted total. Reachable when a provider load lands AFTER a finalize has banked: our own
+    // upsert would otherwise have rewritten the row's id to the projectKey.
+    const scope = 'ledger-remove-id';
+    clearCostSessionHistory(scope);
+    const el = element({
+        scope,
+        live: usage(2),
+        rows: [row({ id: 'host-assigned-uuid', projectKey: PROJECT, usage: usage(10) })],
+        persistenceActive: false,
+    });
+    // Memo already populated for this project, as it would be after a turn.
+    const internals = el;
+    internals._bankedFor = PROJECT;
+    internals._bankedUsage = usage(10);
+    el.removeCostSessionFromHistory('host-assigned-uuid');
+    assert.is(el.costSessionHistory.length, 0);
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 2, 'deleted total must not come back');
+    clearCostSessionHistory(scope);
+});
+Suite('hides the lifetime section when no state key at all can produce a row', () => {
+    const el = element({ scope: 'ledger-nokey', live: usage(3) });
+    assert.is(el.settingsCostLifetimeVisible, true, 'visible with a key');
+    // getStateKey falls back to `id::headerTitle`, and headerTitle has a non-empty default — so
+    // clearing the wired key alone is NOT enough to lose the key. All three have to be absent.
+    el._activeStateKey = undefined;
+    assert.is(el.settingsCostLifetimeVisible, true, 'still keyed by the default header title');
+    el.headerTitle = '';
+    assert.is(el.settingsCostLifetimeVisible, false, 'no key at all: the total could only ever read $0.00 beside real live spend');
+});
+Suite('labels the live figures by whether the transcript is authoritative', () => {
+    const withPersistence = element({ scope: 'bank-label', live: usage(1), persistenceActive: true });
+    assert.is(withPersistence.liveUsageIsProjectLifetime, true, 'restored → project lifetime');
+    const without = element({ scope: 'bank-label', live: usage(1), persistenceActive: false });
+    assert.is(without.liveUsageIsProjectLifetime, false, 'not restored → this session only');
+});
+Suite.run();