@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/src/utils/history-transform.test.ts

@@ -1,228 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import {
-  buildCompactionSummaryPrompt,
-  compactionDividerLabel,
-  COMPACT_KEEP_RECENT_MESSAGES,
-  COMPACT_MIN_MESSAGES_TO_COMPACT,
-  findCompactionCut,
-  normalizeForProvider,
-  transformHistoryForAgent,
-} from './history-transform';
-
-const asMsg = (o: Record<string, unknown>): ChatMessage => o as unknown as ChatMessage;
-const user = (content: string) => asMsg({ role: 'user', content });
-const assistant = (content: string) => asMsg({ role: 'assistant', content });
-
-// GENC-1351 §5.7 — the pure compaction helpers (no DOM/provider deps).
-const Suite = createLogicSuite('history-transform-compaction');
-
-// ── findCompactionCut ─────────────────────────────────────────────────────────
-
-Suite('findCompactionCut returns null for a transcript too short to be worth compacting', () => {
-  assert.is(findCompactionCut([]), null);
-  // One below the floor (keep-recent + min-to-compact) → nothing to do.
-  const justUnder = Array.from(
-    { length: COMPACT_KEEP_RECENT_MESSAGES + COMPACT_MIN_MESSAGES_TO_COMPACT - 1 },
-    (_, i) => (i % 2 === 0 ? user(`u${i}`) : assistant(`a${i}`)),
-  );
-  assert.is(findCompactionCut(justUnder), null);
-});
-
-Suite('findCompactionCut cuts at a user-message boundary, keeping the recent tail', () => {
-  // 10 messages alternating user/assistant; user at even indices.
-  const h = Array.from({ length: 10 }, (_, i) =>
-    i % 2 === 0 ? user(`u${i}`) : assistant(`a${i}`),
-  );
-  const cut = findCompactionCut(h);
-  // target = 10 - 4 = 6; history[6] is a user message → cut there.
-  assert.is(cut, 6);
-  assert.is(h[cut!].role, 'user', 'tail must start on a user boundary');
-});
-
-Suite('findCompactionCut walks back to the nearest earlier user boundary', () => {
-  // user only at indices 0,1,3,5,7,9 — index 6 is assistant, so it walks back to 5.
-  const h = [
-    user('u0'),
-    user('u1'),
-    assistant('a2'),
-    user('u3'),
-    assistant('a4'),
-    user('u5'),
-    assistant('a6'),
-    user('u7'),
-    assistant('a8'),
-    user('u9'),
-  ];
-  // target = 6 (assistant) → walk back to 5 (user).
-  assert.is(findCompactionCut(h), 5);
-});
-
-Suite('findCompactionCut returns null when the only user turn is the first message', () => {
-  // No user boundary after index 0 → nothing can be summarized behind a boundary.
-  const h = [user('u0'), ...Array.from({ length: 9 }, (_, i) => assistant(`a${i}`))];
-  assert.is(findCompactionCut(h), null);
-});
-
-Suite(
-  'findCompactionCut includes an existing head summary in the region to compact (rolling)',
-  () => {
-    const h = [
-      asMsg({ role: 'compacted-summary', content: 'prior', compaction: { compactedCount: 3 } }),
-      user('u1'),
-      assistant('a2'),
-      user('u3'),
-      assistant('a4'),
-      user('u5'),
-      assistant('a6'),
-      user('u7'),
-      assistant('a8'),
-      user('u9'),
-    ];
-    const cut = findCompactionCut(h);
-    assert.ok(
-      cut != null && cut >= 1,
-      'cut should leave the head summary inside the compacted region',
-    );
-    assert.is(h.slice(0, cut!)[0].role, 'compacted-summary', 'prior summary is folded back in');
-  },
-);
-
-// ── buildCompactionSummaryPrompt ──────────────────────────────────────────────
-
-Suite('buildCompactionSummaryPrompt wraps the transcript and labels roles', () => {
-  const { systemPrompt, userMessage } = buildCompactionSummaryPrompt([
-    user('book a trade'),
-    assistant('sure, which counterparty?'),
-  ]);
-  assert.ok(/summar/i.test(systemPrompt), 'system prompt frames a summarization task');
-  assert.ok(userMessage.includes('<conversation_history>'));
-  assert.ok(userMessage.includes('</conversation_history>'));
-  assert.ok(userMessage.includes('User: book a trade'));
-  assert.ok(userMessage.includes('Assistant: sure, which counterparty?'));
-});
-
-Suite('buildCompactionSummaryPrompt renders tool activity and a prior summary', () => {
-  const { userMessage } = buildCompactionSummaryPrompt([
-    asMsg({
-      role: 'compacted-summary',
-      content: 'earlier stuff',
-      compaction: { compactedCount: 2 },
-    }),
-    asMsg({
-      role: 'assistant',
-      content: '',
-      toolCalls: [{ id: 't1', name: 'searchTrades', args: {} }],
-    }),
-    asMsg({ role: 'tool', content: '', toolResult: { toolCallId: 't1', content: '3 hits' } }),
-  ]);
-  assert.ok(userMessage.includes('[Earlier summary] earlier stuff'));
-  assert.ok(userMessage.includes('searchTrades'), 'tool call name is preserved for continuity');
-  assert.ok(userMessage.includes('Tool result: 3 hits'));
-});
-
-Suite(
-  'buildCompactionSummaryPrompt folds in reasoning + narration, labelled Thinking / Working',
-  () => {
-    const { userMessage } = buildCompactionSummaryPrompt([
-      asMsg({
-        role: 'assistant',
-        content: 'weigh the counterparty options',
-        category: 'reasoning',
-      }),
-      asMsg({ role: 'assistant', content: 'searching the trade blotter', category: 'narration' }),
-    ]);
-    assert.ok(userMessage.includes('Thinking: weigh the counterparty options'));
-    assert.ok(userMessage.includes('Working: searching the trade blotter'));
-  },
-);
-
-// ── normalizeForProvider (the no-leak guarantee) ──────────────────────────────
-
-Suite(
-  'normalizeForProvider translates compacted-summary into a <conversation_summary> user msg',
-  () => {
-    const out = normalizeForProvider([
-      asMsg({ role: 'compacted-summary', content: 'the gist', compaction: { compactedCount: 9 } }),
-      user('and now?'),
-    ]);
-    assert.is(out[0].role, 'user', 'the raw display-only role is gone');
-    assert.ok(out[0].content.includes('<conversation_summary>'));
-    assert.ok(out[0].content.includes('the gist'));
-    assert.is(out[0].compaction, undefined, 'compaction metadata is dropped from the sent message');
-  },
-);
-
-Suite('normalizeForProvider never emits a compacted-summary role (no leak to a transport)', () => {
-  const out = normalizeForProvider([
-    asMsg({ role: 'compacted-summary', content: 's1', compaction: { compactedCount: 1 } }),
-    user('u'),
-    assistant('a'),
-    asMsg({ role: 'system-event', content: 'Switched agent' }),
-  ]);
-  assert.ok(
-    out.every((m) => m.role !== 'compacted-summary'),
-    'no compacted-summary role survives normalization',
-  );
-});
-
-Suite('normalizeForProvider passes non-summary messages through untouched (same ref)', () => {
-  const u = user('hello');
-  const a = assistant('hi');
-  const out = normalizeForProvider([u, a]);
-  assert.is(out[0], u);
-  assert.is(out[1], a);
-});
-
-// ── compactionDividerLabel ────────────────────────────────────────────────────
-
-Suite('compactionDividerLabel pluralizes and falls back to 0', () => {
-  assert.is(
-    compactionDividerLabel(
-      asMsg({ role: 'compacted-summary', content: '', compaction: { compactedCount: 1 } }),
-    ),
-    'Compacted 1 earlier message',
-  );
-  assert.is(
-    compactionDividerLabel(
-      asMsg({ role: 'compacted-summary', content: '', compaction: { compactedCount: 12 } }),
-    ),
-    'Compacted 12 earlier messages',
-  );
-  assert.is(
-    compactionDividerLabel(asMsg({ role: 'compacted-summary', content: '' })),
-    'Compacted 0 earlier messages',
-  );
-});
-
-// ── masking another agent's tool payload (GENC-1508) ─────────────────────────
-
-Suite('transformHistoryForAgent drops tool-result IMAGES, not just the text', () => {
-  const history: ChatMessage[] = [
-    asMsg({
-      role: 'tool',
-      content: '',
-      agentName: 'other-agent',
-      toolResult: {
-        toolCallId: 'r1',
-        content: 'rendered the mockup',
-        attachments: [
-          { kind: 'image', name: 'mockup.png', mimeType: 'image/png', data: 'a'.repeat(2000) },
-        ],
-      },
-    }),
-  ];
-  const out = transformHistoryForAgent(history, 'this-agent');
-  assert.ok(
-    out[0].toolResult!.content.includes('omitted'),
-    'the text is stubbed, as it always was',
-  );
-  assert.is(
-    out[0].toolResult!.attachments,
-    undefined,
-    "masking exists to keep another agent's payload out of context — an image IS the payload, " +
-      'and stubbing the prose while shipping the render defeats the mask where it matters most',
-  );
-});
-
-Suite.run();

