@robota-sdk/agent-transport 3.0.0-beta.74 → 3.0.0-beta.76

package/src/tui/__tests__/render-channel-options.test.ts

@@ -1,32 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { IAIProvider } from '@robota-sdk/agent-core';
-import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
-import { toChannelOptions } from '../render.js';
-import type { IRenderOptions } from '../render.js';
-
-describe('toChannelOptions', () => {
-  it('TC-02: threads allowedTools and deniedTools into the channel options', () => {
-    const renderOptions: IRenderOptions = {
-      cwd: '/tmp/project',
-      provider: {} as IAIProvider,
-      cliAdapter: {} as ITuiCliAdapter,
-      allowedTools: ['Read'],
-      deniedTools: ['Bash'],
-    };
-    const channelOptions = toChannelOptions(renderOptions, 'session-1');
-    expect(channelOptions.allowedTools).toEqual(['Read']);
-    expect(channelOptions.deniedTools).toEqual(['Bash']);
-    expect(channelOptions.resumeSessionId).toBe('session-1');
-    expect(channelOptions.cwd).toBe('/tmp/project');
-  });
-
-  it('leaves tool filters undefined when not provided', () => {
-    const channelOptions = toChannelOptions({
-      cwd: '/tmp/project',
-      provider: {} as IAIProvider,
-      cliAdapter: {} as ITuiCliAdapter,
-    });
-    expect(channelOptions.allowedTools).toBeUndefined();
-    expect(channelOptions.deniedTools).toBeUndefined();
-  });
-});

package/src/tui/__tests__/render-markdown.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { renderMarkdown } from '../render-markdown.js';
-
-const ANSI_LIGHT_RED = '\u001b[38;5;210m';
-const ANSI_LIGHT_GREEN = '\u001b[38;5;120m';
-const ANSI_DARK_RED_BACKGROUND = '\u001b[48;5;52m';
-const ANSI_DARK_GREEN_BACKGROUND = '\u001b[48;5;22m';
-const ANSI_RESET = '\u001b[0m';
-const CODE_BLOCK_INDENT = '    ';
-
-describe('renderMarkdown', () => {
-  it('renders diff fenced code blocks with addition and removal colors', () => {
-    const output = renderMarkdown(
-      ['Before', '', '```diff', '- const oldValue = true;', '+ const newValue = true;', '```'].join(
-        '\n',
-      ),
-      { color: true },
-    );
-
-    expect(output).toContain(`${ANSI_DARK_RED_BACKGROUND}${ANSI_LIGHT_RED}`);
-    expect(output).toContain(`${CODE_BLOCK_INDENT}- const oldValue = true;`);
-    expect(output).toContain(`${ANSI_DARK_GREEN_BACKGROUND}${ANSI_LIGHT_GREEN}`);
-    expect(output).toContain(`${CODE_BLOCK_INDENT}+ const newValue = true;`);
-  });
-
-  it('pads added and removed diff rows before applying background colors', () => {
-    const codeBlockWidth = 24;
-    const removedRow = `${CODE_BLOCK_INDENT}- removed`.padEnd(codeBlockWidth);
-    const addedRow = `${CODE_BLOCK_INDENT}+ added`.padEnd(codeBlockWidth);
-    const output = renderMarkdown(['```diff', '- removed', '+ added', '```'].join('\n'), {
-      color: true,
-      codeBlockWidth,
-    });
-
-    expect(output).toContain(
-      `${ANSI_DARK_RED_BACKGROUND}${ANSI_LIGHT_RED}${removedRow}${ANSI_RESET}`,
-    );
-    expect(output).toContain(
-      `${ANSI_DARK_GREEN_BACKGROUND}${ANSI_LIGHT_GREEN}${addedRow}${ANSI_RESET}`,
-    );
-  });
-
-  it('keeps diff fenced code block content readable when color is disabled', () => {
-    const output = renderMarkdown(
-      ['```diff', '- removed line', '+ added line', ' unchanged line', '```'].join('\n'),
-      { color: false },
-    );
-
-    expect(output).toContain('- removed line');
-    expect(output).toContain('+ added line');
-    expect(output).toContain(' unchanged line');
-    expect(output).not.toContain(ANSI_LIGHT_RED);
-    expect(output).not.toContain(ANSI_LIGHT_GREEN);
-    expect(output).not.toContain(ANSI_DARK_RED_BACKGROUND);
-    expect(output).not.toContain(ANSI_DARK_GREEN_BACKGROUND);
-  });
-
-  it('keeps regular fenced code blocks as code output', () => {
-    const output = renderMarkdown(['```ts', 'const value: string = "ok";', '```'].join('\n'), {
-      color: false,
-    });
-
-    expect(output).toContain('const value: string = "ok";');
-  });
-
-  it('keeps inline markdown formatting readable', () => {
-    const output = renderMarkdown('Use **bold** and `code` here.', { color: false });
-
-    expect(output).toContain('bold');
-    expect(output).toContain('code');
-  });
-});

