@genesislcap/ai-assistant 15.19.0 → 15.19.1

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

@@ -1,218 +0,0 @@
-import type { AggregateUsage, AIProviderType } from '@genesislcap/foundation-ai';
-import { emptyUsage } from './sum-usage';
-
-/** A model used during a recorded cost session. */
-export interface CostSessionModelEntry {
-  model: string;
-  /** Vendor id from `getStatus()` (e.g. `'anthropic'`, `'gemini'`). */
-  provider?: AIProviderType;
-}
-
-/** Persisted usage record for one project's assistant work. */
-export interface CostSessionRecord {
-  id: string;
-  /**
-   * Stable identity of the work this row stands for — the assistant's session key
-   * (a project id, for hosts that key sessions per project). The upsert key: a row
-   * is one project's lifetime usage, so re-reporting the same key REPLACES the row
-   * rather than adding another.
-   */
-  projectKey: string;
-  title: string;
-  /**
-   * ISO-8601 timestamp of the most recent usage recorded for this row.
-   *
-   * Named for what it is: the row is upserted as spend accrues, so this moves. It is
-   * NOT an end time — a row has no terminal state, because a project can always be
-   * worked on again.
-   */
-  updatedAt: string;
-  /**
-   * Cost plus the four token buckets — the same shape the live session tile renders, so
-   * a history row can show the identical breakdown instead of a lone merged total that
-   * cannot explain a large token count at a small cost.
-   *
-   * This is the project's **lifetime** usage: `banked` plus whatever the live transcript
-   * currently proves.
-   */
-  usage: AggregateUsage;
-  /**
-   * Spend that predates the current transcript, and so cannot be re-derived from it.
-   *
-   * Without this a row could only ever report what the open transcript proves. That is
-   * fine when the transcript is restored on load (it *is* the project's history), but
-   * where it starts empty every refresh the row would be rewritten downwards on the next
-   * turn and the project's earlier spend lost. Banking it keeps `usage` a lifetime figure
-   * in both cases.
-   *
-   * Deliberately part of the row rather than element state: two assistant instances (a
-   * docked bubble and a popped-out panel) share one session, and both write this row. A
-   * value derived from the row keeps every write idempotent, whereas an element-held
-   * accumulator would be applied once per instance.
-   *
-   * Optional: rows written before this existed have none, which reads as "nothing banked".
-   */
-  banked?: AggregateUsage;
-  models: CostSessionModelEntry[];
-}
-
-const STORAGE_PREFIX = 'genesis-ai-assistant:cost-history:';
-
-/**
- * Every bucket must be a number before a row is trusted. Checked per field rather than
- * just testing for an object, because a partially-shaped `usage` would sum as `NaN` and
- * silently poison every total on the Usage tab.
- */
-function isAggregateUsage(value: unknown): value is AggregateUsage {
-  if (typeof value !== 'object' || value == null) return false;
-  const u = value as AggregateUsage;
-  return (
-    typeof u.costUsd === 'number' &&
-    typeof u.uncachedInputTokens === 'number' &&
-    typeof u.cacheReadTokens === 'number' &&
-    typeof u.cacheWriteTokens === 'number' &&
-    typeof u.outputTokens === 'number'
-  );
-}
-
-/** localStorage key for a host-scoped cost history list. */
-export function costHistoryStorageKey(scope: string): string {
-  return `${STORAGE_PREFIX}${scope}`;
-}
-
-/**
- * Load persisted cost sessions for a scope, in whatever order they were stored — this applies no
- * ordering of its own. Display order is the caller's business; see `sortRecordsByRecency`.
- */
-export function loadCostSessionHistory(scope: string): CostSessionRecord[] {
-  if (typeof localStorage === 'undefined') return [];
-  try {
-    const raw = localStorage.getItem(costHistoryStorageKey(scope));
-    if (!raw) return [];
-    const parsed: unknown = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(isCostSessionRecord);
-  } catch {
-    return [];
-  }
-}
-
-/** Replace the persisted list for a scope. */
-export function saveCostSessionHistory(scope: string, records: CostSessionRecord[]): void {
-  if (typeof localStorage === 'undefined') return;
-  try {
-    localStorage.setItem(costHistoryStorageKey(scope), JSON.stringify(records));
-  } catch {
-    // Quota exceeded or private browsing — non-fatal.
-  }
-}
-
-/**
- * Pure upsert — `records` with `record` replacing any row sharing its `projectKey`, or
- * prepended when there is none.
- *
- * An upsert, not an append, because a row stands for a **project's lifetime usage** rather
- * than a visit to it. Appending cut a fresh row per page-hide, so one project accumulated
- * a stack of near-identical rows and its spend was counted once per refresh by anything
- * summing the list.
- *
- * The resulting array order is incidental — it is insertion order, so a project returned to
- * stays where it first landed. Do not read it as recency; `sortRecordsByRecency` is what the
- * Usage tab renders through.
- *
- * Storage-agnostic on purpose: the same merge serves the synchronous `localStorage` path
- * and the async provider-backed one, so the two can never drift on what "upsert" means.
- * The caller owns persistence — see the assistant's `persistCostHistory`.
- */
-export function upsertRecord(
-  records: readonly CostSessionRecord[],
-  record: CostSessionRecord,
-): CostSessionRecord[] {
-  const at = records.findIndex((r) => r.projectKey === record.projectKey);
-  return at === -1 ? [record, ...records] : records.map((r, i) => (i === at ? record : r));
-}
-
-/**
- * Rows most-recently-worked-on first, as a new array.
- *
- * Applied at read time rather than baked into the stored order, so it covers rows that came from
- * a host provider as well as from `localStorage`, and so no write path has to maintain it.
- *
- * `updatedAt` is ISO-8601, which sorts lexicographically — no date parsing, and no dependence on
- * the strings being valid dates. Sorting by it rather than by insertion order is what makes the
- * list track use: the active project moves to the top on its first upsert and stays there, since
- * its row is rewritten on every transcript change.
- */
-export function sortRecordsByRecency(records: readonly CostSessionRecord[]): CostSessionRecord[] {
-  return [...records].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-}
-
-/**
- * The spend a project's next row must carry over from before its current transcript.
- *
- * `transcriptIsAuthoritative` means the open transcript already accounts for this project's
- * history — true exactly when a session snapshot is restored on load. The two branches are
- * not interchangeable, and picking the wrong one is silently destructive:
- *
- * - Authoritative: carry the previous row's own `banked` forward. Taking `usage` instead would
- *   re-add the restored history on every reload, the compounding double-count this replaced.
- * - Not authoritative: the whole previous total becomes banked, because nothing in the fresh
- *   transcript accounts for it. Taking `banked` instead would rewrite the row down to the
- *   current page-load and drop the project's earlier spend.
- *
- * Note both branches are idempotent — the result never includes the current transcript — which
- * is what lets two assistant instances sharing a session write the same row.
- */
-export function resolveBankedUsage(
-  existing: CostSessionRecord | undefined,
-  transcriptIsAuthoritative: boolean,
-): AggregateUsage {
-  if (!existing) return emptyUsage();
-  const carried = transcriptIsAuthoritative ? existing.banked : existing.usage;
-  return carried ?? emptyUsage();
-}
-
-/** Clear all persisted records for a scope. */
-export function clearCostSessionHistory(scope: string): void {
-  if (typeof localStorage === 'undefined') return;
-  try {
-    localStorage.removeItem(costHistoryStorageKey(scope));
-  } catch {
-    // Non-fatal.
-  }
-}
-
-/** Display date for a history row (e.g. "Jun 14, 2026"). */
-export function formatCostSessionDate(iso: string): string {
-  return new Intl.DateTimeFormat('en-US', {
-    month: 'short',
-    day: 'numeric',
-    year: 'numeric',
-  }).format(new Date(iso));
-}
-
-/**
- * Whether a value is a usable row. Exported because rows arrive by two routes and BOTH need it:
- * `loadCostSessionHistory` filters the `localStorage` path here, and the assistant filters what a
- * host provider returns. A row that skips this check is not merely ignored downstream — a
- * half-shaped `usage` sums to `NaN` through every total, and a missing `updatedAt` throws inside
- * the sort that orders the list, during render.
- */
-export function isCostSessionRecord(value: unknown): value is CostSessionRecord {
-  if (typeof value !== 'object' || value == null) return false;
-  const r = value as CostSessionRecord;
-  return (
-    typeof r.id === 'string' &&
-    // Rows written before the upsert model have no `projectKey` and cannot be keyed
-    // to a project, so they are discarded on load rather than silently pooled with
-    // the new per-project rows (where they would double-count that project).
-    typeof r.projectKey === 'string' &&
-    typeof r.title === 'string' &&
-    typeof r.updatedAt === 'string' &&
-    isAggregateUsage(r.usage) &&
-    // Absent is valid (nothing banked / pre-dates the field); present must be whole, since
-    // a half-shaped `banked` would poison the lifetime total exactly as a bad `usage` would.
-    (r.banked === undefined || isAggregateUsage(r.banked)) &&
-    Array.isArray(r.models)
-  );
-}

