@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/utils/condense-history.ts

@@ -1,448 +0,0 @@
-import type { ChatMessage, CondensePolicy, CondenseTrigger } from '@genesislcap/foundation-ai';
-
-/**
- * Tool-context condensation: collapse stale tool payloads out of the history
- * sent to the model, while leaving stored history untouched.
- *
- * The driver owns the registry (tool handlers populate it via `condenseWhen`)
- * and the cadence (this runs before every provider call). This module owns the
- * pure application: given the registry + the current loop iteration, produce a
- * rewritten copy of the history with stale args/results replaced by stubs. Kept
- * pure (no driver/session state, no logging) so it unit-tests in isolation —
- * the one-time `context.condensed` signal is delivered via an `onCondensed`
- * callback rather than reaching into the debug-event log directly.
- *
- * @packageDocumentation
- */
-
-/**
- * Below this serialized size a tool payload isn't worth condensing — the stub
- * would save little and cost a breadcrumb. A driver-level floor so the public
- * `condenseWhen` API needs no per-policy threshold field.
- */
-export const CONDENSE_MIN_CHARS = 1000;
-
-/** Key the collapsed args are stored under — a tool-call's args must stay a Record. */
-export const CONDENSED_ARGS_KEY = 'condensed';
-
-/**
- * Rough chars-per-token divisor for the `tokensSaved` estimate. No tokenizer is
- * available in this stack; ~4 chars/token is the usual English approximation.
- */
-const APPROX_CHARS_PER_TOKEN = 4;
-
-/**
- * A `condenseWhen` policy registered against a tool-call id, with its age clock
- * and report-once flags. The driver holds these in a `Map<toolCallId, …>`;
- * {@link applyCondensation} reads them and flips the `reported*` flags so the
- * `context.condensed` signal fires once per payload, not once per provider call.
- */
-export interface RegisteredCondensePolicy {
-  policy: CondensePolicy;
-  /**
-   * Monotonic model-call sequence (`modelCallSeq`) when `condenseWhen` was called
-   * — the origin of the age clock. Driver-lifetime and NOT reset per turn, so age
-   * is measured consistently across turn boundaries (the field name is historical;
-   * it is not the per-turn loop iteration).
-   */
-  iteration: number;
-  /** Turn (`sendMessage`) sequence when the call was made — the `turnEnd` clock. */
-  turn: number;
-  /** Agent-activation sequence when the call was made — the `agentEnd` clock. */
-  activation: number;
-  /** App-controlled phase epoch when the call was made — the `phaseEnd` clock. */
-  phaseEpoch: number;
-  /** `context.condensed` already emitted for the args payload (fire-once). */
-  reportedArgs?: boolean;
-  /** `context.condensed` already emitted for the response payload (fire-once). */
-  reportedResponse?: boolean;
-  /**
-   * The first trigger to fire for this call, latched on the pass it fired.
-   *
-   * "Fired", not "collapsed": it is written during trigger resolution, before the
-   * per-payload size floor is applied, so an entry whose payloads are all below the floor
-   * can latch without anything ever rendering. That is deliberate and safe — both payloads
-   * of a call resolve off the same clocks in the same pass, so they can never disagree
-   * about which trigger fired, and a payload's size is fixed for the life of the call
-   * (condensation never touches stored history), so a below-floor payload can never later
-   * become a large one under a stale reason.
-   *
-   * Trigger resolution picks the first LISTED trigger that is *currently* true, so without
-   * this it re-evaluates on every provider call and can change after the collapse: with the
-   * usual `on: [{superseded}, {agentEnd}]`, a payload collapsed at `agentEnd` silently
-   * re-resolves to `superseded` as soon as a newer call on the same key lands. Any stub that
-   * embeds the reason (`pointer` does) is then rewritten — an in-place history mutation that
-   * invalidates the prompt cache from that position a second time, for a payload that had
-   * already collapsed. Latching keeps the rendered stub stable, which is sound because a
-   * collapse is monotonic and never reverts, so the first trigger to fire is the correct
-   * one to keep.
-   */
-  firedTrigger?: CondenseTrigger;
-}
-
-/**
- * The driver's live state at the moment of a provider call — the clocks every
- * trigger is evaluated against. Passed by the driver; kept as an interface so the
- * transform stays a pure function of (history, policies, clocks).
- */
-export interface CondenseContext {
-  /** Monotonic model-call sequence now — the `age` clock. */
-  modelCall: number;
-  /** Monotonic turn (`sendMessage`) sequence now — the `turnEnd` clock. */
-  turn: number;
-  /** Whether the agent activation that made a call has since ended — the `agentEnd` clock. */
-  activationEnded: (activation: number) => boolean;
-  /**
-   * Whether a later phase epoch is current than the one a call was made in — the
-   * `phaseEnd` clock. True once `endPhase()` has been called since the call.
-   */
-  phaseEnded: (phaseEpoch: number) => boolean;
-  /**
-   * Collapse in batches of this many model-calls instead of continuously. A positive
-   * integer; decimals are floored and anything below `1` becomes `1`. Omit (or `1`) to
-   * collapse as soon as a trigger fires, which is the historical behaviour.
-   *
-   * Condensation rewrites a payload *in place*, so the model-bound history is not
-   * append-only and every prompt-cache entry written before the rewrite is invalidated
-   * from that position on. Collapsing the moment each trigger fires therefore breaks the
-   * cache on nearly every call of a re-read loop — the case condensation exists to
-   * contain. Batching holds the collapse set still between boundaries so the prefix is
-   * append-only in between, trading up to `batchCalls` calls' worth of extra context for
-   * one cache break per batch instead of one per call.
-   *
-   * `agentEnd` and `phaseEnd` are exempt and still collapse as they fire: they mark a
-   * discontinuity that invalidates the cached prefix anyway, so deferring them would hold
-   * stale payloads longer for nothing.
-   */
-  batchCalls?: number;
-}
-
-/**
- * Structured detail for a `context.condensed` meta-event. The index signature
- * lets it satisfy `recordMetaEvent`'s `Record<string, unknown>` detail param
- * while the named fields stay strictly typed.
- */
-export interface CondensedEventDetail {
-  [key: string]: unknown;
-  /** Tool-loop iteration the collapsed call was made on. */
-  turn: number;
-  toolCallId: string;
-  tool: string;
-  target: 'args' | 'response';
-  /** Human-readable trigger, e.g. `superseded:Foo.tsx` or `age:3`. */
-  trigger: string;
-  /** Length of the replacement stub. */
-  stubLen: number;
-  /** Estimated input tokens saved this collapse (char/4 — no tokenizer in-stack). */
-  tokensSaved: number;
-}
-
-/** Short human-readable reason for the stub text, per fired trigger. */
-function triggerReason(trigger: CondenseTrigger): string {
-  switch (trigger.kind) {
-    case 'age':
-      return 'aged out';
-    case 'turnEnd':
-      return 'turn ended';
-    case 'agentEnd':
-      return 'agent finished';
-    case 'phaseEnd':
-      return 'phase ended';
-    default:
-      return 'superseded';
-  }
-}
-
-/**
- * Framework-generated stub, shared by `pointer` and `drop`. Names the tool, the superseded key
- * (the only surviving identifier once args are elided — the model cannot otherwise tell WHICH
- * file a collapsed `vfs_write` wrote) and the original size.
- *
- * `restorable` is the ONLY difference between the two modes: `pointer` promises that re-calling
- * reproduces the content and is valid solely for idempotent tools; `drop` makes no such promise
- * and must not carry the clause. Identifying information is not what separates them — a stub too
- * bare to say what the call did is how GENC-1494 started.
- */
-function condenseStub(
-  target: 'args' | 'response',
-  tool: string,
-  trigger: CondenseTrigger,
-  origLen: number,
-  restorable: boolean,
-  /**
-   * Images elided alongside the text. Reported separately because the model reads this stub as
-   * fact: folding base64 bytes into the char count would tell it a 15KB render was "~15447
-   * chars" of prose. One variable cannot be both the size FLOOR (bytes, correctly) and a
-   * model-facing description (characters).
-   */
-  imageCount = 0,
-): string {
-  const what = target === 'args' ? 'args' : 'result';
-  const key = trigger.kind === 'superseded' ? ` ${trigger.by}` : '';
-  const restore = restorable ? '; re-call to restore' : '';
-  const images = imageCount > 0 ? ` + ${imageCount} image${imageCount === 1 ? '' : 's'}` : '';
-  return `[${tool}${key} — ${what} elided, ~${origLen} chars${images} (${triggerReason(trigger)})${restore}]`;
-}
-
-/** Stable label for the `context.condensed` meta-event's `trigger` field. */
-function triggerLabel(trigger: CondenseTrigger): string {
-  switch (trigger.kind) {
-    case 'age':
-      return `age:${trigger.turns}`;
-    case 'superseded':
-      return `superseded:${trigger.by}`;
-    default:
-      return trigger.kind; // 'turnEnd' | 'agentEnd' | 'phaseEnd'
-  }
-}
-
-function estimateTokensSaved(origLen: number, stubLen: number): number {
-  return Math.max(0, Math.ceil((origLen - stubLen) / APPROX_CHARS_PER_TOKEN));
-}
-
-/**
- * Whether a trigger marks a genuine discontinuity rather than firing continuously, and so is
- * exempt from batching.
- *
- * `agentEnd` advances only when the active agent's name changes (or a sub-agent completes /
- * the agent is released), which swaps the system prompt and tool definitions — those render
- * before the messages, so the cached prefix is invalidated at that point regardless. `phaseEnd`
- * is the app declaring the same kind of boundary explicitly, and falls back to `agentEnd`.
- * Deferring either to the next batch would buy no cache and only hold stale payloads longer.
- *
- * The rest fire continuously (`superseded`, `age`) or at a point where the history is otherwise
- * append-only (`turnEnd` — a new turn appends a user message, leaving the previous entry live),
- * so batching them is exactly where the cache is won.
- */
-function marksDiscontinuity(kind: CondenseTrigger['kind']): boolean {
-  return kind === 'agentEnd' || kind === 'phaseEnd';
-}
-
-/**
- * Collapse stale tool payloads (declared via `condenseWhen`) out of the
- * model-bound history. Pure over the `history` array — it emits new message
- * objects and never mutates the input messages (mirroring the agent-masking
- * transform). It DOES, however, write two latches onto the matching `policies`
- * entry the first time a payload collapses, both because the collapse itself
- * re-runs before every provider call: the `reported*` flag (the report-once gate
- * that keeps `onCondensed` firing once per (tool call, payload)) and
- * `firedTrigger` (which pins the reason so a reason-bearing stub is rendered
- * once and never rewritten).
- *
- * Triggers (a policy may list several via `on: Trigger[]` — the FIRST to fire
- * collapses the payload; all are monotonic, so the collapse never reverts):
- * - `superseded` — among all registered calls sharing a `by` key, the LAST in
- *   history order survives; every earlier one's targeted payload collapses. A
- *   re-call with the same key becomes the new survivor and re-arms the rest.
- * - `age` — the result is first visible one model-call after the call, so `turns`
- *   is how many model-calls may see the full result before it collapses
- *   (fires when `modelCall − callModelCall > turns`): `turns: 1` is seen once,
- *   then collapses. The clock is monotonic across turns.
- * - `turnEnd` — collapses once the turn (`sendMessage`) that made the call has
- *   ended (fires when `turn > callTurn`): full for the rest of that request,
- *   gone on every later one.
- * - `agentEnd` — collapses once the agent activation that made the call has ended
- *   (a swap to another agent, or `releaseAgent`/`completeSubAgent`): kept across
- *   all of the agent's turns, dropped when its flow finishes.
- * - `phaseEnd` — collapses once the app advances its phase epoch via `endPhase()`
- *   after the call (a sub-`agentEnd` boundary the author declares), OR at
- *   `agentEnd` as a backstop if no boundary is ever declared.
- *
- * The tool-call/result envelope is never removed (providers reject orphaned
- * calls/results) — only the args object or the result content is replaced.
- *
- * @param history - The to-model history copy to rewrite (not mutated).
- * @param policies - The driver's registry, keyed by tool-call id. Its entries'
- *   `reported*` flags are flipped as payloads first collapse.
- * @param ctx - The driver's live clocks (model-call / turn / agent-activation).
- * @param onCondensed - Invoked once per payload at its full→stub transition.
- */
-export function applyCondensation(
-  history: ChatMessage[],
-  policies: Map<string, RegisteredCondensePolicy>,
-  ctx: CondenseContext,
-  onCondensed: (detail: CondensedEventDetail) => void,
-): ChatMessage[] {
-  if (policies.size === 0) return history;
-
-  const triggersOf = (entry: RegisteredCondensePolicy): CondenseTrigger[] =>
-    Array.isArray(entry.policy.on) ? entry.policy.on : [entry.policy.on];
-
-  // One pass: resolve supersession survivors and a toolCallId → tool-name
-  // lookup. For each `superseded` key the LAST call in history order survives.
-  // The name lookup lets a tool message (which carries only an id) name its tool
-  // in stubs and events.
-  // Batch boundary: the collapse set is resolved as of this model-call and stays put
-  // until the next boundary, so the prefix is append-only in between. `batchCalls` of 1
-  // (the default) makes this `ctx.modelCall` — i.e. no batching.
-  const batchCalls = Math.max(1, Math.floor(ctx.batchCalls ?? 1));
-  const asOf =
-    batchCalls === 1 ? ctx.modelCall : Math.floor(ctx.modelCall / batchCalls) * batchCalls;
-  // A call made after the boundary is invisible to this pass in BOTH directions: it
-  // cannot supersede an older call (which would collapse the older payload early), and
-  // it cannot itself collapse (which would elide the very result just fetched). Unbatched,
-  // the boundary is the live clock and this gate is off entirely — a call registered on
-  // the current model-call is still eligible, as it always was.
-  const withinBatch = (entry: RegisteredCondensePolicy): boolean =>
-    batchCalls === 1 || entry.iteration <= asOf;
-
-  const latestByKey = new Map<string, string>();
-  const nameById = new Map<string, string>();
-  for (const msg of history) {
-    if (!msg.toolCalls?.length) continue;
-    for (const tc of msg.toolCalls) {
-      nameById.set(tc.id, tc.name);
-      const entry = policies.get(tc.id);
-      if (!entry || !withinBatch(entry)) continue;
-      for (const t of triggersOf(entry)) {
-        if (t.kind === 'superseded') latestByKey.set(t.by, tc.id);
-      }
-    }
-  }
-
-  const triggerFires = (
-    toolCallId: string,
-    entry: RegisteredCondensePolicy,
-    trig: CondenseTrigger,
-  ): boolean => {
-    switch (trig.kind) {
-      // Result first visible one model-call after the call, so collapse one call
-      // past the last allowed view: turns:1 → seen once, then gone. Monotonic
-      // clock, so this holds across turn boundaries too.
-      case 'age':
-        return asOf - entry.iteration > trig.turns;
-      case 'turnEnd':
-        return ctx.turn > entry.turn;
-      case 'agentEnd':
-        return ctx.activationEnded(entry.activation);
-      // Fires when the app advanced the phase epoch since the call — OR, as a
-      // backstop, when the whole activation has ended, so a phase boundary that
-      // is never declared still collapses at `agentEnd` rather than never.
-      case 'phaseEnd':
-        return ctx.phaseEnded(entry.phaseEpoch) || ctx.activationEnded(entry.activation);
-      default:
-        return latestByKey.get(trig.by) !== toolCallId; // superseded by a newer call
-    }
-  };
-
-  // The first listed trigger that fires — drives the collapse, the stub reason,
-  // and the event label. `undefined` means the payload stays full.
-  //
-  // Latched on first fire (see `firedTrigger`): re-resolving on every pass lets the reason
-  // change under a payload that has already collapsed, which rewrites any reason-bearing stub
-  // and costs a second cache break. Both payloads of a call share the latch — they are
-  // evaluated in the same pass off the same clocks, so they never disagree about which
-  // trigger fired; only the size floor decides whether each one renders.
-  const firstFired = (
-    toolCallId: string,
-    entry: RegisteredCondensePolicy,
-  ): CondenseTrigger | undefined => {
-    if (entry.firedTrigger) return entry.firedTrigger;
-    const fired = triggersOf(entry).find(
-      (t) =>
-        (marksDiscontinuity(t.kind) || withinBatch(entry)) && triggerFires(toolCallId, entry, t),
-    );
-    if (fired) entry.firedTrigger = fired;
-    return fired;
-  };
-
-  return history.map((msg) => {
-    // Tool-call ARGS live on the assistant message.
-    if (msg.toolCalls?.length) {
-      let changed = false;
-      const toolCalls = msg.toolCalls.map((tc) => {
-        const entry = policies.get(tc.id);
-        if (!entry?.policy.args) return tc;
-        const fired = firstFired(tc.id, entry);
-        if (!fired) return tc;
-        const origLen = JSON.stringify(tc.args ?? {}).length;
-        if (origLen < CONDENSE_MIN_CHARS) return tc;
-        changed = true;
-        const result = entry.policy.args;
-        // Args must stay a Record, so every mode stashes its stub under a single key.
-        // Spread `tc` so providerMetadata (e.g. the Gemini reasoning signature that must
-        // round-trip) and UI fields survive.
-        //
-        // GENC-1494: `drop` used to collapse args to a bare `{}`. That is indistinguishable
-        // from a call the model made with NO arguments, and the model reads its own history
-        // as fact: a ui-builder run saw its elided `vfs_write` calls as `vfs_write {}` beside
-        // a live `{"status":"buffered","path":"…"}` result, concluded it was calling the tool
-        // without content, and burned two hours re-writing files that were already correct.
-        // A bare marker is not enough either — it still fails to say WHICH file the call
-        // wrote, since `path` went with the args. So `drop` renders the same identifying stub
-        // as `pointer`, minus only the restore promise it cannot honour.
-        const args: Record<string, unknown> = {
-          [CONDENSED_ARGS_KEY]:
-            result === 'drop' || result === 'pointer'
-              ? condenseStub('args', tc.name, fired, origLen, result === 'pointer')
-              : result.replaceWith,
-        };
-        if (!entry.reportedArgs) {
-          entry.reportedArgs = true;
-          const stubLen = JSON.stringify(args).length;
-          onCondensed({
-            turn: entry.iteration,
-            toolCallId: tc.id,
-            tool: tc.name,
-            target: 'args',
-            trigger: triggerLabel(fired),
-            stubLen,
-            tokensSaved: estimateTokensSaved(origLen, stubLen),
-          });
-        }
-        return { ...tc, args };
-      });
-      return changed ? { ...msg, toolCalls } : msg;
-    }
-
-    // The tool RESULT lives on the tool message.
-    if (msg.toolResult) {
-      const entry = policies.get(msg.toolResult.toolCallId);
-      // Defensive `?? 0` for restored/malformed history — `content` is typed
-      // `string`, but a 0-length payload is simply below the floor and skipped.
-      //
-      // Attachment bytes COUNT toward the floor (GENC-1508). An image-bearing result is
-      // typically a few words of text — "rendered the mockup" — plus ~15KB of base64, so
-      // sizing on `content` alone leaves it permanently under CONDENSE_MIN_CHARS and the
-      // image rides every subsequent turn. That is the exact payload condensation exists
-      // to shed, so it must be what is measured.
-      const textLen = msg.toolResult.content?.length ?? 0;
-      const images = msg.toolResult.attachments ?? [];
-      // Bytes gate the FLOOR (an image result is a few words of text plus ~15KB of base64, so
-      // sizing on text alone would never condense it); `textLen` and the image count are what
-      // the model is told. See condenseStub.
-      const origLen = textLen + images.reduce((n, att) => n + (att.data?.length ?? 0), 0);
-      const fired = entry?.policy.response
-        ? firstFired(msg.toolResult.toolCallId, entry)
-        : undefined;
-      if (entry && fired && origLen >= CONDENSE_MIN_CHARS) {
-        const tool = nameById.get(msg.toolResult.toolCallId) ?? msg.toolResult.toolCallId;
-        const result = entry.policy.response!; // `fired` is only set when response is declared
-        // Kept non-empty — Anthropic rejects empty tool_result content.
-        const content =
-          result === 'drop' || result === 'pointer'
-            ? condenseStub('response', tool, fired, textLen, result === 'pointer', images.length)
-            : result.replaceWith;
-        if (!entry.reportedResponse) {
-          entry.reportedResponse = true;
-          onCondensed({
-            turn: entry.iteration,
-            toolCallId: msg.toolResult.toolCallId,
-            tool,
-            target: 'response',
-            trigger: triggerLabel(fired),
-            stubLen: content.length,
-            tokensSaved: estimateTokensSaved(origLen, content.length),
-          });
-        }
-        // `attachments` is dropped, not spread through: the stub says the payload was
-        // elided, and leaving the images attached would make that a lie AND shed none of
-        // the bytes the condensation was performed to shed.
-        const { attachments: _elided, ...restOfResult } = msg.toolResult;
-        return { ...msg, toolResult: { ...restOfResult, content } };
-      }
-    }
-
-    return msg;
-  });
-}

