@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/suggestions/chat-suggestions.ts

@@ -1,186 +0,0 @@
-import {
-  attr,
-  customElement,
-  GenesisElement,
-  observable,
-  html,
-  css,
-  repeat,
-  when,
-} from '@genesislcap/web-core';
-import type { SuggestionsState } from '../main/main.types';
-
-type LoadedState = { status: 'loaded'; suggestions: string[] };
-
-const PILL_ANIMATION_STAGGER_MS = 70;
-
-const template = html<ChatSuggestions>`
-  ${when(
-    (x) => x.state.status === 'loading',
-    html<ChatSuggestions>`
-      <div class="suggestions-container">
-        ${repeat(
-          () => Array.from({ length: 3 }),
-          html`
-            <div class="suggestion-placeholder"></div>
-          `,
-        )}
-      </div>
-    `,
-  )}
-  ${when(
-    (x) => x.state.status === 'loaded',
-    html<ChatSuggestions>`
-      <div class="suggestions-container">
-        ${repeat(
-          (x) => (x.state as LoadedState).suggestions,
-          html<string, ChatSuggestions>`
-            <button
-              class="suggestion-pill"
-              style="animation-delay: ${(_, c) => c.index * PILL_ANIMATION_STAGGER_MS}ms"
-              @click="${(suggestion, c) => c.parent.handleSuggestionClick(suggestion)}"
-            >
-              ${(suggestion) => suggestion}
-            </button>
-          `,
-        )}
-      </div>
-    `,
-  )}
-`;
-
-const styles = css`
-  :host {
-    /* Collapsed unless there is something to render (see hasContent), so the empty
-       host never occupies space or shows through a consumer's border as a stray
-       line. */
-    display: none;
-  }
-
-  :host([has-content]) {
-    display: block;
-  }
-
-  .suggestions-container {
-    display: flex;
-    flex-wrap: wrap;
-    align-items: center;
-    gap: 6px;
-    padding: calc(var(--design-unit) * 2px) calc(var(--design-unit) * 3px);
-    background-color: var(--neutral-layer-2);
-    animation: suggestions-appear 0.2s ease-out both;
-  }
-
-  @keyframes suggestions-appear {
-    from {
-      opacity: 0;
-      transform: translateY(6px);
-    }
-
-    to {
-      opacity: 1;
-      transform: translateY(0);
-    }
-  }
-
-  .suggestion-pill {
-    display: inline-flex;
-    align-items: center;
-    padding: 5px 14px;
-    background: color-mix(in srgb, var(--accent-fill-rest) 10%, var(--neutral-layer-3));
-    color: var(--neutral-foreground-rest);
-    border: 1px solid color-mix(in srgb, var(--accent-fill-rest) 25%, var(--neutral-stroke-rest));
-    border-radius: 20px;
-    font-family: var(--body-font);
-    font-size: 0.85em;
-    cursor: pointer;
-    transition:
-      background 0.15s ease,
-      border-color 0.15s ease,
-      transform 0.15s ease,
-      box-shadow 0.15s ease;
-    animation: pill-appear 0.3s ease-out both;
-    max-width: 100%;
-    white-space: normal;
-    text-align: left;
-  }
-
-  .suggestion-pill:hover {
-    background: color-mix(in srgb, var(--accent-fill-rest) 20%, var(--neutral-layer-3));
-    border-color: color-mix(in srgb, var(--accent-fill-rest) 50%, var(--neutral-stroke-rest));
-    transform: translateY(-1px);
-    box-shadow: 0 2px 8px color-mix(in srgb, var(--accent-fill-rest) 20%, transparent);
-  }
-
-  .suggestion-pill:active {
-    transform: translateY(0);
-    box-shadow: none;
-  }
-
-  @keyframes pill-appear {
-    from {
-      opacity: 0;
-      transform: scale(0.88) translateY(4px);
-    }
-
-    to {
-      opacity: 1;
-      transform: scale(1) translateY(0);
-    }
-  }
-
-  .suggestion-placeholder {
-    height: 30px;
-    width: 110px;
-    background: var(--neutral-layer-3);
-    border-radius: 20px;
-    animation: placeholder-pulse 1.6s ease-in-out infinite;
-  }
-
-  .suggestion-placeholder:nth-child(2) {
-    width: 150px;
-    animation-delay: 0.25s;
-  }
-
-  .suggestion-placeholder:nth-child(3) {
-    width: 130px;
-    animation-delay: 0.5s;
-  }
-
-  @keyframes placeholder-pulse {
-    0%,
-    100% {
-      opacity: 0.35;
-    }
-
-    50% {
-      opacity: 0.65;
-    }
-  }
-`;
-
-@customElement({
-  name: 'chat-suggestions',
-  template,
-  styles,
-})
-export class ChatSuggestions extends GenesisElement {
-  @observable
-  state: SuggestionsState = { status: 'idle' };
-
-  /**
-   * Reflected to a `has-content` attribute so the host can collapse when there is
-   * nothing to render. True only while loading or when loaded with at least one
-   * suggestion; idle, errored, and empty-loaded states render nothing.
-   */
-  @attr({ attribute: 'has-content', mode: 'boolean' }) hasContent = false;
-
-  stateChanged(): void {
-    const s = this.state;
-    this.hasContent = s.status === 'loading' || (s.status === 'loaded' && s.suggestions.length > 0);
-  }
-
-  handleSuggestionClick(suggestion: string): void {
-    this.$emit('suggestion-clicked', suggestion);
-  }
-}

