@robota-sdk/agent-ui-terminal 3.0.0-beta.81

package/src/__tests__/TextPrompt.test.tsx

@@ -0,0 +1,112 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import TextPrompt from '../TextPrompt.js';
+import { formatKeyHints } from '../key-hint-footer.js';
+
+describe('TextPrompt', () => {
+  it('renders title', () => {
+    const { lastFrame } = render(
+      <TextPrompt title="Enter URL" onSubmit={() => {}} onCancel={() => {}} />,
+    );
+    expect(lastFrame()!).toContain('Enter URL');
+  });
+
+  it('renders placeholder when provided', () => {
+    const { lastFrame } = render(
+      <TextPrompt title="Enter" placeholder="owner/repo" onSubmit={() => {}} onCancel={() => {}} />,
+    );
+    expect(lastFrame()!).toContain('owner/repo');
+  });
+
+  it('calls onCancel on Escape', async () => {
+    let cancelled = false;
+    const { stdin } = render(
+      <TextPrompt
+        title="Enter"
+        onSubmit={() => {}}
+        onCancel={() => {
+          cancelled = true;
+        }}
+      />,
+    );
+    stdin.write('\x1B');
+    await new Promise((r) => setTimeout(r, 50));
+    expect(cancelled).toBe(true);
+  });
+
+  it('calls onSubmit with value on Enter', () => {
+    let submitted = '';
+    const { stdin } = render(
+      <TextPrompt
+        title="Enter"
+        onSubmit={(v) => {
+          submitted = v;
+        }}
+        onCancel={() => {}}
+      />,
+    );
+    stdin.write('hello');
+    stdin.write('\r');
+    expect(submitted).toBe('hello');
+  });
+
+  it('can submit an empty value when allowed', () => {
+    let submitted = 'not-called';
+    const { stdin } = render(
+      <TextPrompt
+        title="Enter"
+        allowEmpty
+        onSubmit={(v) => {
+          submitted = v;
+        }}
+        onCancel={() => {}}
+      />,
+    );
+    stdin.write('\r');
+    expect(submitted).toBe('');
+  });
+
+  it('masks typed values when requested', async () => {
+    const { stdin, lastFrame } = render(
+      <TextPrompt title="Secret" masked onSubmit={() => {}} onCancel={() => {}} />,
+    );
+    stdin.write('abc');
+    await new Promise((r) => setTimeout(r, 50));
+    expect(lastFrame()!).toContain('***');
+    expect(lastFrame()!).not.toContain('abc');
+  });
+
+  it('shows validation error and blocks submit', async () => {
+    let submitted = false;
+    const validate = (v: string) => (v.length < 3 ? 'Too short' : undefined);
+    const { stdin, lastFrame } = render(
+      <TextPrompt
+        title="Enter"
+        onSubmit={() => {
+          submitted = true;
+        }}
+        onCancel={() => {}}
+        validate={validate}
+      />,
+    );
+    stdin.write('ab');
+    stdin.write('\r');
+    expect(submitted).toBe(false);
+    await new Promise((r) => setTimeout(r, 50));
+    expect(lastFrame()!).toContain('Too short');
+  });
+
+  // SCREEN-005: footer renders through the key-hint SSOT grammar.
+  it('renders the footer in the shared key-hint grammar', () => {
+    const { lastFrame } = render(
+      <TextPrompt title="Enter value" onSubmit={() => {}} onCancel={() => {}} />,
+    );
+    expect(lastFrame()!).toContain(
+      formatKeyHints([
+        { keys: 'Enter', label: 'Submit' },
+        { keys: 'Esc', label: 'Cancel' },
+      ]),
+    );
+  });
+});

package/src/__tests__/TransportTUI.test.tsx

