@genesislcap/ai-assistant 15.6.2 → 15.7.1

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

@@ -1,4 +1,5 @@
 import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+import { getBankedBaseline, resetBankedBaselines, setBankedBaseline, } from '../utils/banked-usage-baselines';
 import { clearCostSessionHistory, loadCostSessionHistory, } from '../utils/cost-session-history';
 import { emptyUsage } from '../utils/sum-usage';
 import { FoundationAiAssistant } from './main';
@@ -28,9 +29,17 @@ const usage = (costUsd, outputTokens = 100) => (Object.assign(Object.assign({},
 /**
  * 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.
+ *
+ * Banked baselines are module state keyed by session (so remounts share one), which means they
+ * outlive an element. Cleared by default, because every suite but the remount ones is modelling
+ * a *fresh page load* — and because leaving them would leak one suite's baseline into the next
+ * under the shared `PROJECT` key. Pass `remount: true` to model a new element joining a session
+ * that has already banked, which is the case this file exists to pin.
  */
 function element(options) {
     var _a, _b, _c;
+    if (!options.remount)
+        resetBankedBaselines();
     const el = document.createElement('foundation-ai-assistant');
     const messages = [{ role: 'user', content: 'build me a blotter' }];
     const internals = el;
@@ -267,10 +276,10 @@ Suite('an unreadable ledger blocks writes instead of replacing it with what we c
     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.
+    // Baselines are keyed by projectKey; the delete action passes a row id. A host provider can
+    // assign any id, so deleting by the wrong namespace left the baseline in place 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({
@@ -279,16 +288,221 @@ Suite('deleting a provider row whose id differs from its projectKey still drops
         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);
+    // Baseline already resolved for this project, as it would be after a turn — set directly
+    // rather than by finalizing, because our own upsert would rewrite the row's id to the
+    // projectKey and the id mismatch under test would vanish with it.
+    setBankedBaseline(PROJECT, 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('a remount mid-session does not re-bank what the row already holds', () => {
+    var _a;
+    // The reported regression (GENC-1475). Reproduces the field report exactly: with persistence
+    // off, the host remounted the assistant part-way through a session (a layout re-render — the
+    // debug log showed seven connects in one session) and the LIFETIME figure jumped by the whole
+    // session-to-date while the live figure kept climbing normally.
+    //
+    // The new element joins a live session: same key, same transcript, and rows that already
+    // contain the previous instance's upsert. An element-scoped baseline re-derived here and, with
+    // no restore to defer to, banked `row.usage` — which already included this very transcript.
+    const scope = 'bank-remount';
+    clearCostSessionHistory(scope);
+    const first = element({
+        scope,
+        live: usage(6),
+        rows: [row({ usage: usage(1), banked: usage(1) })],
+        persistenceActive: false,
+    });
+    first.finalizeCostSession();
+    assert.is(first.costSessionHistory[0].usage.costUsd, 7, '1 banked + 6 live');
+    // Remount: a brand new element wired to the same session, handed the rows as they now stand.
+    const second = element({
+        scope,
+        live: usage(6),
+        rows: first.costSessionHistory,
+        persistenceActive: false,
+        remount: true,
+    });
+    second.finalizeCostSession();
+    assert.is(second.costSessionHistory[0].usage.costUsd, 7, 'remount must not inflate the row');
+    assert.is((_a = second.costSessionHistory[0].banked) === null || _a === void 0 ? void 0 : _a.costUsd, 1, 'baseline unchanged by the remount');
+    // And the session keeps accruing normally afterwards, on top of the SAME baseline.
+    const third = element({
+        scope,
+        live: usage(9),
+        rows: second.costSessionHistory,
+        persistenceActive: false,
+        remount: true,
+    });
+    third.finalizeCostSession();
+    assert.is(third.costSessionHistory[0].usage.costUsd, 10, '1 banked + 9 live');
+    clearCostSessionHistory(scope);
+});
+Suite('a page reload still absorbs the prior total after a remount banked nothing new', () => {
+    // The other half of the pairing: dropping the baseline on remount is wrong, but keeping it
+    // across a *page load* would be too — the transcript starts empty there (persistence off), so
+    // the row's whole total must be banked. `resetBankedBaselines` stands in for the realm dying.
+    const scope = 'bank-reload';
+    clearCostSessionHistory(scope);
+    const before = element({
+        scope,
+        live: usage(6),
+        rows: [row({ usage: usage(1), banked: usage(1) })],
+        persistenceActive: false,
+    });
+    before.finalizeCostSession();
+    assert.is(before.costSessionHistory[0].usage.costUsd, 7);
+    const afterReload = element({
+        scope,
+        live: usage(2),
+        rows: before.costSessionHistory,
+        persistenceActive: false,
+    });
+    afterReload.finalizeCostSession();
+    assert.is(afterReload.costSessionHistory[0].usage.costUsd, 9, 'prior 7 banked, this load adds 2');
+    clearCostSessionHistory(scope);
+});
+Suite('clearing the transcript re-baselines instead of discarding spend', () => {
+    var _a;
+    // Clear empties the transcript, so the row's total now predates what is on screen and has to be
+    // banked wholesale. Merely dropping the baseline would re-derive through `persistenceActive`,
+    // which with persistence ON carries the row's OLD banked figure forward and silently loses
+    // every turn between that baseline and the clear.
+    const scope = 'bank-clear-session';
+    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);
+    // `clearSession` itself tears down and rebuilds the driver, which an unconnected element has
+    // none of — so drive the one step under test. `clearSession` reads the live figure before
+    // `resetSession` zeroes it and passes it in; the 6 here is that capture.
+    const priv = el;
+    priv.rebaselineOnClearedTranscript(PROJECT, usage(6));
+    // A fresh transcript worth 3, on top of the whole 10 the project had accrued.
+    priv._sessionRef.store.aiAssistant.sessionUsage = usage(3);
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 13, 'pre-clear spend kept, new turn added');
+    assert.is((_a = el.costSessionHistory[0].banked) === null || _a === void 0 ? void 0 : _a.costUsd, 10, 'whole pre-clear total banked');
+    clearCostSessionHistory(scope);
+});
+Suite('clearing while the ledger is still loading must not pin a baseline', () => {
+    var _a;
+    // Review case. A stamped baseline is sticky — `bankedUsageFor` short-circuits on any stored
+    // entry and a zero usage is a *resolved* value there. On the provider path the row list is empty
+    // and `_costHistoryLoaded` false while the read is in flight, so a clear landing in that window
+    // used to pin a baseline derived from no rows at all. The load arriving afterwards with the
+    // project's real total was then never consulted, and the next write replaced its row with
+    // `banked: 0` — the project's whole history gone.
+    const scope = 'bank-clear-unloaded';
+    clearCostSessionHistory(scope);
+    const el = element({ scope, live: usage(5), loaded: false });
+    const priv = el;
+    // Clear arrives before the provider read lands: rows are empty and nothing is known yet.
+    priv.rebaselineOnClearedTranscript(PROJECT, usage(5));
+    assert.is(getBankedBaseline(PROJECT), undefined, 'nothing pinned from a ledger we cannot see');
+    // The read lands with this project's real history, and a turn follows.
+    el.costSessionHistory = [row({ usage: usage(42), banked: usage(40) })];
+    priv._costHistoryLoaded = true;
+    priv._sessionRef.store.aiAssistant.sessionUsage = usage(1);
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 43, "the project's 42 survives the race");
+    assert.is((_a = el.costSessionHistory[0].banked) === null || _a === void 0 ? void 0 : _a.costUsd, 42, 'baseline re-derived from real rows');
+    clearCostSessionHistory(scope);
+});
+Suite('clearing banks a transcript the row has not caught up with', () => {
+    var _a;
+    // Review case: without this, the suite passed identically against the OLD derivation
+    // (`existing?.usage`), because everywhere else the row already agreed with baseline + live.
+    //
+    // The formulas only diverge when the row is STALE relative to the transcript — which is exactly
+    // what the new one exists for, since `finalizeCostSession` skips its write while the ledger is
+    // unloaded and while the session has no usage. No finalize here, so the row lags by 3.
+    const scope = 'bank-clear-stale-row';
+    clearCostSessionHistory(scope);
+    const el = element({
+        scope,
+        live: usage(3),
+        rows: [row({ usage: usage(42), banked: usage(40) })],
+        persistenceActive: false,
+    });
+    const priv = el;
+    priv.rebaselineOnClearedTranscript(PROJECT, usage(3));
+    // 42 from the row plus the 3 the discarded transcript proved. The old row-read banked 42 flat.
+    assert.is((_a = getBankedBaseline(PROJECT)) === null || _a === void 0 ? void 0 : _a.costUsd, 45, 'the stale 3 is banked, not dropped');
+    priv._sessionRef.store.aiAssistant.sessionUsage = usage(1);
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 46, '45 banked + the new turn');
+    clearCostSessionHistory(scope);
+});
+Suite('a memoised baseline survives a clear during a reload instead of being dropped', () => {
+    var _a, _b;
+    // Review case. The guard is broader than the derivation needs: once a baseline is memoised the
+    // new figure is determined without any rows, so deleting it there throws away something correct.
+    // Concretely — row at usage 120 / banked 90, baseline memoised at 90, 30 on screen — dropping it
+    // made the next turn re-derive `row.banked` and rewrite the row BACKWARDS from 120 to 95.
+    const scope = 'bank-clear-memoised';
+    clearCostSessionHistory(scope);
+    const el = element({
+        scope,
+        live: usage(30),
+        rows: [row({ usage: usage(120), banked: usage(90) })],
+        persistenceActive: true,
+    });
+    el.finalizeCostSession();
+    assert.is((_a = getBankedBaseline(PROJECT)) === null || _a === void 0 ? void 0 : _a.costUsd, 90, 'baseline memoised off the restored row');
+    // A chatConfig rebind puts the ledger back in flight, and the clear lands inside that window.
+    const priv = el;
+    priv._costHistoryLoaded = false;
+    priv.rebaselineOnClearedTranscript(PROJECT, usage(30));
+    assert.is((_b = getBankedBaseline(PROJECT)) === null || _b === void 0 ? void 0 : _b.costUsd, 120, '90 kept and the discarded 30 added');
+    priv._costHistoryLoaded = true;
+    priv._sessionRef.store.aiAssistant.sessionUsage = usage(5);
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 125, 'row moves forward, never backwards');
+    clearCostSessionHistory(scope);
+});
+Suite('clearing with the ledger disabled pins nothing, even though it reads as loaded', () => {
+    // Review case. `reloadCostSessionHistory` sets `_costHistoryLoaded` TRUE over a deliberately
+    // empty list when `enabled` is false — "nothing will be loaded", not "rows are known" — so the
+    // flag alone let a clear pin a baseline from a ledger that was never read. A host enabling
+    // history afterwards (an async setting, a feature flag) then had its real row buried by it.
+    const scope = 'bank-clear-disabled';
+    clearCostSessionHistory(scope);
+    const el = element({ scope, live: usage(3) });
+    el.chatConfig = { costHistory: { enabled: false, scope } };
+    const priv = el;
+    assert.is(priv._costHistoryLoaded, true, 'reads as loaded despite nothing being known');
+    priv.rebaselineOnClearedTranscript(PROJECT, usage(3));
+    assert.is(getBankedBaseline(PROJECT), undefined, 'nothing pinned while the ledger is off');
+    // History switched on afterwards, and this project turns out to have real spend.
+    el.chatConfig = { costHistory: { enabled: true, scope, title: 'Trade Blotter' } };
+    el.costSessionHistory = [row({ usage: usage(50), banked: usage(50) })];
+    priv._costHistoryLoaded = true;
+    priv._sessionRef.store.aiAssistant.sessionUsage = usage(1);
+    el.finalizeCostSession();
+    assert.is(el.costSessionHistory[0].usage.costUsd, 51, "the project's 50 is not buried");
+    clearCostSessionHistory(scope);
+});
+Suite('a host slotting its own build history does not have to enable our ledger', () => {
+    // Review case. `enabled` governs the BUILT-IN ledger and defaults false, while the Usage tab
+    // shows for showCost/showTokens which default true. Once the section's ?hidden binding became
+    // effective, short-circuiting on `enabled` above the slot check hid a host's own markup — and
+    // the slot is the only thing in that container.
+    const el = element({ scope: 'slotted-history', live: usage(1) });
+    el.chatConfig = { costHistory: { enabled: false } };
+    assert.is(el.settingsCostHistorySectionVisible, false, 'nothing slotted, ledger off → hidden');
+    el.settingsCostHistorySlotted = [document.createElement('div')];
+    assert.is(el.settingsCostHistorySectionVisible, true, 'slotted content shows without `enabled`');
+    assert.is(el.settingsCostHistoryHeadingVisible, true, 'and the heading comes with it');
+});
 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');
@@ -305,4 +519,20 @@ Suite('labels the live figures by whether the transcript is authoritative', () =
     const without = element({ scope: 'bank-label', live: usage(1), persistenceActive: false });
     assert.is(without.liveUsageIsProjectLifetime, false, 'not restored → this session only');
 });
+Suite('a stored baseline is isolated from the row and the caller it passed through', () => {
+    var _a, _b;
+    // A baseline arrives as a reference into a ledger row (`resolveBankedUsage` returns `row.banked`
+    // or `row.usage`) and is read back onto the NEXT row's `banked` field, so an uncloned map entry
+    // is reachable from page-global state, two rows, and any host handed the row list. Mutating
+    // either end must not move the stored figure, or a project's baseline is silently rewritten for
+    // the rest of the page.
+    resetBankedBaselines();
+    const source = usage(10);
+    setBankedBaseline(PROJECT, source);
+    source.costUsd = 999;
+    assert.is((_a = getBankedBaseline(PROJECT)) === null || _a === void 0 ? void 0 : _a.costUsd, 10, 'mutating the source cannot reach the map');
+    const readBack = getBankedBaseline(PROJECT);
+    readBack.costUsd = 777;
+    assert.is((_b = getBankedBaseline(PROJECT)) === null || _b === void 0 ? void 0 : _b.costUsd, 10, 'mutating a read copy cannot reach the map');
+});
 Suite.run();