package/src/tui/__tests__/selection-flow.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  applySelectionInput,
-  createSelectionFlowState,
-  getDirectionalSelectionInputAction,
-  getVerticalSelectionInputAction,
-} from '../flows/selection-flow.js';
-
-describe('selection flow', () => {
-  it('Given first item selected When previous is applied Then selection stays bounded', () => {
-    const result = applySelectionInput(createSelectionFlowState(), 'previous', { itemCount: 3 });
-
-    expect(result.state.selectedIndex).toBe(0);
-    expect(result.effect).toEqual({ type: 'none' });
-  });
-
-  it('Given last item selected When next is applied Then selection stays bounded', () => {
-    const state = { selectedIndex: 2, scrollOffset: 0, resolved: false };
-
-    const result = applySelectionInput(state, 'next', { itemCount: 3 });
-
-    expect(result.state.selectedIndex).toBe(2);
-  });
-
-  it('Given wrapping selection When previous from first is applied Then it wraps to last', () => {
-    const result = applySelectionInput(createSelectionFlowState(), 'previous', {
-      itemCount: 3,
-      wrap: true,
-    });
-
-    expect(result.state.selectedIndex).toBe(2);
-  });
-
-  it('Given max visible window When moving below viewport Then scroll offset follows', () => {
-    const state = applySelectionInput(createSelectionFlowState(), 'next', {
-      itemCount: 4,
-      maxVisible: 2,
-    }).state;
-
-    const result = applySelectionInput(state, 'next', { itemCount: 4, maxVisible: 2 });
-
-    expect(result.state).toMatchObject({ selectedIndex: 2, scrollOffset: 1 });
-  });
-
-  it('Given selected item When select is applied Then selected index is emitted once', () => {
-    const state = { selectedIndex: 1, scrollOffset: 0, resolved: false };
-
-    const selected = applySelectionInput(state, 'select', { itemCount: 3 });
-    const ignored = applySelectionInput(selected.state, 'select', { itemCount: 3 });
-
-    expect(selected.effect).toEqual({ type: 'select', index: 1 });
-    expect(ignored.effect).toEqual({ type: 'none' });
-  });
-
-  it('Given raw key info When mapped Then vertical and directional actions are produced', () => {
-    expect(getVerticalSelectionInputAction({ downArrow: true })).toBe('next');
-    expect(getVerticalSelectionInputAction({ escape: true })).toBe('cancel');
-    expect(getDirectionalSelectionInputAction({ leftArrow: true })).toBe('previous');
-    expect(getDirectionalSelectionInputAction({ rightArrow: true })).toBe('next');
-  });
-});

package/src/tui/__tests__/session-init-poller.test.ts