@@ -0,0 +1,124 @@
+/**
+ * TRANS-009 — the toggle surface tells the truth about what it did.
+ *
+ * Two defects, one place. `registry.setEnabled` writes a settings file and returns; nothing on that
+ * path starts a transport, and `startAll` reads `getEnabled()` at session start. So the row used to
+ * report a transport as running because a file had changed. And the failure branch was
+ * `.catch(() => setSaving(false))` — the error taken and discarded, so an unwritable settings file
+ * looked exactly like a successful save.
+ *
+ * The assertions are on what the COMPONENT RENDERS, not on whether the registry was called. A test
+ * that asserts `setEnabled` was invoked passes against both the old code and the new one, because
+ * the call was never the defect.
+ */
+import { render } from 'ink-testing-library';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import TransportTUI from '../TransportTUI.js';
+
+import type {
+  ITransportEntry,
+  ITransportSettingsRegistryView,
+} from '@robota-sdk/agent-interface-transport';
+
+function entry(name: string, enabled: boolean): ITransportEntry {
+  return {
+    transport: { name },
+    config: { enabled, options: {} },
+  } as unknown as ITransportEntry;
+}
+
+function registryWith(
+  setEnabled: ITransportSettingsRegistryView['setEnabled'],
+  entries = [entry('ws', false)],
+): ITransportSettingsRegistryView {
+  return {
+    getAll: () => entries,
+    setEnabled,
+    setOptions: vi.fn().mockResolvedValue(undefined),
+  } as unknown as ITransportSettingsRegistryView;
+}
+
+const flush = async (): Promise<void> => {
+  await new Promise((resolve) => setImmediate(resolve));
+  await new Promise((resolve) => setImmediate(resolve));
+};
+
+describe('TRANS-009: the surface says when a toggle applies', () => {
+  it('states that a toggle applies at the next start', () => {
+    const { lastFrame } = render(
+      <TransportTUI
+        registry={registryWith(vi.fn().mockResolvedValue(undefined))}
+        onClose={vi.fn()}
+      />,
+    );
+    expect(lastFrame()).toContain('applies the next time Assistant starts');
+  });
+
+  it('does not describe a saved setting as a running transport', () => {
+    // `[enabled]` read as "this is up". The badge names the saved setting instead.
+    const { lastFrame } = render(
+      <TransportTUI
+        registry={registryWith(vi.fn().mockResolvedValue(undefined), [entry('ws', true)])}
+        onClose={vi.fn()}
+      />,
+    );
+    const frame = lastFrame() ?? '';
+    expect(frame).not.toContain('[enabled]');
+    expect(frame).toContain('[on]');
+  });
+
+  it('names the saved setting for a disabled transport too', () => {
+    // The other half of the badge's ternary. Asserting only the enabled branch leaves the disabled
+    // one uncovered by the change that rewrote both — the coverage gap HARNESS-122 was made of: a
+    // mutation proves a case measures the guard, not that the cases reach across it.
+    const { lastFrame } = render(
+      <TransportTUI
+        registry={registryWith(vi.fn().mockResolvedValue(undefined), [entry('ws', false)])}
+        onClose={vi.fn()}
+      />,
+    );
+    const frame = lastFrame() ?? '';
+    expect(frame).not.toContain('[disabled]');
+    expect(frame).toContain('[off]');
+  });
+});
+
+describe('TRANS-009: a failed save is reported, not swallowed', () => {
+  it('renders the reason when the write fails', async () => {
+    const registry = registryWith(vi.fn().mockRejectedValue(new Error('EACCES: settings.json')));
+    const { stdin, lastFrame } = render(<TransportTUI registry={registry} onClose={vi.fn()} />);
+
+    stdin.write(' ');
+    await flush();
+
+    const frame = lastFrame() ?? '';
+    expect(frame).toContain('Not saved');
+    expect(frame).toContain('EACCES: settings.json');
+  });
+
+  it('reports a non-Error rejection rather than rendering nothing', async () => {
+    // The branch that would otherwise print `undefined` — a rejection that is not an Error still has
+    // to produce a sentence, because the user's question is whether their change took effect.
+    const registry = registryWith(vi.fn().mockRejectedValue('nope'));
+    const { stdin, lastFrame } = render(<TransportTUI registry={registry} onClose={vi.fn()} />);
+
+    stdin.write(' ');
+    await flush();
+
+    expect(lastFrame() ?? '').toContain('could not save the setting');
+  });
+
+  // THE POSITIVE CONTROL. Without it the two cases above pass against a component that renders
+  // "Not saved" unconditionally — which would be a worse defect than the one being fixed.
+  it('shows no failure when the save succeeds', async () => {
+    const registry = registryWith(vi.fn().mockResolvedValue(undefined));
+    const { stdin, lastFrame } = render(<TransportTUI registry={registry} onClose={vi.fn()} />);
+
+    stdin.write(' ');
+    await flush();
+
+    expect(lastFrame() ?? '').not.toContain('Not saved');
+  });
+});