package/src/utils/derive-cost-session-title.test.ts

@@ -1,63 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import {
-  deriveCostSessionTitleFromMessages,
-  resolveCostSessionTitle,
-  truncateCostSessionTitle,
-} from './derive-cost-session-title';
-
-const suite = createLogicSuite('deriveCostSessionTitle');
-
-const userMsg = (content: string): ChatMessage => ({ role: 'user', content });
-
-suite('truncateCostSessionTitle keeps first sentence only', () => {
-  assert.is(
-    truncateCostSessionTitle('Build a trade blotter. With FX options and limits.'),
-    'Build a trade blotter',
-  );
-});
-
-suite('truncateCostSessionTitle caps word count', () => {
-  const long = 'one two three four five six seven eight nine ten eleven twelve thirteen fourteen';
-  assert.is(truncateCostSessionTitle(long), 'one two three four five six seven eight nine ten…');
-});
-
-suite('truncateCostSessionTitle caps character count on one long word', () => {
-  const word = 'a'.repeat(80);
-  assert.is(truncateCostSessionTitle(word).length, 60);
-  assert.ok(truncateCostSessionTitle(word).endsWith('…'));
-});
-
-suite('deriveCostSessionTitleFromMessages skips empty and uses first user turn', () => {
-  assert.is(
-    deriveCostSessionTitleFromMessages([
-      { role: 'assistant', content: 'Hi' },
-      { role: 'user', content: '   ' },
-      { role: 'user', content: 'Equity options pricer for desk' },
-    ]),
-    'Equity options pricer for desk',
-  );
-});
-
-suite('resolveCostSessionTitle prefers app title over messages', () => {
-  assert.is(
-    resolveCostSessionTitle({
-      appTitle: 'fx-trading',
-      messages: [userMsg('Something else entirely')],
-      headerTitle: 'Genesis Assistant',
-    }),
-    'fx-trading',
-  );
-});
-
-suite('resolveCostSessionTitle falls back to first user message', () => {
-  assert.is(
-    resolveCostSessionTitle({
-      messages: [userMsg('Search for recent trades in APAC')],
-      headerTitle: 'Genesis Assistant',
-    }),
-    'Search for recent trades in APAC',
-  );
-});
-
-suite.run();