package/src/utils/history-transform.ts

@@ -1,163 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-
-/**
- * Masks the tool-specific payload of a single message — clears tool call args
- * and replaces tool result content with a placeholder. Used when passing history
- * to an agent that should not see another agent's implementation detail.
- */
-function maskToolPayload(msg: ChatMessage): ChatMessage {
-  if (msg.toolCalls?.length) {
-    return { ...msg, toolCalls: msg.toolCalls.map((tc) => ({ ...tc, args: {} })) };
-  }
-  if (msg.toolResult) {
-    // `attachments` is dropped, not spread through. Masking exists to keep another agent's
-    // payload out of this one's context, and an image is the largest payload there is — spreading
-    // it would stub the prose while still shipping the render, defeating the mask for exactly the
-    // case it matters most. `applyHistoryCap` masks everything past the cap for sub-agent context,
-    // so without this every older image rides every sub-agent turn under an "omitted" label.
-    const { attachments: _masked, ...restOfResult } = msg.toolResult;
-    return {
-      ...msg,
-      toolResult: { ...restOfResult, content: "[other agent's tool result omitted]" },
-    };
-  }
-  return msg;
-}
-
-/**
- * Prepares history for the LLM only: masks tool call args and results from other
- * agents so the active specialist is not confused by tools it does not have.
- * Canonical history in `ChatDriver` stays unmasked for UI and logging.
- */
-export function transformHistoryForAgent(history: ChatMessage[], agentName: string): ChatMessage[] {
-  return history.map((msg) => {
-    if (!msg.agentName || msg.agentName === agentName) return msg;
-    return maskToolPayload(msg);
-  });
-}
-
-/**
- * Applies a history cap for sub-agent context: the last `cap` messages are passed
- * verbatim; older messages have their tool payloads masked.
- */
-export function applyHistoryCap(history: readonly ChatMessage[], cap: number): ChatMessage[] {
-  const cutoff = history.length - cap;
-  return history.map((msg, i) => (i < cutoff ? maskToolPayload(msg) : msg));
-}
-
-// ───────────────────────────── Compaction (GENC-1351 §5.7) ─────────────────────────────
-
-/** Recent messages kept verbatim when compacting; everything earlier is summarized. */
-export const COMPACT_KEEP_RECENT_MESSAGES = 4;
-
-/** Don't bother compacting unless at least this many messages would be summarized. */
-export const COMPACT_MIN_MESSAGES_TO_COMPACT = 4;
-
-/**
- * Index at which the verbatim tail begins — everything before it gets summarized.
- * The tail starts on a clean turn boundary (a `user` message): a user message
- * never appears between a `tool_use` and its `tool_result`, so cutting there
- * guarantees the summarized region is tool-pair-balanced (compaction only runs
- * when idle, so history is turn-complete). Returns `null` when there is nothing
- * worth compacting (too short, or no earlier user boundary) — e.g. a freshly
- * restored session whose only user turn is the current one.
- */
-export function findCompactionCut(history: readonly ChatMessage[]): number | null {
-  if (history.length < COMPACT_KEEP_RECENT_MESSAGES + COMPACT_MIN_MESSAGES_TO_COMPACT) {
-    return null;
-  }
-  const target = history.length - COMPACT_KEEP_RECENT_MESSAGES;
-  for (let i = target; i > 0; i -= 1) {
-    if (history[i].role === 'user') {
-      return i >= COMPACT_MIN_MESSAGES_TO_COMPACT ? i : null;
-    }
-  }
-  return null;
-}
-
-/** One-line rendering of a message for the summarizer transcript. */
-function renderMessageForSummary(m: ChatMessage): string {
-  switch (m.role) {
-    case 'compacted-summary':
-      return `[Earlier summary] ${m.content}`;
-    case 'user':
-      return m.content ? `User: ${m.content}` : '';
-    case 'assistant': {
-      // Reasoning ("Thinking") and narration ("Working") are display-only assistant splits
-      // (GENC-1410) with no tool calls of their own — fold them into the summary too, labelled
-      // the same as the UI so the summarizer knows they were internal, not a final answer.
-      if (m.category === 'reasoning') {
-        return m.content ? `Thinking: ${m.content}` : '';
-      }
-      if (m.category === 'narration') {
-        return m.content ? `Working: ${m.content}` : '';
-      }
-      if (m.toolCalls?.length) {
-        const calls = m.toolCalls.map((t) => t.name).join(', ');
-        return m.content
-          ? `Assistant: ${m.content} (called: ${calls})`
-          : `Assistant called: ${calls}`;
-      }
-      return m.content ? `Assistant: ${m.content}` : '';
-    }
-    case 'tool':
-      return m.toolResult ? `Tool result: ${m.toolResult.content}` : '';
-    default:
-      return ''; // system-event / synthetic-user — not part of the model transcript
-  }
-}
-
-/**
- * Build the one-shot summarizer prompt for a run of older messages (used with
- * `AIProvider.prompt`). Mirrors the `<conversation_history>` block convention
- * that suggestions use. Any existing `compacted-summary` at the head is folded
- * in (rendered as prior-summary context), so rolling re-compaction produces one
- * combined summary.
- */
-export function buildCompactionSummaryPrompt(toCompact: readonly ChatMessage[]): {
-  systemPrompt: string;
-  userMessage: string;
-} {
-  const transcript = toCompact.map(renderMessageForSummary).filter(Boolean).join('\n');
-  const systemPrompt =
-    'You compress a conversation transcript into a concise summary that lets an AI ' +
-    'assistant continue the conversation seamlessly. Preserve key facts, decisions, ' +
-    'what the user wants, entity names and IDs, and any unresolved threads. Write ' +
-    'plain prose. Never roleplay or continue the conversation.';
-  const userMessage =
-    `<conversation_history>\n${transcript}\n</conversation_history>\n\n` +
-    'Summarize the conversation above so it can be dropped from context while ' +
-    'preserving everything needed to continue. Output only the summary prose.';
-  return { systemPrompt, userMessage };
-}
-
-/**
- * Normalize history for a provider request (GENC-1351 §5.7): translate each
- * `compacted-summary` message into a `user` message that wraps its summary in a
- * `<conversation_summary>` block, so the raw display-only role never reaches a
- * transport. Other roles pass through untouched. Pure — returns a new array.
- *
- * Applied at the request-build chokepoint *before* per-agent masking, so the
- * guarantee holds for every provider/transport regardless of any optional
- * per-agent history transform.
- */
-export function normalizeForProvider(history: readonly ChatMessage[]): ChatMessage[] {
-  return history.map((m) => {
-    if (m.role !== 'compacted-summary') return m;
-    return {
-      ...m,
-      role: 'user',
-      content:
-        `<conversation_summary>\n${m.content}\n</conversation_summary>\n\n` +
-        'The above summarizes earlier parts of this conversation that were compacted. ' +
-        'Continue naturally from it.',
-      compaction: undefined,
-    };
-  });
-}
-
-/** Human-facing divider label for a `compacted-summary` message. */
-export function compactionDividerLabel(m: ChatMessage): string {
-  const n = m.compaction?.compactedCount ?? 0;
-  return `Compacted ${n} earlier message${n === 1 ? '' : 's'}`;
-}