package/src/__tests__/TuiInteractionChannel.askUser.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Unit tests for TuiInteractionChannel.askUser() — the CMD-004 unified ask path (the sole
+ * "ask the user" seam). Queue resolution + abort cancellation in isolation; no Ink render.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@robota-sdk/agent-framework', async () => {
+  const actual = await vi.importActual<typeof import('@robota-sdk/agent-framework')>(
+    '@robota-sdk/agent-framework',
+  );
+  // RUNTIME-001: construction flows through buildRuntimeSession (wraps InteractiveSession); mock both.
+  const makeMockSession = (): unknown => ({
+    getFullHistory: vi.fn().mockReturnValue([]),
+    setName: vi.fn(),
+    getSessionId: vi.fn().mockReturnValue('test-id'),
+    isInitialized: false,
+    on: vi.fn(),
+    off: vi.fn(),
+    cancelQueue: vi.fn(),
+    abort: vi.fn(),
+  });
+  return {
+    ...actual,
+    InteractiveSession: vi.fn().mockImplementation(makeMockSession),
+    buildRuntimeSession: vi.fn().mockImplementation(makeMockSession),
+    CommandRegistry: vi.fn().mockImplementation(() => ({
+      addModule: vi.fn(),
+    })),
+  };
+});
+
+import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
+
+import type { IAIProvider, IActionRequest } from '@robota-sdk/agent-core';
+
+function makeChannel(): TuiInteractionChannel {
+  return new TuiInteractionChannel({ cwd: '/tmp', provider: {} as IAIProvider });
+}
+
+const SELECT: IActionRequest = {
+  id: 'mode',
+  title: 'Select mode',
+  options: [
+    { value: 'plan', label: 'Plan' },
+    { value: 'default', label: 'Default' },
+  ],
+  maxSelect: 1,
+};
+
+const CONFIRM: IActionRequest = {
+  id: 'exit',
+  title: 'Exit?',
+  options: [
+    { value: 'yes', label: 'Yes' },
+    { value: 'no', label: 'No' },
+  ],
+  maxSelect: 1,
+};
+
+describe('TuiInteractionChannel.askUser', () => {
+  let channel: TuiInteractionChannel;
+
+  beforeEach(() => {
+    channel = makeChannel();
+  });
+
+  it('sets pendingUserAction when askUser is called', () => {
+    void channel.askUser(SELECT);
+    expect(channel.pendingUserAction).toMatchObject({ id: 'mode' });
+  });
+
+  it('resolves the answer when resolveUserAction is called, then clears pendingUserAction', async () => {
+    const promise = channel.askUser(SELECT);
+    channel.resolveUserAction(channel.pendingUserAction!, {
+      type: 'answer',
+      values: ['default'],
+    });
+    const response = await promise;
+    expect(response).toEqual({ type: 'answer', values: ['default'] });
+    expect(channel.pendingUserAction).toBeNull();
+  });
+
+  it('resolves cancelled', async () => {
+    const promise = channel.askUser(SELECT);
+    channel.resolveUserAction(channel.pendingUserAction!, { type: 'cancelled' });
+    expect(await promise).toEqual({ type: 'cancelled' });
+  });
+
+  it('queues multiple asks and processes them sequentially', async () => {
+    const p1 = channel.askUser(SELECT);
+    const p2 = channel.askUser(CONFIRM);
+    expect(channel.pendingUserAction).toMatchObject({ id: 'mode' });
+
+    channel.resolveUserAction(channel.pendingUserAction!, { type: 'answer', values: ['plan'] });
+    await p1;
+    expect(channel.pendingUserAction).toMatchObject({ id: 'exit' });
+
+    channel.resolveUserAction(channel.pendingUserAction!, { type: 'answer', values: ['no'] });
+    expect(await p2).toEqual({ type: 'answer', values: ['no'] });
+    expect(channel.pendingUserAction).toBeNull();
+  });
+
+  it('cancelQueue() resolves every in-flight/queued ask as cancelled', async () => {
+    const p1 = channel.askUser(SELECT);
+    const p2 = channel.askUser(CONFIRM);
+    channel.cancelQueue();
+    expect(await p1).toEqual({ type: 'cancelled' });
+    expect(await p2).toEqual({ type: 'cancelled' });
+    expect(channel.pendingUserAction).toBeNull();
+  });
+
+  it('abort() resolves an in-flight ask as cancelled', async () => {
+    const promise = channel.askUser(SELECT);
+    channel.abort();
+    expect(await promise).toEqual({ type: 'cancelled' });
+  });
+
+  it('calls onChange when pendingUserAction changes', () => {
+    const onChange = vi.fn();
+    channel.onChange = onChange;
+    void channel.askUser(SELECT);
+    expect(onChange).toHaveBeenCalled();
+  });
+});