package/src/tags/index.ts

@@ -1 +0,0 @@
-export {};

package/src/types/ai-chat-widget.ts

@@ -1,67 +0,0 @@
-import type { InteractionResult } from '@genesislcap/foundation-ai';
-import type { InteractionContext } from './interaction-context';
-
-/**
- * The two mutually-exclusive states an interaction widget is ever in (GENC-1390).
- * Modelling them as a discriminated union makes illegal combinations
- * unrepresentable — a resolved widget cannot carry a live `interactionContext` or
- * a `shouldAutoFocus`, and a pending widget cannot be read for a `result`.
- *
- * The host sets the widget's `interaction` on mount and REPLACES it (pending →
- * resolved) on completion.
- *
- * @beta
- */
-export type AiChatInteraction<TData = unknown, TResult = unknown> =
-  | {
-      status: 'pending';
-      /** Immutable inputs for the interaction. */
-      data: TData;
-      /**
-       * Grab focus on mount? Meaningful ONLY while pending — a resolved widget is a
-       * history re-render and must never steal focus.
-       */
-      shouldAutoFocus: boolean;
-      /**
-       * Live, remount-surviving scratch for this interaction. Present ONLY while
-       * pending — the host disposes it on resolve. See {@link InteractionContext}.
-       */
-      interactionContext: InteractionContext;
-    }
-  | {
-      status: 'resolved';
-      /** Same inputs — the resolved view still reads them. */
-      data: TData;
-      /** The interaction outcome. */
-      result: InteractionResult<TResult>;
-    };
-
-/**
- * Interface that AI inline interaction components implement. The
- * `AiChatInteractionWrapper` sets `interactionId` and `interaction` on the
- * rendered element on every (re)mount, and replaces `interaction` (pending →
- * resolved) when the interaction completes.
- *
- * @remarks
- * GENC-1390 replaced the previous flat `data` / `resolved` / `shouldAutoFocus`
- * surface with the discriminated {@link AiChatInteraction}. This is a breaking
- * change on this `@beta` interface — widgets read `this.interaction` (narrowing on
- * `status`) instead of the removed flat fields.
- *
- * @remarks
- * A widget talks back by dispatching two events, both caught by the wrapper:
- * `interaction-completed` resolves the interaction (once — a second is ignored), and
- * `interaction-cost` reports a positive USD delta for paid work done AFTER resolving,
- * which repeated calls sum. The second exists for widgets that resolve early so the
- * assistant stops waiting, then keep working for the user; without it that spend is
- * billed but missing from the total the user sees.
- *
- * @beta
- */
-export interface AiChatWidget<TData = unknown, TResult = unknown> {
-  /** Stable per-interaction UUID; constant across remounts, present in both states. */
-  interactionId: string;
-
-  /** The current interaction state (pending or resolved). */
-  interaction: AiChatInteraction<TData, TResult>;
-}

package/src/types/interaction-context.ts