package/src/utils/derive-cost-session-title.ts

@@ -1,76 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-
-/** Max words kept from the first user turn when deriving a session title. */
-export const COST_SESSION_TITLE_MAX_WORDS = 10;
-
-/** Hard cap on derived title length (ellipsis included). */
-export const COST_SESSION_TITLE_MAX_CHARS = 60;
-
-const ELLIPSIS = '…';
-
-/** Plain text from a chat message `content` field. */
-export function getChatMessageText(content: ChatMessage['content']): string {
-  return typeof content === 'string' ? content.trim() : '';
-}
-
-/**
- * Trim a raw user phrase to a display-friendly session title: first sentence,
- * then word cap, then character cap.
- */
-export function truncateCostSessionTitle(text: string): string {
-  const normalized = text.replace(/\s+/g, ' ').trim();
-  if (!normalized) return '';
-
-  const firstSentence = normalized.split(/\n|[.!?](?:\s|$)/u)[0]?.trim() || normalized;
-
-  const words = firstSentence.split(/\s+/).filter(Boolean);
-  let title = words.slice(0, COST_SESSION_TITLE_MAX_WORDS).join(' ');
-  if (words.length > COST_SESSION_TITLE_MAX_WORDS) {
-    title = `${title}${ELLIPSIS}`;
-  }
-
-  if (title.length > COST_SESSION_TITLE_MAX_CHARS) {
-    const sliceEnd = COST_SESSION_TITLE_MAX_CHARS - ELLIPSIS.length;
-    title = `${title.slice(0, Math.max(0, sliceEnd)).trimEnd()}${ELLIPSIS}`;
-  }
-
-  return title;
-}
-
-/** First non-empty user message in the thread, shortened for cost history. */
-export function deriveCostSessionTitleFromMessages(
-  messages: readonly ChatMessage[],
-): string | undefined {
-  for (const message of messages) {
-    if (message.role !== 'user') continue;
-    const title = truncateCostSessionTitle(message.content);
-    if (title) return title;
-  }
-  return undefined;
-}
-
-export interface ResolveCostSessionTitleInput {
-  explicit?: string;
-  /** Host-provided label (e.g. Create `projectName`). */
-  appTitle?: string;
-  messages: readonly ChatMessage[];
-  headerTitle?: string;
-  fallback?: string;
-}
-
-/** Resolve the label stored on a finalized cost session record. */
-export function resolveCostSessionTitle(input: ResolveCostSessionTitleInput): string {
-  const explicit = input.explicit?.trim();
-  if (explicit) return explicit;
-
-  const appTitle = input.appTitle?.trim();
-  if (appTitle) return appTitle;
-
-  const fromMessages = deriveCostSessionTitleFromMessages(input.messages);
-  if (fromMessages) return fromMessages;
-
-  const header = input.headerTitle?.trim();
-  if (header) return header;
-
-  return input.fallback?.trim() || 'Untitled session';
-}