package/src/utils/cost-session-history.test.ts

@@ -1,226 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import type { CostSessionRecord } from './cost-session-history';
-import {
-  clearCostSessionHistory,
-  costHistoryStorageKey,
-  formatCostSessionDate,
-  loadCostSessionHistory,
-  resolveBankedUsage,
-  saveCostSessionHistory,
-  sortRecordsByRecency,
-  upsertRecord,
-} from './cost-session-history';
-import { emptyUsage } from './sum-usage';
-
-const scope = `test-${Date.now()}`;
-
-const usage = (costUsd: number): CostSessionRecord['usage'] => ({
-  costUsd,
-  uncachedInputTokens: 100_000,
-  cacheReadTokens: 1_200_000,
-  cacheWriteTokens: 60_000,
-  outputTokens: 40_000,
-});
-
-const sampleRecord = (overrides: Partial<CostSessionRecord> = {}): CostSessionRecord => ({
-  id: 'rec-1',
-  projectKey: 'proj-1',
-  title: 'Equity Options Pricer',
-  updatedAt: '2026-06-14T12:00:00.000Z',
-  usage: usage(1.86),
-  // Present by default so `delete record.banked` in the legacy-row cases actually removes
-  // something, and so the storage round-trip covers it.
-  banked: usage(0.5),
-  models: [{ model: 'claude-sonnet-4-6', provider: 'anthropic' }],
-  ...overrides,
-});
-
-const suite = createLogicSuite('costSessionHistory');
-
-suite('uses a scoped storage key', () => {
-  assert.is(costHistoryStorageKey('my-app'), 'genesis-ai-assistant:cost-history:my-app');
-});
-
-suite('upsertRecord prepends a project it has not seen', () => {
-  const first = upsertRecord([], sampleRecord({ id: 'a', projectKey: 'a', title: 'First' }));
-  const both = upsertRecord(first, sampleRecord({ id: 'b', projectKey: 'b', title: 'Second' }));
-  assert.is(both.length, 2);
-  // Insertion order, not recency — display ordering is sortRecordsByRecency's job.
-  assert.is(both[0]?.id, 'b', 'most recently added is prepended');
-  assert.is(both[1]?.id, 'a');
-});
-
-suite('upsertRecord replaces a project in place rather than stacking a second row', () => {
-  const seeded = [
-    sampleRecord({ id: 'b', projectKey: 'b', usage: usage(2) }),
-    sampleRecord({ id: 'a', projectKey: 'a', usage: usage(1) }),
-  ];
-  // Re-reporting a project must REPLACE its row. Appending here is what made a single
-  // project's spend count once per refresh in any total summed over the list.
-  const next = upsertRecord(seeded, sampleRecord({ id: 'a', projectKey: 'a', usage: usage(9.5) }));
-  assert.is(next.length, 2);
-  // Replaced in place rather than moved — the stored array is not a recency ordering.
-  assert.is(next[1]?.projectKey, 'a');
-  assert.is(next[1]?.usage.costUsd, 9.5);
-  assert.is(
-    next.reduce((sum, r) => sum + r.usage.costUsd, 0),
-    11.5,
-  );
-});
-
-suite('round-trips records through storage', () => {
-  clearCostSessionHistory(scope);
-  const records = upsertRecord([], sampleRecord({ id: 'a', projectKey: 'a', usage: usage(3.5) }));
-  saveCostSessionHistory(scope, records);
-  const loaded = loadCostSessionHistory(scope);
-  assert.is(loaded.length, 1);
-  assert.is(loaded[0]?.usage.costUsd, 3.5);
-  assert.is(loaded[0]?.usage.cacheReadTokens, 1_200_000, 'buckets survive serialization');
-  assert.is(loaded[0]?.banked?.costUsd, 0.5, 'banked survives serialization');
-  clearCostSessionHistory(scope);
-});
-
-suite('discards legacy rows that predate the per-project key', () => {
-  clearCostSessionHistory(scope);
-  const legacy = sampleRecord({ id: 'old' }) as Partial<CostSessionRecord>;
-  delete legacy.projectKey;
-  saveCostSessionHistory(scope, [legacy as CostSessionRecord, sampleRecord({ id: 'new' })]);
-  const loaded = loadCostSessionHistory(scope);
-  // A keyless row can never be matched to a project, so pooling it with the new rows
-  // would permanently double-count whichever project it came from.
-  assert.is(loaded.length, 1);
-  assert.is(loaded[0]?.id, 'new');
-  clearCostSessionHistory(scope);
-});
-
-suite('discards rows whose usage is not fully numeric', () => {
-  clearCostSessionHistory(scope);
-  const broken = sampleRecord({ id: 'broken' });
-  // A half-shaped `usage` is worse than a missing row: it sums as NaN and poisons every
-  // total on the Usage tab, with no clue where the NaN came from.
-  delete (broken.usage as Partial<CostSessionRecord['usage']>).outputTokens;
-  saveCostSessionHistory(scope, [broken, sampleRecord({ id: 'ok', projectKey: 'ok' })]);
-  const loaded = loadCostSessionHistory(scope);
-  assert.is(loaded.length, 1);
-  assert.is(loaded[0]?.id, 'ok');
-  clearCostSessionHistory(scope);
-});
-
-suite('discards rows whose banked figure is half-shaped', () => {
-  clearCostSessionHistory(scope);
-  const broken = sampleRecord({ id: 'broken', banked: { ...usage(2) } });
-  // A malformed `banked` poisons the lifetime total exactly as a malformed `usage` does,
-  // since the two are added together to produce it.
-  delete (broken.banked as Partial<CostSessionRecord['usage']>).cacheWriteTokens;
-  saveCostSessionHistory(scope, [broken, sampleRecord({ id: 'ok', projectKey: 'ok' })]);
-  const loaded = loadCostSessionHistory(scope);
-  assert.is(loaded.length, 1);
-  assert.is(loaded[0]?.id, 'ok');
-  clearCostSessionHistory(scope);
-});
-
-suite('keeps a row whose banked figure is absent', () => {
-  clearCostSessionHistory(scope);
-  const legacy = sampleRecord({ id: 'legacy' });
-  delete legacy.banked;
-  saveCostSessionHistory(scope, [legacy]);
-  assert.is(loadCostSessionHistory(scope).length, 1, 'absent is valid, unlike half-shaped');
-  clearCostSessionHistory(scope);
-});
-
-suite('formats session dates for display', () => {
-  assert.is(formatCostSessionDate('2026-06-14T12:00:00.000Z'), 'Jun 14, 2026');
-});
-
-suite('sortRecordsByRecency puts the most recently worked-on project first', () => {
-  const records = [
-    sampleRecord({ id: 'old', projectKey: 'old', updatedAt: '2026-01-01T00:00:00.000Z' }),
-    sampleRecord({ id: 'newest', projectKey: 'newest', updatedAt: '2026-08-04T09:00:00.000Z' }),
-    sampleRecord({ id: 'mid', projectKey: 'mid', updatedAt: '2026-05-01T00:00:00.000Z' }),
-  ];
-  const sorted = sortRecordsByRecency(records);
-  assert.equal(
-    sorted.map((r) => r.id),
-    ['newest', 'mid', 'old'],
-  );
-  // Read-time ordering, so the caller's array must be left alone.
-  assert.equal(
-    records.map((r) => r.id),
-    ['old', 'newest', 'mid'],
-    'input not mutated',
-  );
-});
-
-suite('sortRecordsByRecency overrides insertion order, which upsert leaves alone', () => {
-  // The behaviour this fixes: revisiting a project replaces its row IN PLACE, so insertion order
-  // strands it wherever it was first seen. Display order must come from updatedAt instead.
-  let records = upsertRecord(
-    [],
-    sampleRecord({ id: 'a', projectKey: 'a', updatedAt: '2026-01-01T00:00:00.000Z' }),
-  );
-  records = upsertRecord(
-    records,
-    sampleRecord({ id: 'b', projectKey: 'b', updatedAt: '2026-02-01T00:00:00.000Z' }),
-  );
-  // Work on 'a' again — newer than 'b', but upsert keeps it in slot 1.
-  records = upsertRecord(
-    records,
-    sampleRecord({ id: 'a', projectKey: 'a', updatedAt: '2026-03-01T00:00:00.000Z' }),
-  );
-  assert.is(records[1]?.id, 'a', 'stored order is unchanged by the revisit');
-  assert.is(sortRecordsByRecency(records)[0]?.id, 'a', 'display order tracks the revisit');
-});
-
-suite('banks nothing for a project with no prior row', () => {
-  assert.equal(resolveBankedUsage(undefined, true), emptyUsage());
-  assert.equal(resolveBankedUsage(undefined, false), emptyUsage());
-});
-
-suite('carries the prior banked figure forward when the transcript is authoritative', () => {
-  // Restored transcript: it already re-proves everything after the row's own banked figure,
-  // so only that figure carries over. Taking `usage` here is the compounding double-count.
-  const prior = sampleRecord({ usage: usage(10), banked: { ...usage(4) } });
-  assert.is(resolveBankedUsage(prior, true).costUsd, 4);
-});
-
-suite('banks the whole prior total when the transcript starts empty', () => {
-  // Nothing on screen accounts for the previous total, so all of it must carry over or the
-  // next turn rewrites the row down to just that turn.
-  const prior = sampleRecord({ usage: usage(10), banked: { ...usage(4) } });
-  assert.is(resolveBankedUsage(prior, false).costUsd, 10);
-});
-
-suite('treats a row predating the banked field as nothing banked', () => {
-  const legacy = sampleRecord({ usage: usage(7) });
-  delete legacy.banked;
-  assert.equal(resolveBankedUsage(legacy, true), emptyUsage());
-  // Without persistence the legacy total still carries, so upgrading loses no spend.
-  assert.is(resolveBankedUsage(legacy, false).costUsd, 7);
-});
-
-suite('is stable across repeated reloads — the regression this guards', () => {
-  // Simulate the reload cycle: usage = banked + whatever the transcript proves. With a
-  // restored transcript (worth 6 on top of 4 banked) the row must land on 10 every time,
-  // not 10 → 14 → 18 as it did when a reload re-banked the restored history.
-  const transcript = 6;
-  let row = sampleRecord({ usage: usage(10), banked: { ...usage(4) } });
-  for (let reload = 0; reload < 3; reload += 1) {
-    const banked = resolveBankedUsage(row, true);
-    row = { ...row, banked, usage: { ...usage(banked.costUsd + transcript) } };
-    assert.is(row.usage.costUsd, 10, `reload ${reload}`);
-  }
-});
-
-suite('accumulates across reloads when the transcript does not persist', () => {
-  // The mirror case: each page-load starts from an empty transcript, so the row must grow by
-  // whatever that load spends rather than being overwritten by it.
-  let row = sampleRecord({ usage: usage(10), banked: { ...usage(4) } });
-  for (const spend of [2, 3]) {
-    const banked = resolveBankedUsage(row, false);
-    row = { ...row, banked, usage: { ...usage(banked.costUsd + spend) } };
-  }
-  // 10 banked, +2 → 12; then 12 banked, +3 → 15. Never decreases.
-  assert.is(row.usage.costUsd, 15);
-});
-
-suite.run();