@@ -1,82 +0,0 @@
-/**
- * A live, per-interaction scratch space owned by the chat host (keyed by
- * `interactionId`) and handed to a widget on every (re)mount.
- *
- * WHY: an interaction widget element is destroyed+recreated on layout reflow
- * (GoldenLayout rebuilds/reparents on panel add/remove AND on drag), on
- * dock/undock, and on transcript re-render (the keyless `repeat`). The element
- * cannot hold anything live across that; this object can, because the host keeps
- * it alive for the interaction's lifetime, independent of the element. (GENC-1390)
- *
- * LIVE-ONLY — never persisted. A reload / project switch / session restore wipes
- * it; the interaction is then rebuilt purely from the serialisable `data` +
- * `result`. Never store here anything that must survive a reload: durable inputs
- * belong in the interaction's `data`, the outcome in its resolved payload.
- *
- * LIFETIME — created lazily when the interaction is requested, reused for every
- * remount of that same `interactionId`. Torn down (its `onDispose` callbacks fire
- * once) when the interaction RESOLVES or is evicted — NOT when the element
- * unmounts. That inversion is the point: a transient unmount (drag, re-render)
- * must leave context-owned resources (sockets, timers) untouched; only completion
- * ends them.
- *
- * NOTE: `subscribe`/`notify` are a plain observer list, not a reactivity engine
- * and not a FAST dependency. `notify()` renders nothing — it signals the
- * currently-mounted element "state changed, re-read", and the element updates its
- * own observables and re-renders with whatever primitives it has.
- *
- * @beta
- */
-export interface InteractionContext<TState extends object = Record<string, unknown>> {
-  /** Stable id of the interaction this context belongs to. */
-  readonly interactionId: string;
-
-  /**
-   * Durable, remount-surviving source of truth for the interaction — a socket
-   * handle, the current phase, a half-typed draft. A plain object, deliberately
-   * NOT reactive: a widget renders from its own observables and reads/writes this
-   * on mount and on change so the next remount can recover.
-   */
-  readonly state: TState;
-
-  /**
-   * Run `factory` at most once for this interaction's lifetime and memoise the
-   * result; every later call with the same `key` (including after a remount)
-   * returns the stored value without re-running. Covers one-shot side effects and
-   * create-once live resources alike:
-   *
-   * ```ts
-   * ctx.once('open-panel', () => this.dispatchEvent(openPanelEvent)); // fires once, ever
-   * const ws = ctx.once('ws', () => new TestDataWebSocketService());  // same instance each remount
-   * ```
-   *
-   * Returns `null` once the interaction has ended (resolve/timeout/evict): the
-   * factory is NOT run, because a resource created on a disposed context would
-   * never be torn down (its `onDispose` has already fired). A widget that opens a
-   * live resource here must guard on the resolved state and stop touching `once`
-   * when the interaction completes — a stray late call (e.g. an async callback
-   * landing after a `timeoutMs` timeout) gets `null` rather than a leaked resource.
-   */
-  once<T>(key: string, factory: () => T): T | null;
-
-  /**
-   * Signal that `state` changed so subscribers re-read. NOT a renderer —
-   * just a change ping; the subscribing element updates its own observables.
-   */
-  notify(): void;
-
-  /**
-   * Observe `state` changes. Call in `connectedCallback`; call the returned
-   * unsubscribe in `disconnectedCallback`.
-   */
-  subscribe(listener: () => void): () => void;
-
-  /**
-   * Register a teardown run exactly once when the interaction ends (resolve or
-   * evict) — the correct home for closing sockets/timers created via `once`.
-   * Decoupled from the element's `disconnectedCallback`, which fires on every
-   * transient unmount and must NOT tear these down. Registering after the context
-   * has already been disposed runs `fn` immediately.
-   */
-  onDispose(fn: () => void): void;
-}

package/src/utils/animated-panel-toggle.ts

@@ -1,62 +0,0 @@
-/**
- * Drives the open/close lifecycle of a slide-out panel inside a component's
- * shadow root, with a tracked close timer instead of an `animationend`
- * listener so the panel cannot wedge open if it's unmounted mid-animation
- * (pop-in/pop-out, dock change, host disconnect).
- *
- * @internal
- */
-export class AnimatedPanelToggle {
-  private timer?: ReturnType<typeof setTimeout>;
-
-  constructor(
-    private readonly host: HTMLElement,
-    private readonly selector: string,
-    private readonly closeDurationMs: number,
-    private readonly getOpen: () => boolean,
-    private readonly setOpen: (v: boolean) => void,
-  ) {}
-
-  private queryPanel(): HTMLElement | null {
-    return this.host.shadowRoot?.querySelector(this.selector) as HTMLElement | null;
-  }
-
-  toggle(): void {
-    if (this.getOpen()) {
-      // Capture the panel reference now so the timer callback strips
-      // `closing` from the same node, regardless of any later remounts.
-      // Leftover `closing` is what breaks the next open: with
-      // `animation-fill-mode: forwards` the slide-out keyframe pins the panel
-      // to opacity 0, so a remount looks like a no-op.
-      const panel = this.queryPanel();
-      panel?.classList.add('closing');
-      if (this.timer != null) clearTimeout(this.timer);
-      this.timer = setTimeout(() => {
-        this.timer = undefined;
-        panel?.classList.remove('closing');
-        this.setOpen(false);
-      }, this.closeDurationMs);
-    } else {
-      // Re-opened mid-close: cancel the pending flip and strip the closing
-      // class so the panel snaps back to the open state.
-      if (this.timer != null) {
-        clearTimeout(this.timer);
-        this.timer = undefined;
-        this.queryPanel()?.classList.remove('closing');
-      }
-      this.setOpen(true);
-    }
-  }
-
-  /**
-   * Synchronously finalise an in-flight close — call from
-   * `disconnectedCallback` so the closed state lands in the store before any
-   * session ref is cleared.
-   */
-  finalize(): void {
-    if (this.timer == null) return;
-    clearTimeout(this.timer);
-    this.timer = undefined;
-    this.setOpen(false);
-  }
-}