package/src/utils/flatten-sub-agent-messages.test.ts

@@ -1,163 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { flattenSubAgentMessages } from './flatten-sub-agent-messages';
-
-const msg = (overrides: Partial<ChatMessage> = {}): ChatMessage => ({
-  role: 'assistant',
-  content: '',
-  ...overrides,
-});
-
-/** A parent assistant message whose single tool call delegated to a sub-agent. */
-const delegating = (id: string, agentName: string, trace: ChatMessage[]): ChatMessage =>
-  msg({
-    agentName,
-    toolCalls: [{ id, name: 'requestSubAgent', args: {}, subAgentTrace: trace }],
-  });
-
-const suite = createLogicSuite('flattenSubAgentMessages');
-
-suite('returns an empty array for an empty list', () => {
-  assert.equal(flattenSubAgentMessages([]), []);
-});
-
-suite('emits top-level messages unchanged and tags none as sub-agent', () => {
-  const out = flattenSubAgentMessages([
-    msg({ role: 'user', content: 'hi', agentName: 'UI Builder' }),
-    msg({ content: 'hello', agentName: 'UI Builder' }),
-  ]);
-  assert.is(out.length, 2);
-  assert.is(out[0].kind, 'message');
-  assert.is(out[0].agentName, 'UI Builder');
-  // No depth/marker fields on top-level entries.
-  assert.is(out[0].subAgentDepth, undefined);
-  assert.is(out[0].subAgentName, undefined);
-  assert.is(out[1].subAgentOf, undefined);
-});
-
-suite('hoists a sub-agent trace to top-level entries after the spawning message', () => {
-  const trace = [
-    msg({
-      agentName: 'UI Architecture Planner',
-      content: '',
-      toolCalls: [{ id: 'g', name: 'grep_source', args: {} }],
-    }),
-    msg({
-      role: 'tool',
-      agentName: 'UI Architecture Planner',
-      toolResult: { toolCallId: 'g', content: 'result' },
-    }),
-  ];
-  const out = flattenSubAgentMessages([
-    delegating('tc1', 'UI Builder', trace),
-    msg({
-      role: 'tool',
-      agentName: 'UI Builder',
-      toolResult: { toolCallId: 'tc1', content: 'plan done' },
-    }),
-  ]);
-
-  // parent tool-call msg, then 2 hoisted children, then the parent tool-result msg.
-  assert.is(out.length, 4);
-  assert.is(out[0].agentName, 'UI Builder'); // parent unchanged
-  assert.is(out[1].agentName, 'UI Builder › UI Architecture Planner');
-  assert.is(out[2].agentName, 'UI Builder › UI Architecture Planner');
-  assert.is(out[3].agentName, 'UI Builder'); // parent tool-result, back at top level
-});
-
-suite('marks hoisted entries with depth, raw name, and the spawning tool-call id', () => {
-  const out = flattenSubAgentMessages([
-    delegating('tc1', 'UI Builder', [msg({ agentName: 'UI Architecture Planner', content: 'x' })]),
-  ]);
-  const child = out[1];
-  assert.is(child.subAgentDepth, 1);
-  assert.is(child.subAgentName, 'UI Architecture Planner');
-  assert.is(child.subAgentOf, 'tc1');
-});
-
-suite(
-  'moves the trace out — the emitted parent tool call no longer carries it (no duplication)',
-  () => {
-    const trace = [msg({ agentName: 'Planner', content: 'only once' })];
-    const out = flattenSubAgentMessages([delegating('tc1', 'UI Builder', trace)]);
-    // The trace is stripped from the emitted tool call ...
-    assert.is(out[0].toolCalls![0].subAgentTrace, undefined);
-    // ... and surfaces exactly once, as a hoisted top-level entry.
-    const hoisted = out.filter((e) => e.subAgentDepth === 1);
-    assert.is(hoisted.length, 1);
-    assert.is(hoisted[0].content, 'only once');
-  },
-);
-
-suite('preserves per-message usage fields on hoisted entries', () => {
-  const out = flattenSubAgentMessages([
-    delegating('tc1', 'UI Builder', [
-      msg({
-        agentName: 'Planner',
-        model: 'claude-sonnet-4-6',
-        inputTokens: 100,
-        outputTokens: 20,
-        cost: 0.5,
-      }),
-    ]),
-  ]);
-  const child = out[1];
-  assert.is(child.model, 'claude-sonnet-4-6');
-  assert.is(child.inputTokens, 100);
-  assert.is(child.outputTokens, 20);
-  assert.is(child.cost, 0.5);
-});
-
-suite('composes the breadcrumb for nested sub-agents', () => {
-  const grandchild = [msg({ agentName: 'Grounding', content: 'deep' })];
-  const childTrace = [delegating('tc2', 'Planner', grandchild)];
-  const out = flattenSubAgentMessages([delegating('tc1', 'UI Builder', childTrace)]);
-
-  // top: UI Builder | depth1: Planner | depth2: Grounding
-  const depth1 = out.find((e) => e.subAgentDepth === 1)!;
-  const depth2 = out.find((e) => e.subAgentDepth === 2)!;
-  assert.is(depth1.agentName, 'UI Builder › Planner');
-  assert.is(depth2.agentName, 'UI Builder › Planner › Grounding');
-  assert.is(depth2.subAgentName, 'Grounding');
-  assert.is(depth2.subAgentOf, 'tc2');
-});
-
-suite('correlates two sub-agents spawned in the same parent turn', () => {
-  const parent = msg({
-    agentName: 'UI Builder',
-    toolCalls: [
-      {
-        id: 'a',
-        name: 'requestSubAgent',
-        args: {},
-        subAgentTrace: [msg({ agentName: 'Planner', content: 'p' })],
-      },
-      {
-        id: 'b',
-        name: 'requestSubAgent',
-        args: {},
-        subAgentTrace: [msg({ agentName: 'Reviewer', content: 'r' })],
-      },
-    ],
-  });
-  const out = flattenSubAgentMessages([parent]);
-  const planner = out.find((e) => e.subAgentName === 'Planner')!;
-  const reviewer = out.find((e) => e.subAgentName === 'Reviewer')!;
-  assert.is(planner.subAgentOf, 'a');
-  assert.is(reviewer.subAgentOf, 'b');
-  assert.is(planner.agentName, 'UI Builder › Planner');
-  assert.is(reviewer.agentName, 'UI Builder › Reviewer');
-});
-
-suite('falls back gracefully when the spawning message has no agentName', () => {
-  const out = flattenSubAgentMessages([
-    delegating('tc1', undefined as unknown as string, [
-      msg({ agentName: 'Planner', content: 'x' }),
-    ]),
-  ]);
-  // No parent name to prefix → show the sub-agent's own name unbreadcrumbed.
-  assert.is(out[1].agentName, 'Planner');
-  assert.is(out[1].subAgentName, 'Planner');
-});
-
-suite.run();