package/src/utils/index.ts

@@ -1,3 +0,0 @@
-export * from './animated-panel-toggle';
-export * from './logger';
-export * from './tool-fold';

package/src/utils/logger.ts

@@ -1,3 +0,0 @@
-import { createLogger } from '@genesislcap/foundation-logger';
-
-export const logger = createLogger('ai-assistant');

package/src/utils/message-partition.test.ts

@@ -1,129 +0,0 @@
-import type { ChatInteraction, ChatMessage } from '@genesislcap/foundation-ai';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import {
-  filterVisibleMessages,
-  type MessageFilterState,
-  SESSION_RESTORED_LABEL,
-  SESSION_RESTORE_FAILED_LABEL,
-  trailingInteractionRow,
-} from './message-partition';
-
-const msg = (overrides: Partial<ChatMessage> = {}): ChatMessage => ({
-  role: 'assistant',
-  content: '',
-  ...overrides,
-});
-
-const interaction = (interactionId: string, resolved = false): ChatInteraction => ({
-  interactionId,
-  componentName: 'test-widget',
-  data: {},
-  ...(resolved ? { resolved: { status: 'approved' } } : {}),
-});
-
-const ALL_ON: MessageFilterState = {
-  showToolCalls: true,
-  showThinkingSteps: true,
-  showNarration: true,
-  showAgentSwitchIndicator: true,
-  showRestoreNotices: true,
-};
-const ALL_OFF: MessageFilterState = {
-  showToolCalls: false,
-  showThinkingSteps: false,
-  showNarration: false,
-  showAgentSwitchIndicator: false,
-  showRestoreNotices: false,
-};
-
-const trailing = createLogicSuite('trailingInteractionRow');
-
-trailing('is empty when there are no messages', () => {
-  assert.equal(trailingInteractionRow([]), []);
-});
-
-trailing('is empty when the last message has no interaction', () => {
-  assert.equal(trailingInteractionRow([msg({ content: 'hi' })]), []);
-});
-
-trailing('returns the last message when it carries an interaction (pending)', () => {
-  const pending = msg({ interaction: interaction('id-a') });
-  assert.equal(trailingInteractionRow([msg({ content: 'q' }), pending]), [pending]);
-});
-
-trailing('still returns the trailing interaction once it is resolved', () => {
-  // Keeps it in the pinned slot so resolving forwards in place without a rebuild.
-  const resolved = msg({ interaction: interaction('id-a', true) });
-  assert.equal(trailingInteractionRow([resolved]), [resolved]);
-});
-
-trailing('returns nothing once a newer non-interaction message arrives', () => {
-  // The interaction is no longer last, so it rejoins the scrolling list.
-  const earlier = msg({ interaction: interaction('id-a', true) });
-  assert.equal(trailingInteractionRow([earlier, msg({ content: 'next' })]), []);
-});
-
-trailing('returns the same message reference (lets FAST short-circuit rebind)', () => {
-  const pending = msg({ interaction: interaction('id-a') });
-  assert.is(trailingInteractionRow([pending])[0], pending);
-});
-
-const filter = createLogicSuite('filterVisibleMessages');
-
-filter('hides tool result messages regardless of toggles', () => {
-  const msgs = [msg({ role: 'tool', toolResult: { toolCallId: 't1', content: 'r' } })];
-  assert.equal(filterVisibleMessages(msgs, ALL_ON), []);
-});
-
-filter('hides tool-call messages when showToolCalls is off, shows them when on', () => {
-  const toolCall = msg({ toolCalls: [{ id: 't1', name: 'do', args: {} } as any] });
-  assert.equal(filterVisibleMessages([toolCall], ALL_OFF), []);
-  assert.equal(filterVisibleMessages([toolCall], ALL_ON), [toolCall]);
-});
-
-filter('hides thinking messages when showThinkingSteps is off', () => {
-  const thinking = msg({ thinking: true, content: 'hmm' });
-  assert.equal(filterVisibleMessages([thinking], ALL_OFF), []);
-  assert.equal(filterVisibleMessages([thinking], ALL_ON), [thinking]);
-});
-
-filter('hides system-event rows unless the agent-switch toggle is on', () => {
-  const event = msg({ role: 'system-event', content: 'switched' });
-  assert.equal(filterVisibleMessages([event], ALL_OFF), []);
-  assert.equal(filterVisibleMessages([event], ALL_ON), [event]);
-});
-
-filter('drops empty assistant messages', () => {
-  assert.equal(filterVisibleMessages([msg({ content: '   ' })], ALL_ON), []);
-});
-
-filter('keeps user and non-empty assistant messages with everything off', () => {
-  const user = msg({ role: 'user', content: 'hello' });
-  const reply = msg({ content: 'hi there' });
-  assert.equal(filterVisibleMessages([user, reply], ALL_OFF), [user, reply]);
-});
-
-// GENC-1351 §6: restore notices are gated by their own (persistence) toggle, NOT
-// by showAgentSwitchIndicator — the two unrelated switches must not cross-control.
-filter(
-  'restore notices follow showRestoreNotices; agent-switch rows follow showAgentSwitchIndicator',
-  () => {
-    const restored = msg({ role: 'system-event', content: SESSION_RESTORED_LABEL });
-    const failed = msg({ role: 'system-event', content: SESSION_RESTORE_FAILED_LABEL });
-    const agentSwitch = msg({ role: 'system-event', content: 'Guided Booking' });
-    const rows = [restored, failed, agentSwitch];
-
-    // Persistence on, agent-switch off → only the restore notices show.
-    assert.equal(filterVisibleMessages(rows, { ...ALL_OFF, showRestoreNotices: true }), [
-      restored,
-      failed,
-    ]);
-    // Agent-switch on, persistence off → only the agent-switch indicator shows.
-    assert.equal(filterVisibleMessages(rows, { ...ALL_OFF, showAgentSwitchIndicator: true }), [
-      agentSwitch,
-    ]);
-  },
-);
-
-trailing.run();
-filter.run();