package/src/__tests__/TuiInteractionChannel.display-contract.test.ts

@@ -0,0 +1,284 @@
+/**
+ * Display-contract tests for TuiInteractionChannel.
+ *
+ * Verifies user-visible state: which entries appear in stateManager.history,
+ * with which roles, and in which order.
+ *
+ * These are deliberately separate from lifecycle.test.ts:
+ *   lifecycle  → event routing / onChange propagation (mechanism layer)
+ *   this file  → what the user sees on screen (display contract layer)
+ *
+ * Design principles:
+ *   - user_message assertions do NOT require getFullHistory injection
+ *   - every history assertion checks entry.type (= role) explicitly
+ *   - timing: user message visible BEFORE complete fires
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('@robota-sdk/agent-framework', async () => {
+  const actual = await vi.importActual<typeof import('@robota-sdk/agent-framework')>(
+    '@robota-sdk/agent-framework',
+  );
+  // RUNTIME-001: construction flows through buildRuntimeSession (wraps InteractiveSession); mock both.
+  const makeMockSession = (): unknown => {
+    {
+      const handlers = new Map<string, Array<(...args: unknown[]) => void>>();
+      return {
+        getFullHistory: vi.fn().mockReturnValue([]),
+        setName: vi.fn(),
+        getName: vi.fn().mockReturnValue(undefined),
+        getPermissionMode: vi.fn().mockReturnValue('default'),
+        isInitialized: false,
+        on: vi.fn().mockImplementation((event: string, handler: (...args: unknown[]) => void) => {
+          if (!handlers.has(event)) handlers.set(event, []);
+          handlers.get(event)!.push(handler);
+        }),
+        off: vi.fn(),
+        emit: (event: string, ...args: unknown[]) => {
+          (handlers.get(event) ?? []).forEach((h) => h(...args));
+        },
+        submit: vi.fn().mockResolvedValue(undefined),
+        executeCommand: vi.fn().mockResolvedValue(null),
+        getPendingPrompt: vi.fn().mockReturnValue(null),
+        abort: vi.fn(),
+        cancelQueue: vi.fn(),
+        listSelfPacedLoops: vi.fn().mockReturnValue([]),
+        stopSelfPacedLoop: vi.fn().mockResolvedValue(undefined),
+        getContextState: vi.fn().mockReturnValue({
+          usedPercentage: 0,
+          usedTokens: 0,
+          maxTokens: 100_000,
+        }),
+        getExecutionWorkspaceSnapshot: vi.fn().mockReturnValue({ entries: [] }),
+        shutdown: vi.fn().mockResolvedValue(undefined),
+        sendAgentJob: vi.fn().mockResolvedValue(undefined),
+        readExecutionWorkspaceDetail: vi.fn().mockResolvedValue({}),
+      };
+    }
+  };
+  return {
+    ...actual,
+    InteractiveSession: vi.fn().mockImplementation(makeMockSession),
+    buildRuntimeSession: vi.fn().mockImplementation(makeMockSession),
+    CommandRegistry: vi.fn().mockImplementation(() => ({
+      addModule: vi.fn(),
+    })),
+  };
+});
+
+import {
+  createAssistantMessage,
+  createSystemMessage,
+  createUserMessage,
+  messageToHistoryEntry,
+} from '@robota-sdk/agent-core';
+import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
+
+import type { IAIProvider, IHistoryEntry } from '@robota-sdk/agent-core';
+import type { IExecutionResult } from '@robota-sdk/agent-interface-session';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+type MockSession = {
+  getFullHistory: ReturnType<typeof vi.fn>;
+  listSelfPacedLoops: ReturnType<typeof vi.fn>;
+  stopSelfPacedLoop: ReturnType<typeof vi.fn>;
+  on: ReturnType<typeof vi.fn>;
+  emit: (event: string, ...args: unknown[]) => void;
+};
+
+function getMockSession(channel: TuiInteractionChannel): MockSession {
+  return (channel as unknown as { interactiveSession: MockSession }).interactiveSession;
+}
+
+function emitSessionEvent(channel: TuiInteractionChannel, event: string, ...args: unknown[]): void {
+  getMockSession(channel).emit(event, ...args);
+}
+
+function makeChannel(provider: IAIProvider = {} as IAIProvider): TuiInteractionChannel {
+  return new TuiInteractionChannel({
+    cwd: '/tmp/test',
+    provider,
+  });
+}
+
+function makeResult(overrides?: Partial<IExecutionResult>): IExecutionResult {
+  return {
+    contextState: { usedPercentage: 5, usedTokens: 500, maxTokens: 100_000 },
+    response: 'done',
+    ...overrides,
+  } as unknown as IExecutionResult;
+}
+
+const MOCK_TOOL_RUNNING = {
+  toolName: 'bash',
+  isRunning: true,
+  input: '{}',
+  startTime: Date.now(),
+};
+
+const MOCK_TOOL_DONE = {
+  toolName: 'bash',
+  isRunning: false,
+  input: '{}',
+  startTime: Date.now(),
+};
+
+function entryRole(entry: IHistoryEntry): string {
+  return entry.type;
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+// ── Group D: display contract (what the user sees) ────────────────────────────
+
+describe('Group D — display contract: history entries and active tools', () => {
+  it('keeps automatic naming text-only when an external event starts the session', async () => {
+    const chat = vi.fn().mockResolvedValue({ role: 'assistant', content: 'Event summary' });
+    const channel = makeChannel({ chat } as unknown as IAIProvider);
+    await channel.start();
+
+    emitSessionEvent(channel, 'turn_source', 'external');
+    emitSessionEvent(channel, 'user_message', 'external event');
+
+    expect(chat).toHaveBeenCalledTimes(1);
+    expect(chat.mock.calls[0]?.[1]?.toolChoice).toBe('none');
+    await channel.stop();
+  });
+
+  it('Esc stops the only waiting self-paced loop without aborting the session', async () => {
+    const channel = makeChannel();
+    const session = getMockSession(channel);
+    session.listSelfPacedLoops.mockReturnValue([{ loopId: 'loop_one', phase: 'waiting' }]);
+    await channel.stopWaitingSelfPacedLoop();
+    expect(session.stopSelfPacedLoop).toHaveBeenCalledWith('loop_one', 'Loop stopped by Esc');
+    expect(channel.stateManager.history.some((entry) =>
+      JSON.stringify(entry).includes('loop_one'))).toBe(true);
+  });
+
+  it('Esc does not guess which loop to stop when several are waiting', async () => {
+    const channel = makeChannel();
+    const session = getMockSession(channel);
+    session.listSelfPacedLoops.mockReturnValue([
+      { loopId: 'loop_one', phase: 'waiting' },
+      { loopId: 'loop_two', phase: 'waiting' },
+    ]);
+    await channel.stopWaitingSelfPacedLoop();
+    expect(session.stopSelfPacedLoop).not.toHaveBeenCalled();
+    expect(channel.stateManager.history.some((entry) =>
+      JSON.stringify(entry).includes('/loop stop'))).toBe(true);
+  });
+
+  it('D1 (CLI-B05): user_message event immediately adds role=user entry before complete', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    // user message fires BEFORE complete — must be in history immediately
+    emitSessionEvent(channel, 'user_message', 'hello');
+
+    expect(channel.stateManager.history).toHaveLength(1);
+    expect(entryRole(channel.stateManager.history[0])).toBe('user');
+    expect((channel.stateManager.history[0].data as { content: string }).content).toBe('hello');
+
+    await channel.stop();
+  });
+
+  it('D2: complete syncs assistant entry into history', async () => {
+    const channel = makeChannel();
+    const mockSession = getMockSession(channel);
+    const assistantEntry = messageToHistoryEntry(createAssistantMessage('Hi!'));
+    mockSession.getFullHistory.mockReturnValue([assistantEntry]);
+    await channel.start();
+
+    emitSessionEvent(channel, 'complete', makeResult());
+
+    const roles = channel.stateManager.history.map(entryRole);
+    expect(roles).toContain('assistant');
+    await channel.stop();
+  });
+
+  it('D3 (CLI-B06): error event syncs error entry into history — no silent failure', async () => {
+    const channel = makeChannel();
+    const mockSession = getMockSession(channel);
+    const userEntry = messageToHistoryEntry(createUserMessage('hello'));
+    const errorEntry = messageToHistoryEntry(createSystemMessage('Error: network failure'));
+    mockSession.getFullHistory.mockReturnValue([userEntry, errorEntry]);
+    await channel.start();
+
+    emitSessionEvent(channel, 'user_message', 'hello');
+    emitSessionEvent(channel, 'error');
+
+    // error entry from getFullHistory must be visible
+    const roles = channel.stateManager.history.map(entryRole);
+    expect(roles).toContain('system');
+    await channel.stop();
+  });
+
+  it('D4 (CLI-B07): tool_end marks tool isRunning=false; complete clears all (no stale spinner after complete)', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    emitSessionEvent(channel, 'tool_start', MOCK_TOOL_RUNNING);
+    expect(channel.stateManager.activeTools).toHaveLength(1);
+
+    // After tool_end: tool stays in activeTools with isRunning:false (shows "ran" status during streaming)
+    emitSessionEvent(channel, 'tool_end', MOCK_TOOL_DONE);
+    expect(channel.stateManager.activeTools).toHaveLength(1);
+    expect(channel.stateManager.activeTools[0]!.isRunning).toBe(false);
+
+    // After complete: all tools cleared — StreamingIndicator must be gone
+    emitSessionEvent(channel, 'complete', makeResult());
+    expect(channel.stateManager.activeTools).toHaveLength(0);
+
+    await channel.stop();
+  });
+
+  it('D5 (CLI-B08): thinking(false) clears activeTools even without complete', async () => {
+    const channel = makeChannel();
+    await channel.start();
+
+    emitSessionEvent(channel, 'thinking', true);
+    emitSessionEvent(channel, 'tool_start', MOCK_TOOL_RUNNING);
+    expect(channel.stateManager.activeTools).toHaveLength(1);
+
+    // abort path: thinking(false) without complete
+    emitSessionEvent(channel, 'thinking', false);
+    expect(channel.stateManager.activeTools).toHaveLength(0);
+
+    await channel.stop();
+  });
+
+  it('D6: full turn — user entry appears first, assistant entry follows after complete', async () => {
+    const channel = makeChannel();
+    const mockSession = getMockSession(channel);
+    const userEntry = messageToHistoryEntry(createUserMessage('hello'));
+    const assistantEntry = messageToHistoryEntry(createAssistantMessage('world'));
+    // session history after complete includes both
+    mockSession.getFullHistory.mockReturnValue([userEntry, assistantEntry]);
+    await channel.start();
+
+    // 1. user message fires — visible immediately
+    emitSessionEvent(channel, 'user_message', 'hello');
+    expect(entryRole(channel.stateManager.history[0])).toBe('user');
+
+    // 2. streaming
+    emitSessionEvent(channel, 'text_delta', 'world');
+    expect(channel.stateManager.streamingText).toBe('world');
+
+    // 3. complete — syncHistory replaces with authoritative session history
+    emitSessionEvent(channel, 'complete', makeResult());
+    expect(channel.stateManager.streamingText).toBe('');
+
+    const roles = channel.stateManager.history.map(entryRole);
+    expect(roles[0]).toBe('user');
+    expect(roles[1]).toBe('assistant');
+
+    await channel.stop();
+  });
+});