@@ -1,102 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { createSessionInitPoller } from '../flows/session-init-poller.js';
-
-describe('createSessionInitPoller', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('TC-04: calls onReady and stops once the check succeeds', () => {
-    const onReady = vi.fn();
-    const onFailure = vi.fn();
-    let ready = false;
-    const poller = createSessionInitPoller({
-      check: () => {
-        if (!ready) throw new Error('InteractiveSession not initialized. Call submit().');
-      },
-      intervalMs: 200,
-      timeoutMs: 15000,
-      onReady,
-      onFailure,
-    });
-    poller.start();
-    vi.advanceTimersByTime(600);
-    expect(onReady).not.toHaveBeenCalled();
-    ready = true;
-    vi.advanceTimersByTime(200);
-    expect(onReady).toHaveBeenCalledTimes(1);
-    vi.advanceTimersByTime(2000);
-    expect(onReady).toHaveBeenCalledTimes(1);
-    expect(onFailure).not.toHaveBeenCalled();
-  });
-
-  it('TC-04: benign not-initialized errors poll until timeout, then fail with timeout kind', () => {
-    const onReady = vi.fn();
-    const onFailure = vi.fn();
-    const poller = createSessionInitPoller({
-      check: () => {
-        throw new Error('InteractiveSession not initialized. Call submit().');
-      },
-      intervalMs: 200,
-      timeoutMs: 1000,
-      onReady,
-      onFailure,
-    });
-    poller.start();
-    vi.advanceTimersByTime(900);
-    expect(onFailure).not.toHaveBeenCalled();
-    vi.advanceTimersByTime(400);
-    expect(onFailure).toHaveBeenCalledTimes(1);
-    expect(onFailure.mock.calls[0]?.[0]).toMatchObject({ kind: 'timeout' });
-    expect(onReady).not.toHaveBeenCalled();
-    vi.advanceTimersByTime(2000);
-    expect(onFailure).toHaveBeenCalledTimes(1);
-  });
-
-  it('TC-04: a real error fails immediately with the error attached', () => {
-    const onFailure = vi.fn();
-    const poller = createSessionInitPoller({
-      check: () => {
-        throw new Error('ENOENT: session store unreadable');
-      },
-      intervalMs: 200,
-      timeoutMs: 15000,
-      onReady: vi.fn(),
-      onFailure,
-    });
-    poller.start();
-    vi.advanceTimersByTime(200);
-    expect(onFailure).toHaveBeenCalledTimes(1);
-    expect(onFailure.mock.calls[0]?.[0]).toMatchObject({ kind: 'error' });
-    expect(String((onFailure.mock.calls[0]?.[0] as { error: Error }).error.message)).toContain(
-      'ENOENT',
-    );
-    vi.advanceTimersByTime(2000);
-    expect(onFailure).toHaveBeenCalledTimes(1);
-  });
-
-  it('stop() cancels polling without callbacks', () => {
-    const onReady = vi.fn();
-    const onFailure = vi.fn();
-    const poller = createSessionInitPoller({
-      check: () => {
-        throw new Error('InteractiveSession not initialized.');
-      },
-      intervalMs: 200,
-      timeoutMs: 1000,
-      onReady,
-      onFailure,
-    });
-    poller.start();
-    vi.advanceTimersByTime(400);
-    poller.stop();
-    vi.advanceTimersByTime(5000);
-    expect(onReady).not.toHaveBeenCalled();
-    expect(onFailure).not.toHaveBeenCalled();
-  });
-});

