@genesislcap/ai-assistant 15.7.0 → 15.7.2

package/src/main/main.ts

@@ -123,6 +123,11 @@ import { ChatSuggestions } from '../suggestions/chat-suggestions';
 import type { InteractionContext } from '../types/interaction-context';
 import { AnimatedPanelToggle } from '../utils/animated-panel-toggle';
 import { resolveExclusiveLoadingStyle } from '../utils/animation-exclusivity';
+import {
+  deleteBankedBaseline,
+  getBankedBaseline,
+  setBankedBaseline,
+} from '../utils/banked-usage-baselines';
 import { collectSessionModels } from '../utils/collect-session-models';
 import {
   clearCostSessionHistory,
@@ -877,11 +882,6 @@ export class FoundationAiAssistant extends GenesisElement {
    *
    * @beta
    */
-  /** Whether this vendor's wall came from the sweep alone — see the slice's `sweptVendors`. */
-  private isVendorSwept(vendor: AIProviderType): boolean {
-    return (this._sessionRef?.store.aiAssistant.sweptVendors ?? []).includes(vendor);
-  }
-
   setVendorBlocked(vendor: AIProviderType, blocked: boolean, reason?: string | null): void {
     if (vendor === 'none') {
       logger.warn(
@@ -893,6 +893,11 @@ export class FoundationAiAssistant extends GenesisElement {
     this._sessionRef?.actions.aiAssistant.setVendorBlocked({ vendor, blocked, reason });
   }
 
+  /** Whether this vendor's wall came from the sweep alone — see the slice's `sweptVendors`. */
+  private isVendorSwept(vendor: AIProviderType): boolean {
+    return (this._sessionRef?.store.aiAssistant.sweptVendors ?? []).includes(vendor);
+  }
+
   /**
    * The walled vendors the user can still be routed to — i.e.
    * {@link FoundationAiAssistant.blockedVendors} narrowed to the reachable set,
@@ -1535,9 +1540,9 @@ export class FoundationAiAssistant extends GenesisElement {
   }
 
   /**
-   * Spend for `projectKey` that predates the current transcript, resolved once per project
-   * and memoised (`_bankedFor`) so it cannot drift mid-session as the row it came from is
-   * rewritten by our own upserts.
+   * Spend for `projectKey` that predates the current transcript, resolved once per SESSION and
+   * shared by every element instance wired to it (see `banked-usage-baselines`), so it cannot
+   * drift as the row it came from is rewritten by our own upserts.
    *
    * The two cases turn on whether the transcript is authoritative for this project:
    *
@@ -1547,28 +1552,77 @@ export class FoundationAiAssistant extends GenesisElement {
    * - **Transcript starts empty**: nothing on screen accounts for the previous total, so the
    *   whole of it becomes banked. Without this the next turn would rewrite the row downwards
    *   to just that turn, losing the project's earlier spend.
+   *
+   * The baseline is deliberately NOT element state. This element is remounted repeatedly inside
+   * a single session (the host re-rendering its layout, popping out, docking) and a fresh
+   * instance re-deriving would take the second branch against rows that already hold the live
+   * transcript — banking the session as its own baseline. Keying on the session instead means a
+   * remount inherits the baseline that transcript was paired with.
    */
   private bankedUsageFor(projectKey: string): AggregateUsage {
-    if (this._bankedFor === projectKey) return this._bankedUsage;
+    const resolved = getBankedBaseline(projectKey);
+    if (resolved) return resolved;
     const existing = this.costSessionHistory.find((r) => r.projectKey === projectKey);
     // `persistenceActive` is what decides whether the transcript speaks for the project's
     // history: it is on only when a provider is wired AND the user is remembering the chat.
-    this._bankedUsage = resolveBankedUsage(existing, this.persistenceActive);
-    this._bankedFor = projectKey;
-    return this._bankedUsage;
+    const banked = resolveBankedUsage(existing, this.persistenceActive);
+    setBankedBaseline(projectKey, banked);
+    return banked;
   }
 
   /**
-   * Discard the banked figure — for when the spend it stands for has been deliberately
-   * thrown away (the user clearing history, or deleting this project's row).
+   * Re-baseline this session against an emptied transcript: what came before, plus what the
+   * transcript being discarded proved. `discarded` must be read BEFORE the live figures are
+   * reset, since that is the only record of the latter.
    *
-   * NOT for reloads. A reload re-reads rows that already include our own upserts, so
-   * re-deriving from them would fold the live session into its own baseline; only a genuine
-   * project change should re-derive, which `bankedUsageFor`'s per-project memo handles.
+   * Not the same as dropping the baseline. Dropping it re-derives through `persistenceActive`,
+   * and with persistence ON that carries the row's *old* banked figure forward — discarding
+   * every turn between the last baseline and the clear. The transcript is gone either way, so
+   * the branch that reads it as authoritative no longer applies.
+   *
+   * Derived from the memoised baseline and the live figure rather than from the project's row,
+   * because a row is only as current as the last `finalizeCostSession` — which skips its write
+   * while the ledger is unloaded, and while the session has no usage yet.
    */
-  private resetBankedUsage(): void {
-    this._bankedFor = undefined;
-    this._bankedUsage = emptyUsage();
+  private rebaselineOnClearedTranscript(key: string, discarded: AggregateUsage): void {
+    // Already resolved for this session? Then the new baseline is fully determined without
+    // consulting the ledger at all — `bankedUsageFor` would short-circuit on this same value — so
+    // answer before the guard below, which would otherwise discard a figure that is both correct
+    // and independent of the rows. Losing it costs real spend: with a row at `usage: 120,
+    // banked: 90` and 30 on screen, a clear during a reload would drop the memoised 90, and the
+    // next turn would re-derive `row.banked` and rewrite the row BACKWARDS from 120 to 95.
+    const resolved = getBankedBaseline(key);
+    if (resolved) {
+      setBankedBaseline(key, addUsage(resolved, discarded));
+      return;
+    }
+
+    // Nothing memoised, so a baseline can only come from the rows — and a stamped one is STICKY
+    // (`bankedUsageFor` short-circuits on any stored entry, and a zero usage is a *resolved* value
+    // there, not "unresolved"). So unless the rows are genuinely known, do not guess:
+    //
+    //  - `enabled` false: `reloadCostSessionHistory` sets `_costHistoryLoaded` TRUE over a
+    //    deliberately empty list, meaning "nothing will be loaded" rather than "rows are known".
+    //    The flag alone therefore is not enough. Reachable because `enabled` is
+    //    `cost?.enabled === true` — false for an unbound `chatConfig`, and for any host resolving
+    //    it from an async setting, exactly as `chatConfigChanged` already expects.
+    //  - Provider read in flight: the list is emptied and the flag cleared synchronously, on
+    //    connect and again on every `chatConfig` rebind.
+    //  - Unreadable: the rows we hold are a fallback, not the ledger.
+    //
+    // In all three, pinning would bury this project's real total the moment it arrived — a later
+    // load does NOT invalidate baselines (deliberately, see `reloadCostSessionHistory`), so the
+    // next write would replace the row off the pinned figure and lose everything before it.
+    //
+    // Dropping instead leaves the next write to re-derive from rows that actually arrived. It
+    // under-banks `discarded` in that window — a bounded loss, and what every clear did before
+    // this method existed. Nothing is written while disabled, so there is no banked value to
+    // preserve in that case either.
+    if (!this.resolvedCostHistory.enabled || !this._costHistoryLoaded || this._ledgerUnreadable) {
+      deleteBankedBaseline(key);
+      return;
+    }
+    setBankedBaseline(key, addUsage(this.bankedUsageFor(key), discarded));
   }
 
   showConfirmationDialog(
@@ -1593,24 +1647,26 @@ export class FoundationAiAssistant extends GenesisElement {
 
   /** Remove one entry from persisted build history. */
   removeCostSessionFromHistory(id: string): void {
-    // Deleting the active project's row discards its banked spend by intent, so drop the
-    // memo too — otherwise the next turn would rewrite the row we just removed, restoring
-    // the total the user asked to be rid of.
+    // Deleting a row discards its banked spend by intent, so drop the baseline too —
+    // otherwise the next turn would rewrite the row we just removed, restoring the total the
+    // user asked to be rid of.
     //
-    // Resolve the row first: `id` is a row id while `_bankedFor` is a projectKey. They match
-    // only for rows this element wrote (`finalizeCostSession` sets `id: projectKey`); a row from
-    // a host provider can carry any id, and comparing across the two namespaces would silently
-    // skip the reset.
+    // Resolve the row first: `id` is a row id while baselines are keyed by projectKey. They
+    // match only for rows this element wrote (`finalizeCostSession` sets `id: projectKey`); a
+    // row from a host provider can carry any id, and deleting by the wrong namespace would
+    // silently leave the baseline in place.
     const removed = this.costSessionHistory.find((record) => record.id === id);
-    if (removed && this._bankedFor === removed.projectKey) this.resetBankedUsage();
+    if (removed) deleteBankedBaseline(removed.projectKey);
     this.persistCostHistory(this.costSessionHistory.filter((record) => record.id !== id));
   }
 
   /** Clear all persisted build history for this assistant scope. */
   clearCostSessionHistory(): void {
-    // Every row is gone, so nothing is banked any more — without this the active project's
-    // next turn would resurrect its pre-clear total.
-    this.resetBankedUsage();
+    // Every row is gone, so nothing is banked any more — without this the next turn would
+    // resurrect the pre-clear total. Dropped per row rather than for the active session alone,
+    // so a project whose row was cleared while another session was displaying it does not keep
+    // a baseline pointing at spend that no longer exists anywhere.
+    for (const record of this.costSessionHistory) deleteBankedBaseline(record.projectKey);
     // Provider-backed: write an empty ledger through. The `localStorage` path instead
     // removes its key outright rather than leaving an empty array behind.
     if (this.costHistoryProvider()) {
@@ -1843,10 +1899,9 @@ export class FoundationAiAssistant extends GenesisElement {
    * (same key) from a project switch (key already flipped) — see `syncActiveCostSessionTitle`.
    */
   private _activeCostSessionKey?: string;
-  /** Memoised pre-transcript spend for `_bankedFor` — see `bankedUsageFor`. */
-  private _bankedUsage: AggregateUsage = emptyUsage();
-  /** Project key `_bankedUsage` was resolved for; `undefined` means "not yet resolved". */
-  private _bankedFor: string | undefined;
+  // NOTE: the pre-transcript ("banked") spend is deliberately NOT held here. It is keyed by
+  // session in `banked-usage-baselines` so the many element instances a single session sees —
+  // layout re-renders, popout, docking — share one baseline. See `bankedUsageFor`.
   /**
    * Whether the row list reflects storage yet. Gates cost writes so a project's banked
    * spend is never derived from a ledger that simply hasn't arrived.
@@ -2663,6 +2718,10 @@ export class FoundationAiAssistant extends GenesisElement {
     // keeping the high-water `lastEventIndex` would then skip every event of the
     // resumed session (GENC-1351 §5.12 / #9). Clear (same-session) still uses reset.
     deleteDiagnosticsCursorsFor(oldKey);
+    // The cost baseline is paired with the transcript in the store just disposed, so it goes
+    // with it (GENC-1475). A later switch back re-restores from the provider — or starts empty
+    // where it does not — and re-derives from the ledger rows accordingly.
+    deleteBankedBaseline(oldKey);
     clearMetaSession(oldKey);
     // Activate the incoming session. Swapping the observable `_sessionRef` re-points
     // every store-backed getter binding at the new store; `activateSession` rebuilds
@@ -3272,9 +3331,16 @@ export class FoundationAiAssistant extends GenesisElement {
     } catch (e) {
       logger.error('Session clear: agent serialize() failed:', e);
     }
+    // Read BEFORE `resetSession()` zeroes it: this is what the transcript about to be discarded
+    // proved, and nothing else records it. Banking it is what stops the next turn rewriting the
+    // project's row down to itself and losing the spend up to the clear (GENC-1475).
+    const discarded = this.sessionUsage;
     if (this.driver) this.teardownDriver(key);
     this._sessionRef?.actions.aiAssistant.resetSession();
-    if (key) this.rebuildDriver(key);
+    if (key) {
+      this.rebaselineOnClearedTranscript(key, discarded);
+      this.rebuildDriver(key);
+    }
     // Restore-core is owned by the shared per-session persister (GENC-1351 §5.10):
     // it drops the snapshot + resets the carry-forward cache. Diagnostics is
     // append-only and handled separately below.
@@ -3396,10 +3462,35 @@ export class FoundationAiAssistant extends GenesisElement {
     return this.settingsCostCurrentSlotted.length > 0;
   }
 
+  /**
+   * Whether the build-history section has anything in it — the built-in row list, or a host's own
+   * markup in the `settings-cost-history` slot.
+   *
+   * Slotted content is checked FIRST, ahead of `enabled`. That flag governs the *built-in* ledger:
+   * it gates the row writes, the reload, and the lifetime sum — and it defaults to `false`
+   * (`cost?.enabled === true`), while the Usage tab itself shows for `showCost`/`showTokens`, which
+   * default true. So a host can legitimately render its own build history into the slot and never
+   * opt into our `localStorage` ledger. Short-circuiting on `enabled` above the slot check hid that
+   * host's markup outright, since the slot is the only thing in the container.
+   */
   @volatile
   get settingsCostHistorySectionVisible(): boolean {
+    if (this.settingsCostHistorySlotted.length > 0) return true;
     if (!this.resolvedCostHistory.enabled) return false;
-    return this.costSessionHistory.length > 0 || this.settingsCostHistorySlotted.length > 0;
+    return this.costSessionHistory.length > 0;
+  }
+
+  /**
+   * Whether the "Build history" heading has anything under it.
+   *
+   * Broader than {@link FoundationAiAssistant.settingsCostHistorySectionVisible} because the
+   * heading also covers the lifetime total, which renders before the first row exists (rows are
+   * written as spend accrues, the lifetime section only needs history switched on). Gating the
+   * heading on the rows alone left that total sitting under nothing.
+   */
+  @volatile
+  get settingsCostHistoryHeadingVisible(): boolean {
+    return this.settingsCostHistorySectionVisible || this.settingsCostLifetimeVisible;
   }
 
   /** Whether the built-in Usage tab summary block has anything to show. */

package/src/utils/banked-usage-baselines.ts

@@ -0,0 +1,90 @@
+import type { AggregateUsage } from '@genesislcap/foundation-ai';
+
+/**
+ * Per-session banked baselines for the cost ledger (GENC-1475) — the spend a project had
+ * accrued *before* the transcript currently in memory. Module-level and keyed by the session
+ * `stateKey`, exactly like the diagnostics cursors and the meta-event buffer.
+ *
+ * The lifetime is the point of this module. A baseline is only meaningful paired with the
+ * transcript it complements: `row.usage = baseline + whatever that transcript proves`. The
+ * transcript lives in the per-key session store, so the baseline must live and die with that
+ * store — which means module state keyed the same way, NOT element state.
+ *
+ * Held on the element it silently double-counted. Element instances are created and destroyed
+ * many times inside one session (the assistant is remounted as the host re-renders its layout,
+ * and a popped-out bubble and a docked panel can be wired to the same session at once), and each
+ * new instance re-derived the baseline from the ledger rows. By then those rows contain the
+ * instance-before-last's own upserts, whose `usage` already includes the live transcript — so
+ * where the transcript is NOT restored on load (`resolveBankedUsage`'s "bank the whole prior
+ * total" branch, i.e. persistence off) the live session was banked as its own baseline. Lifetime
+ * then jumped by the whole session-to-date on every remount while the live figure kept climbing
+ * normally, which is the "the two totals went up by different amounts" report.
+ *
+ * Module state dies with the JS realm, so a real page reload starts clean — exactly right, since
+ * that is also when the transcript starts over.
+ *
+ * @internal
+ */
+const baselinesByKey = new Map<string, AggregateUsage>();
+
+/**
+ * The baseline resolved for `key`, or `undefined` when this session has not resolved one yet.
+ *
+ * `undefined` rather than an empty usage: "nothing banked" is a legitimate resolved value (a
+ * project's first ever session), and it must not be mistaken for "not resolved", or every write
+ * would re-derive and hit the double-count above.
+ *
+ * Returns a copy — see `setBankedBaseline` for why both ends of this map are cloned.
+ *
+ * @internal
+ */
+export function getBankedBaseline(key: string): AggregateUsage | undefined {
+  const usage = baselinesByKey.get(key);
+  return usage ? { ...usage } : undefined;
+}
+
+/**
+ * Record the baseline for `key`, replacing any previous one.
+ *
+ * Stores a copy, and `getBankedBaseline` hands back a copy, so nothing outside this module can
+ * reach the object the map holds. Both ends have to clone, because a baseline is aliased at both:
+ * `resolveBankedUsage` returns a *reference into a ledger row* (`row.banked` or `row.usage`),
+ * which is what gets stored here, and the caller then assigns what it reads back onto the NEXT
+ * row's `banked` field. Uncloned, one object is reachable from page-global state, two rows, and —
+ * since the row list is public and gets handed to a host's `saveCostHistory` — from host code.
+ * Whoever mutated it would silently rewrite this project's baseline for the rest of the page.
+ *
+ * A shallow spread is a complete copy: `AggregateUsage` is five flat numbers, no nested state.
+ *
+ * @internal
+ */
+export function setBankedBaseline(key: string, usage: AggregateUsage): void {
+  baselinesByKey.set(key, { ...usage });
+}
+
+/**
+ * Drop the baseline for `key`, so the next write re-derives it from the ledger rows.
+ *
+ * For when the pairing is broken deliberately at the *row* end — the row this baseline came from
+ * has been deleted, or the whole ledger cleared — and for a session teardown, where the store
+ * (and with it the transcript) is disposed and a later return re-restores from scratch.
+ *
+ * NOT for a mid-session reload of the rows: those rows already include this session's own
+ * upserts, so re-deriving from them folds the live transcript into its own baseline.
+ *
+ * @internal
+ */
+export function deleteBankedBaseline(key: string): void {
+  baselinesByKey.delete(key);
+}
+
+/**
+ * Forget every baseline — the page-load boundary, which production gets for free from module
+ * state dying with the realm. Exists so tests can model separate page loads (and so one test's
+ * session key cannot leak a baseline into the next).
+ *
+ * @internal
+ */
+export function resetBankedBaselines(): void {
+  baselinesByKey.clear();
+}