package/src/utils/flatten-sub-agent-messages.ts

@@ -1,88 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-
-/**
- * A chat message lifted into the debug-log timeline as a `kind: 'message'` entry.
- *
- * @beta
- */
-export type TimelineMessage = ChatMessage & {
-  kind: 'message';
-  /**
-   * Set only on entries hoisted out of a `subAgentTrace`: the sub-agent's own
-   * (un-breadcrumbed) `agentName`, kept for filtering since the displayed
-   * `agentName` is rewritten to a `"<parent> › <sub-agent>"` breadcrumb.
-   */
-  subAgentName?: string;
-  /** Delegation depth — absent/0 for top-level, 1 for a sub-agent, 2 for a sub-agent's sub-agent, … */
-  subAgentDepth?: number;
-  /** Id of the parent tool call that spawned this run — correlates a hoisted message back to its delegation. */
-  subAgentOf?: string;
-};
-
-/**
- * Flatten sub-agent conversations into a single top-level message stream for the
- * debug-log timeline.
- *
- * A tool call that delegates to a sub-agent carries the sub-agent's entire
- * conversation on `toolCall.subAgentTrace`. The live UI reads that nested shape,
- * but a top-to-bottom timeline reads far better with those messages inline next to
- * the turn that produced them. This walks the list and, for every tool call with a
- * `subAgentTrace`, hoists the sub-agent's messages up as their own timeline
- * entries while **removing** the nested copy from the emitted parent tool call — a
- * move, not a copy. The data is relocated, never duplicated: the export stays the
- * same size and a naive `sum(timeline[].cost)` does not double-count (the
- * canonical `sumCosts` total still reads the un-flattened history).
- *
- * Hoisted entries are:
- * - **breadcrumbed**: `agentName` becomes `"<parent> › <sub-agent>"`, composing for
- *   nested sub-agents (`"<parent> › <sub> › <subsub>"`); the raw sub-agent name is
- *   preserved on `subAgentName`.
- * - **depth-tagged** (`subAgentDepth`) and **correlated** to the spawning tool call
- *   (`subAgentOf`), so the delegation tree is reconstructable even when two
- *   sub-agents run within the same parent turn.
- *
- * Top-level messages (depth 0) are emitted unchanged apart from the trace strip.
- * Order is preserved within each list; the caller sorts the whole timeline by
- * timestamp afterwards, and every sub-agent message carries its own timestamp, so
- * hoisted entries interleave chronologically between the parent's tool-call and
- * tool-result messages.
- *
- * @internal
- */
-export function flattenSubAgentMessages(
-  messages: readonly ChatMessage[],
-  prefix = '',
-  depth = 0,
-  subAgentOf?: string,
-): TimelineMessage[] {
-  return messages.flatMap((m) => {
-    const breadcrumb = prefix ? `${prefix} › ${m.agentName ?? '?'}` : m.agentName;
-    const traceCalls = m.toolCalls?.filter((tc) => tc.subAgentTrace?.length) ?? [];
-
-    const entry: TimelineMessage = {
-      kind: 'message',
-      ...m,
-      // Move the (about-to-be-hoisted) child conversations out of the emitted tool
-      // calls. Setting it to `undefined` drops the key from the serialized export.
-      ...(traceCalls.length > 0 && {
-        toolCalls: m.toolCalls!.map((tc) =>
-          tc.subAgentTrace ? { ...tc, subAgentTrace: undefined } : tc,
-        ),
-      }),
-      // Mark + breadcrumb hoisted sub-agent messages; top-level (depth 0) stays as-is.
-      ...(depth > 0 && {
-        agentName: breadcrumb,
-        subAgentName: m.agentName,
-        subAgentDepth: depth,
-        subAgentOf,
-      }),
-    };
-
-    if (traceCalls.length === 0) return [entry];
-
-    const hoisted = traceCalls.flatMap((tc) =>
-      flattenSubAgentMessages(tc.subAgentTrace!, breadcrumb ?? '', depth + 1, tc.id),
-    );
-    return [entry, ...hoisted];
-  });
-}

package/src/utils/format-usd.ts

@@ -1,26 +0,0 @@
-/**
- * The ONE place this package renders a USD amount as text.
- *
- * Extracted (GENC-1464 budget meter) from the ad-hoc `.toFixed(2)` call sites
- * that had grown in `formatBlockedReason` and the settings modal's cost blocks,
- * so the blocked banner, the session-cost figures and the budget meter cannot
- * drift to different precisions. Two decimals always — money columns jitter
- * when "$5.1" sits above "$5.10".
- *
- * @internal
- */
-
-/** Decimal places for every USD figure this package renders. */
-export const USD_DECIMALS = 2;
-
-/**
- * The bare amount, no currency sign — `(12.3) => "12.30"`.
- *
- * Exists for the settings modal's cost blocks, where the `$` is a separately
- * styled `<span class="prefix">` and folding it into the text would change the
- * DOM those styles target.
- */
-export const formatUsdAmount = (value: number): string => value.toFixed(USD_DECIMALS);
-
-/** A signed USD figure — `(12.3) => "$12.30"`. */
-export const formatUsd = (value: number): string => `$${formatUsdAmount(value)}`;