package/src/tui/__tests__/session-naming.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { generateSessionName } from '../session-naming.js';
-import type { IAIProvider } from '@robota-sdk/agent-core';
-
-function makeProvider(responseContent: string): IAIProvider {
-  return {
-    name: 'mock',
-    version: '1.0.0',
-    chat: vi.fn().mockResolvedValue({ role: 'assistant', content: responseContent }),
-    generateResponse: vi.fn(),
-    supportsTools: () => false,
-  } as unknown as IAIProvider;
-}
-
-describe('generateSessionName', () => {
-  it('returns sanitized name from provider response', async () => {
-    const provider = makeProvider('refactor-auth-middleware');
-    const name = await generateSessionName(provider, 'Refactor the auth middleware');
-    expect(name).toBe('refactor-auth-middleware');
-  });
-
-  it('lowercases and strips special characters', async () => {
-    const provider = makeProvider('Fix: Database Connection!');
-    const name = await generateSessionName(provider, 'Fix database connection');
-    expect(name).toBe('fix-database-connection');
-  });
-
-  it('collapses multiple spaces to single hyphen', async () => {
-    const provider = makeProvider('write  api   docs');
-    const name = await generateSessionName(provider, 'Write API docs');
-    expect(name).toBe('write-api-docs');
-  });
-
-  it('falls back to sanitized first message when response is too short', async () => {
-    const provider = makeProvider('ok');
-    const name = await generateSessionName(provider, 'Fix login bug');
-    expect(name).toBe('fix-login-bug');
-  });
-
-  it('truncates long names to 60 chars', async () => {
-    const long = 'a'.repeat(100);
-    const provider = makeProvider(long);
-    const name = await generateSessionName(provider, 'something');
-    expect(name.length).toBeLessThanOrEqual(60);
-  });
-
-  it('passes maxTokens: 20 to provider', async () => {
-    const provider = makeProvider('short-name');
-    await generateSessionName(provider, 'test');
-    expect(provider.chat).toHaveBeenCalledWith(
-      expect.any(Array),
-      expect.objectContaining({ maxTokens: 20 }),
-    );
-  });
-
-  it('truncates first message to 200 chars before sending', async () => {
-    const long = 'x'.repeat(500);
-    const provider = makeProvider('short-name');
-    await generateSessionName(provider, long);
-    const messages = (provider.chat as ReturnType<typeof vi.fn>).mock.calls[0][0];
-    const userMsg = messages.find((m: { role: string }) => m.role === 'user');
-    expect(userMsg.content.length).toBeLessThanOrEqual(200);
-  });
-});

package/src/tui/__tests__/session-switch-channel.test.tsx