package/src/utils/message-partition.ts

@@ -1,115 +0,0 @@
-import type { ChatMessage } from '@genesislcap/foundation-ai';
-
-/**
- * Display-only session-restore notices (GENC-1351 §6): the "Restored…" divider on
- * a successful reload restore, and the "Couldn't restore…" divider when a saved
- * session existed but couldn't be brought back (timeout / error / unusable
- * snapshot). Both are `system-event` rows, stripped from the persisted snapshot so
- * they never become permanent history — and, unlike agent-switch indicators, they
- * belong to the persistence ("remember chat") feature, so `filterVisibleMessages`
- * gates them by `showRestoreNotices` rather than `showAgentSwitchIndicator`.
- *
- * @internal
- */
-export const SESSION_RESTORED_LABEL = 'Restored previous conversation';
-/** @internal */
-export const SESSION_RESTORE_FAILED_LABEL = "Couldn't restore the previous conversation";
-/** @internal */
-export const isSessionRestoredMarker = (m: ChatMessage): boolean =>
-  m.role === 'system-event' && m.content === SESSION_RESTORED_LABEL;
-/** @internal */
-export const isSessionRestoreFailedMarker = (m: ChatMessage): boolean =>
-  m.role === 'system-event' && m.content === SESSION_RESTORE_FAILED_LABEL;
-/** Either restore notice — both display-only, stripped before persist. @internal */
-export const isSessionNoticeMarker = (m: ChatMessage): boolean =>
-  isSessionRestoredMarker(m) || isSessionRestoreFailedMarker(m);
-
-/**
- * Toggle state that drives which messages appear in the scrolling list. Mirrors
- * the cog-menu switches; `showAgentSwitchIndicator` is pre-resolved by the
- * caller (it falls back to `showToolCalls` when the host hasn't configured an
- * explicit agent-switch toggle).
- */
-export interface MessageFilterState {
-  showToolCalls: boolean;
-  showThinkingSteps: boolean;
-  showNarration: boolean;
-  showAgentSwitchIndicator: boolean;
-  /**
-   * Whether session-restore notices show — driven by the persistence ("remember
-   * chat") toggle, since restore is that feature's concern (GENC-1351 §6). Kept
-   * separate from `showAgentSwitchIndicator` so those two unrelated switches don't
-   * cross-control each other.
-   */
-  showRestoreNotices: boolean;
-}
-
-/**
- * The trailing interaction to render in a pinned slot, separate from the
- * filtered list. Empty unless the most recent message carries an interaction.
- *
- * Pinning the trailing interaction keeps its widget out of the list's
- * reconciliation: FAST's `repeat` has no key function and reconciles by array
- * index, so re-filtering the list (a cog-menu toggle) would otherwise rebind an
- * existing row to a different message and re-create the live widget — discarding
- * any in-progress input. The slot's binding reads only `messages` and returns
- * the same message object across toggles, so the widget's DOM is preserved.
- *
- * It is the *trailing* message (resolved or not), not "unresolved only", so that
- * answering an interaction leaves it in the slot — `resolved` is forwarded in
- * place with no re-render. It rejoins the list naturally once a newer message
- * arrives and it is no longer last.
- */
-export function trailingInteractionRow(messages: ChatMessage[]): ChatMessage[] {
-  const last = messages[messages.length - 1];
-  return last?.interaction ? [last] : [];
-}
-
-/**
- * Filters messages for the scrolling list per the current cog-menu toggles.
- *
- * The trailing interaction (see `trailingInteractionRow`) must be removed
- * before calling, as it is rendered separately.
- */
-export function filterVisibleMessages(
-  messages: ChatMessage[],
-  toggles: MessageFilterState,
-): ChatMessage[] {
-  return messages.filter((m) => {
-    // Compaction dividers are always shown — a real conversation landmark, not
-    // optional UI noise (GENC-1351 §5.7).
-    if (m.role === 'compacted-summary') {
-      return true;
-    }
-    if (m.role === 'system-event') {
-      // Restore notices belong to persistence ("remember chat"), agent-switch
-      // indicators to their own toggle — gate each by its own switch.
-      return isSessionNoticeMarker(m)
-        ? toggles.showRestoreNotices
-        : toggles.showAgentSwitchIndicator;
-    }
-    // Tool result messages are never shown to the user.
-    if (m.role === 'tool') {
-      return false;
-    }
-    // Reasoning (chain-of-thought summary) follows the thinking toggle.
-    if (m.category === 'reasoning') {
-      return toggles.showThinkingSteps;
-    }
-    // Narration (interstitial prose alongside a tool call) follows its own toggle.
-    if (m.category === 'narration') {
-      return toggles.showNarration;
-    }
-    // Legacy: sessions persisted before the reasoning/narration split tagged reasoning-ish
-    // content with `thinking`; keep honouring the flag so their history still hides it.
-    if (m.thinking && !toggles.showThinkingSteps) {
-      return false;
-    }
-    // Drop empty assistant messages that slipped through.
-    if (m.role === 'assistant' && !m.content?.trim() && !m.toolCalls?.length && !m.interaction) {
-      return false;
-    }
-    const isToolRelated = !!(m.toolCalls?.length || m.toolResult);
-    return !isToolRelated || toggles.showToolCalls;
-  });
-}