package/src/utils/animation-exclusivity.test.ts

@@ -1,72 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import type { AiAssistantAnimation } from '../main/main.types';
-import { resolveExclusiveLoadingStyle } from './animation-exclusivity';
-
-const suite = createLogicSuite('resolveExclusiveLoadingStyle');
-
-suite('leaves a selection with only the dots loading style untouched', () => {
-  const next: AiAssistantAnimation[] = ['loading', 'halo'];
-  assert.equal(resolveExclusiveLoadingStyle(next, ['halo']), ['loading', 'halo']);
-});
-
-suite('leaves a selection with only the waves loading style untouched', () => {
-  const next: AiAssistantAnimation[] = ['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/src/utils/animation-exclusivity.ts

@@ -1,40 +0,0 @@
-import type { AiAssistantAnimation } from '../main/main.types';
-import { LOADING_STYLE_ANIMATIONS } from '../main/main.types';
-
-/**
- * Enforces that at most one loading-indicator style (dots vs. waves) is enabled
- * at a time. The two are alternative presentations of the same "assistant is
- * working" state, so selecting one must deselect the other.
- *
- * The settings control is a multiselect (checkboxes), which permits selecting
- * both; this resolver makes the loading-style group behave like a radio group
- * by dropping the previously-selected style whenever a new one is added.
- *
- * @param next - The freshly-selected animation list (e.g. emitted by the
- *   multiselect, or read from consumer config).
- * @param previous - The animation list in effect before this change. Used to
- *   work out which loading style was just added so the other can be dropped.
- *   Pass `[]` when resolving an initial/config value with no prior state.
- * @returns `next` with at most one loading style retained. When both are
- *   present and neither is newly added (e.g. a misconfigured `enabled` list),
- *   the first entry of `LOADING_STYLE_ANIMATIONS` (dots) wins.
- *
- * @internal
- */
-export function resolveExclusiveLoadingStyle(
-  next: AiAssistantAnimation[],
-  previous: AiAssistantAnimation[] = [],
-): AiAssistantAnimation[] {
-  const selectedStyles = LOADING_STYLE_ANIMATIONS.filter((style) => next.includes(style));
-  if (selectedStyles.length <= 1) {
-    return next;
-  }
-  // Both styles selected — keep whichever was just added (absent from
-  // `previous`); fall back to the first declared style on ambiguity.
-  const justAdded = selectedStyles.find((style) => !previous.includes(style)) ?? selectedStyles[0];
-  return next.filter(
-    (animation) =>
-      animation === justAdded ||
-      !(LOADING_STYLE_ANIMATIONS as readonly AiAssistantAnimation[]).includes(animation),
-  );
-}

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

@@ -1,90 +0,0 @@
-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();
-}

package/src/utils/collect-session-models.test.ts

@@ -1,82 +0,0 @@
-import type { AIProviderRegistryStatusEntry, ChatMessage } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { collectSessionModels } from './collect-session-models';
-
-const assistantMsg = (overrides: Partial<ChatMessage> = {}): ChatMessage => ({
-  role: 'assistant',
-  content: '',
-  ...overrides,
-});
-
-const statusEntry = (
-  name: string,
-  model: string,
-  provider: AIProviderRegistryStatusEntry['status'] extends infer S
-    ? S extends { provider: infer P }
-      ? P
-      : never
-    : never,
-): AIProviderRegistryStatusEntry => ({
-  name,
-  isDefault: false,
-  status: { model, provider },
-});
-
-const suite = createLogicSuite('collectSessionModels');
-
-suite('collects unique models from assistant messages', () => {
-  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(models[0]?.model, 'claude-sonnet-4-6');
-  assert.is(models[0]?.provider, 'anthropic');
-  assert.is(models[2]?.model, 'gemini-2.5-pro');
-  assert.is(models[2]?.provider, 'gemini');
-});
-
-suite('resolves vendor from providerStatuses when messages lack provider', () => {
-  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(models[0]?.provider, 'gemini');
-});
-
-suite('does not persist registry tier names as provider', () => {
-  const models = collectSessionModels(
-    [assistantMsg({ model: 'gemini-3.1-flash-lite', providerName: 'low' })],
-    [],
-  );
-  assert.is(models[0]?.provider, undefined);
-  assert.is('providerName' in (models[0] ?? {}), false);
-});
-
-suite('includes models from sub-agent traces', () => {
-  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(models[0]?.model, 'claude-haiku-4-5-20251001');
-});
-
-suite.run();