@@ -1,307 +0,0 @@
-/**
- * CLI-B11 TC-01/03/05 + CLI-B12 TC-01/02/04: session-switch channel ownership
- * at the App boundary.
- *
- * The 2026-05-31 context-loss bug lived between render.tsx, App.tsx and
- * TuiInteractionChannel — InteractiveSession-level tests stayed green through it.
- * These tests render the REAL App with a mocked createChannel factory and drive
- * switches through the real SessionPicker, pinning the factory-call contract.
- * Since CLI-B12 the factory is the SOLE channel source: App creates the initial
- * channel in its useState initializer and replaces it on every switch.
- */
-
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { render } from 'ink-testing-library';
-import React from 'react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-import App from '../App.js';
-import { CommandEffectQueue } from '../hooks/command-effect-queue.js';
-import { TuiStateManager } from '../tui-state-manager.js';
-
-import type { ICommandEffectQueue } from '../hooks/command-effect-queue.js';
-import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
-import type { TuiInteractionChannel } from '../TuiInteractionChannel.js';
-import type {
-  IInteractiveSessionRecord,
-  IInteractiveSessionStore,
-} from '@robota-sdk/agent-interface-transport';
-
-const TICK_MS = 30;
-const FRAME_DEADLINE_MS = 3000;
-
-function tick(ms = TICK_MS): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function waitForFrame(
-  lastFrame: () => string | undefined,
-  predicate: (frame: string) => boolean,
-): Promise<void> {
-  const deadline = Date.now() + FRAME_DEADLINE_MS;
-  while (Date.now() < deadline) {
-    const frame = lastFrame();
-    if (frame !== undefined && predicate(frame)) return;
-    await tick(10);
-  }
-  throw new Error(`waitForFrame timeout\n--- frame ---\n${lastFrame() ?? '<none>'}`);
-}
-
-interface IFakeChannel {
-  sessionName: string | undefined;
-  stateManager: TuiStateManager;
-  onChange: (() => void) | null;
-  isShuttingDown: boolean;
-  permissionRequest: null;
-  start: ReturnType<typeof vi.fn>;
-  stop: ReturnType<typeof vi.fn>;
-  handleInput: ReturnType<typeof vi.fn>;
-  abort: ReturnType<typeof vi.fn>;
-  cancelQueue: ReturnType<typeof vi.fn>;
-  shutdown: ReturnType<typeof vi.fn>;
-  selectExecutionWorkspaceEntry: ReturnType<typeof vi.fn>;
-  readExecutionWorkspaceDetail: ReturnType<typeof vi.fn>;
-  getSession: () => unknown;
-  getRegistry: () => unknown;
-  getCommandEffectQueue: () => ICommandEffectQueue;
-  /** Test handle: the queue backing getCommandEffectQueue. */
-  effectQueue: CommandEffectQueue;
-  /** Test handle: which resumeSessionId this channel was created for. */
-  createdFor: string | undefined;
-}
-
-function createFakeChannel(createdFor: string | undefined): IFakeChannel {
-  const effectQueue = new CommandEffectQueue();
-  const fakeSession = {
-    getName: (): string | undefined => undefined,
-    getSession: (): never => {
-      throw new Error('session not initialized (test fake)');
-    },
-    getFullHistory: (): never[] => [],
-    setName: vi.fn(),
-    shutdown: vi.fn(async () => {}),
-    sendAgentJob: vi.fn(async () => {}),
-  };
-  const fakeRegistry = {
-    getCommands: (): never[] => [],
-    getSubcommands: (): never[] => [],
-  };
-  return {
-    sessionName: undefined,
-    stateManager: new TuiStateManager(),
-    onChange: null,
-    isShuttingDown: false,
-    permissionRequest: null,
-    start: vi.fn(async () => {}),
-    stop: vi.fn(async () => {}),
-    handleInput: vi.fn(async () => {}),
-    abort: vi.fn(),
-    cancelQueue: vi.fn(),
-    shutdown: vi.fn(async () => {}),
-    selectExecutionWorkspaceEntry: vi.fn(),
-    readExecutionWorkspaceDetail: vi.fn(async () => ({ lines: [], title: '' })),
-    getSession: () => fakeSession,
-    getRegistry: () => fakeRegistry,
-    getCommandEffectQueue: () => effectQueue,
-    effectQueue,
-    createdFor,
-  };
-}
-
-function asChannel(fake: IFakeChannel): TuiInteractionChannel {
-  return fake as unknown as TuiInteractionChannel;
-}
-
-function createFakeStore(records: IInteractiveSessionRecord[]): IInteractiveSessionStore {
-  return {
-    save: () => undefined,
-    load: (id) => records.find((r) => r.id === id),
-    list: () => records,
-    delete: () => undefined,
-  };
-}
-
-function sessionRecord(
-  id: string,
-  cwd: string,
-  updatedAt = '2026-06-13T00:00:00.000Z',
-): IInteractiveSessionRecord {
-  return {
-    id,
-    cwd,
-    createdAt: '2026-06-13T00:00:00.000Z',
-    updatedAt,
-    messages: [
-      { role: 'user', content: `hello from ${id}` },
-      { role: 'assistant', content: `reply in ${id}` },
-    ] as IInteractiveSessionRecord['messages'],
-  };
-}
-
-/** The picker lists sessions newest-first; bumping updatedAt puts a record on top. */
-function touch(records: IInteractiveSessionRecord[], id: string, updatedAt: string): void {
-  const record = records.find((r) => r.id === id);
-  if (!record) throw new Error(`no record ${id}`);
-  record.updatedAt = updatedAt;
-}
-
-function createCliAdapter(settingsPath: string): ITuiCliAdapter {
-  return {
-    getUserSettingsPath: () => settingsPath,
-    readSettings: () => ({}),
-    writeSettings: vi.fn(),
-    deleteSettings: vi.fn().mockReturnValue(false),
-    applyStatusLineSettings: vi.fn(),
-    reloadPluginCommandSource: vi.fn(),
-    applyActiveModelChange: vi.fn().mockReturnValue({ applied: true }),
-    getGitBranch: vi.fn().mockReturnValue(undefined),
-    getProviderDisplayName: vi.fn((type: string) => type),
-  };
-}
-
-describe('App session-switch channel ownership (CLI-B11)', () => {
-  let cwd: string;
-  let created: IFakeChannel[];
-  let createChannel: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    cwd = mkdtempSync(join(tmpdir(), 'robota-b11-'));
-    created = [];
-    createChannel = vi.fn((resumeSessionId?: string) => {
-      const fake = createFakeChannel(resumeSessionId);
-      created.push(fake);
-      return asChannel(fake);
-    });
-  });
-
-  afterEach(() => {
-    rmSync(cwd, { recursive: true, force: true });
-  });
-
-  function renderApp(options?: { sessionIds?: string[] }) {
-    const ids = options?.sessionIds ?? ['session-aaaaaaaa', 'session-bbbbbbbb'];
-    const records = ids.map((id) => sessionRecord(id, cwd));
-    const store = createFakeStore(records);
-    const instance = render(
-      <App
-        cwd={cwd}
-        createChannel={createChannel}
-        sessionStore={store}
-        showSessionPickerOnStart
-        cliAdapter={createCliAdapter(join(cwd, 'settings.json'))}
-      />,
-    );
-    return { ...instance, records };
-  }
-
-  it('TC-01 (B11) / TC-01 (B12): the factory is the sole channel source — once at mount, once per switch with the selected sessionId', async () => {
-    const { stdin, lastFrame } = renderApp();
-    await tick();
-    expect(lastFrame()).toContain('Select a session to resume');
-
-    // CLI-B12 TC-01: initial channel from the useState initializer, exactly once.
-    expect(createChannel).toHaveBeenCalledTimes(1);
-    expect(createChannel).toHaveBeenNthCalledWith(1, undefined);
-
-    stdin.write('\r'); // select first item (newest first — equal timestamps keep list order)
-    await tick();
-
-    // CLI-B11 TC-A: the switch asks the factory for exactly one channel with the id.
-    expect(createChannel).toHaveBeenCalledTimes(2);
-    expect(createChannel).toHaveBeenNthCalledWith(2, 'session-aaaaaaaa');
-  });
-
-  it('TC-03 (B11) / TC-02 (B12): the previous channel is stopped before the new one becomes active', async () => {
-    const { stdin } = renderApp();
-    await tick();
-    const initialChannel = created[0]!;
-    expect(initialChannel.start).toHaveBeenCalled();
-
-    stdin.write('\r');
-    await tick();
-
-    // Old channel released: stopped by the switch handler and by the unmounting
-    // AppInner's effect cleanup (stop() is idempotent by contract).
-    expect(initialChannel.stop).toHaveBeenCalled();
-    expect(created).toHaveLength(2);
-    const newChannel = created[1]!;
-    expect(newChannel.start).toHaveBeenCalled();
-    expect(newChannel.stop).not.toHaveBeenCalled();
-
-    // CLI-B12 TC-02 ordering: old stop() was invoked BEFORE the factory built
-    // the replacement channel (stop-before-active contract).
-    const stopOrder = initialChannel.stop.mock.invocationCallOrder[0]!;
-    const replacementOrder = createChannel.mock.invocationCallOrder[1]!;
-    expect(stopOrder).toBeLessThan(replacementOrder);
-  });
-
-  it('TC-04 (B12): App renders from the factory alone — no channel prop exists', async () => {
-    // The old no-factory fallback (B11 TC-D) is deleted with CLI-B12: createChannel
-    // is required and `channel` is no longer a prop (enforced at the type level —
-    // passing one is a compile error). This pins the runtime half: a render with
-    // only the factory boots, starts the initial channel, and keeps rendering.
-    const { lastFrame } = renderApp();
-    await tick();
-
-    expect(lastFrame()).toBeTruthy();
-    expect(createChannel).toHaveBeenCalledTimes(1);
-    expect(created[0]!.start).toHaveBeenCalled();
-  });
-
-  it('TC-05: consecutive switches A→B→C create one channel per switch and stop each prior channel', async () => {
-    // Selection always takes the top (newest) entry; arrow-key navigation itself
-    // is covered by ListPicker.test.tsx. updatedAt ordering decides the target.
-    const ids = ['aaaaaaaa-1111', 'bbbbbbbb-2222', 'cccccccc-3333'];
-    const { stdin, lastFrame, records } = renderApp({ sessionIds: ids });
-    touch(records, 'aaaaaaaa-1111', '2026-06-13T01:00:00.000Z'); // A on top
-    await waitForFrame(lastFrame, (f) => f.includes('Select a session to resume'));
-
-    // Mount creates the initial channel (factory call 1, undefined).
-    expect(createChannel).toHaveBeenNthCalledWith(1, undefined);
-    const channelInitial = created[0]!;
-
-    // Switch 1: pick A (top) from the startup picker.
-    stdin.write('\r');
-    await waitForFrame(lastFrame, () => createChannel.mock.calls.length === 2);
-    expect(createChannel).toHaveBeenNthCalledWith(2, 'aaaaaaaa-1111');
-    expect(channelInitial.stop).toHaveBeenCalled();
-    const channelA = created[1]!;
-
-    // Switch 2: reopen the picker via a queued session-picker-requested effect,
-    // drained by a submit on the active channel (real /resume drain path).
-    touch(records, 'bbbbbbbb-2222', '2026-06-13T02:00:00.000Z'); // B on top
-    channelA.effectQueue.enqueueEffects([{ type: 'session-picker-requested' }]);
-    stdin.write('x');
-    await tick();
-    stdin.write('\r'); // submit input → drains queue → picker opens
-    await waitForFrame(lastFrame, (f) => f.includes('> bbbbbbbb'));
-    await tick(); // settle: let the reopened picker's useInput subscription attach
-    stdin.write('\r');
-    await waitForFrame(lastFrame, () => createChannel.mock.calls.length === 3);
-    expect(createChannel).toHaveBeenNthCalledWith(3, 'bbbbbbbb-2222');
-    expect(channelA.stop).toHaveBeenCalled();
-    const channelB = created[2]!;
-    expect(channelB.start).toHaveBeenCalled();
-
-    // Switch 3: same drill from B to C.
-    touch(records, 'cccccccc-3333', '2026-06-13T03:00:00.000Z'); // C on top
-    channelB.effectQueue.enqueueEffects([{ type: 'session-picker-requested' }]);
-    stdin.write('x');
-    await tick();
-    stdin.write('\r');
-    await waitForFrame(lastFrame, (f) => f.includes('> cccccccc'));
-    await tick(); // settle: let the reopened picker's useInput subscription attach
-    stdin.write('\r');
-    await waitForFrame(lastFrame, () => createChannel.mock.calls.length === 4);
-    expect(createChannel).toHaveBeenNthCalledWith(4, 'cccccccc-3333');
-    expect(channelB.stop).toHaveBeenCalled();
-
-    const channelC = created[3]!;
-    expect(channelC.start).toHaveBeenCalled();
-    expect(channelC.stop).not.toHaveBeenCalled();
-    expect(createChannel).toHaveBeenCalledTimes(4);
-  });
-});