package/src/utils/resolve-cost-history-config.test.ts

@@ -1,38 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { resolveCostHistoryConfig } from './resolve-cost-history-config';
-
-const Suite = createLogicSuite('resolveCostHistoryConfig');
-
-Suite('defaults to disabled with cost UI visible', () => {
-  const resolved = resolveCostHistoryConfig({});
-  assert.is(resolved.enabled, false);
-  assert.is(resolved.showCost, true);
-  assert.is(resolved.showTokens, true);
-  assert.is(resolved.badgeLabel, 'Currently building');
-});
-
-Suite('enables persistence only when costHistory.enabled is true', () => {
-  assert.is(resolveCostHistoryConfig({ costHistory: {} }).enabled, false);
-  assert.is(resolveCostHistoryConfig({ costHistory: { enabled: true } }).enabled, true);
-});
-
-Suite('reads costHistory fields', () => {
-  const resolved = resolveCostHistoryConfig({
-    costHistory: {
-      enabled: true,
-      title: 'My project',
-      scope: 'app-scope',
-      showCost: false,
-      showTokens: false,
-      badgeLabel: 'Building',
-    },
-  });
-
-  assert.is(resolved.title, 'My project');
-  assert.is(resolved.scope, 'app-scope');
-  assert.is(resolved.showCost, false);
-  assert.is(resolved.showTokens, false);
-  assert.is(resolved.badgeLabel, 'Building');
-});
-
-Suite.run();