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

package/src/tui/__tests__/pty/pty-driver.ts

@@ -0,0 +1,135 @@
+/**
+ * PTY TUI driver (CLI-074 TC-07/08).
+ *
+ * Spawns the built robota CLI in a real pseudo-terminal so Ink renders exactly
+ * as in a user terminal, with per-key paced input (expect(1)-style burst input
+ * gets bundled as a bracketed paste — the failure mode this driver exists to
+ * avoid). Test-only; lives in a dedicated vitest project (*.ptytest.ts).
+ */
+
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+import { spawn } from '@homebridge/node-pty-prebuilt-multiarch';
+
+import type { IPty } from '@homebridge/node-pty-prebuilt-multiarch';
+
+const REPO_ROOT = resolve(__dirname, '../../../../../..');
+const ROBOTA_BIN = join(REPO_ROOT, 'packages/agent-cli/bin/robota.cjs');
+
+// eslint-disable-next-line no-control-regex
+const ANSI_PATTERN = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[()][B0]|[\x00-\x08\x0b-\x1f]/g;
+
+export interface IPtySession {
+  /** Type text one key at a time (default 35ms/key — human-ish, avoids paste bundling). */
+  sendKeys(text: string, perKeyDelayMs?: number): Promise<void>;
+  /** Press Enter as a single keystroke. */
+  pressEnter(): Promise<void>;
+  /** Wait until the ANSI-stripped output matches; throws with a snapshot on timeout. */
+  waitFor(pattern: RegExp, timeoutMs?: number): Promise<void>;
+  /** Current ANSI-stripped output. */
+  snapshot(): string;
+  /** Wait for process exit; throws with a snapshot on timeout. */
+  expectExit(timeoutMs?: number): Promise<number>;
+  /** Force-kill (cleanup). */
+  kill(): void;
+}
+
+export interface ISpawnTuiOptions {
+  /** Project cwd (a provider profile settings.json is written here). */
+  projectDir: string;
+  /** Isolated HOME directory. */
+  homeDir: string;
+  cols?: number;
+  rows?: number;
+}
+
+export function writeTuiProviderSettings(projectDir: string): void {
+  const settingsDir = join(projectDir, '.robota');
+  mkdirSync(settingsDir, { recursive: true });
+  writeFileSync(
+    join(settingsDir, 'settings.json'),
+    JSON.stringify({
+      currentProvider: 'anthropic',
+      providers: {
+        // Boot/slash/exit make zero model calls — the key is never used.
+        anthropic: { type: 'anthropic', model: 'claude-test-model', apiKey: 'pty-dummy-key' },
+      },
+    }),
+    'utf8',
+  );
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+
+export function spawnTui(options: ISpawnTuiOptions): IPtySession {
+  mkdirSync(options.homeDir, { recursive: true });
+  let output = '';
+  let exitCode: number | undefined;
+
+  const pty: IPty = spawn(process.execPath, [ROBOTA_BIN], {
+    name: 'xterm-256color',
+    cols: options.cols ?? 100,
+    rows: options.rows ?? 32,
+    cwd: options.projectDir,
+    env: {
+      PATH: process.env['PATH'] ?? '',
+      HOME: options.homeDir,
+      TERM: 'xterm-256color',
+      // Never inherit real provider keys into PTY runs.
+    },
+  });
+
+  pty.onData((data) => {
+    output += data;
+  });
+  pty.onExit(({ exitCode: code }) => {
+    exitCode = code;
+  });
+
+  const stripped = (): string => output.replace(ANSI_PATTERN, '');
+
+  return {
+    async sendKeys(text: string, perKeyDelayMs = 35): Promise<void> {
+      for (const ch of text) {
+        pty.write(ch);
+        await sleep(perKeyDelayMs);
+      }
+    },
+    async pressEnter(): Promise<void> {
+      await sleep(120);
+      pty.write('\r');
+      await sleep(120);
+    },
+    async waitFor(pattern: RegExp, timeoutMs = 15_000): Promise<void> {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        if (pattern.test(stripped())) return;
+        await sleep(100);
+      }
+      throw new Error(
+        `PTY waitFor timeout (${timeoutMs}ms) for ${String(pattern)}\n--- snapshot ---\n${stripped().slice(-2000)}`,
+      );
+    },
+    snapshot: stripped,
+    async expectExit(timeoutMs = 10_000): Promise<number> {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        if (exitCode !== undefined) return exitCode;
+        await sleep(100);
+      }
+      throw new Error(
+        `PTY process did not exit within ${timeoutMs}ms\n--- snapshot ---\n${stripped().slice(-2000)}`,
+      );
+    },
+    kill(): void {
+      try {
+        pty.kill();
+      } catch {
+        // allow-fallback: process already exited — kill on a dead pty is a no-op by design
+      }
+    },
+  };
+}

package/src/tui/__tests__/pty/tui-pty.ptytest.ts

@@ -0,0 +1,61 @@
+/**
+ * Real-PTY TUI suites (CLI-074 TC-07/08).
+ *
+ * Runs in the dedicated PTY vitest project (vitest.pty.config.ts) against the
+ * BUILT robota binary — `pnpm --filter @robota-sdk/agent-cli build` first.
+ */
+
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { spawnTui, writeTuiProviderSettings } from './pty-driver.js';
+
+import type { IPtySession } from './pty-driver.js';
+
+describe('TUI through a real PTY (CLI-074)', () => {
+  let projectDir: string;
+  let session: IPtySession | undefined;
+
+  beforeEach(() => {
+    projectDir = mkdtempSync(join(tmpdir(), 'robota-pty-'));
+    writeTuiProviderSettings(projectDir);
+  });
+
+  afterEach(() => {
+    session?.kill();
+    session = undefined;
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('TC-07: boots, opens slash autocomplete, and executes /help as a command', async () => {
+    session = spawnTui({ projectDir, homeDir: join(projectDir, 'home') });
+
+    // Boot: prompt + status bar render.
+    await session.waitFor(/Type a message or \/help/);
+    await session.waitFor(/Idle/);
+
+    // '/' opens the autocomplete dropdown listing commands.
+    await session.sendKeys('/');
+    await session.waitFor(/\/help\s+Show available commands/);
+
+    // Typing the rest at human key rate must stay a command, not a paste.
+    await session.sendKeys('help');
+    await session.pressEnter();
+    await session.waitFor(/Available commands|\/cost|\/clear/i, 20_000);
+    expect(session.snapshot()).not.toContain('[Pasted text');
+  }, 60_000);
+
+  it('TC-08: /exit reaches process exit within 10s', async () => {
+    session = spawnTui({ projectDir, homeDir: join(projectDir, 'home') });
+    await session.waitFor(/Type a message or \/help/);
+
+    await session.sendKeys('/exit');
+    await session.pressEnter();
+
+    const exitCode = await session.expectExit(10_000);
+    expect(exitCode).toBe(0);
+  }, 60_000);
+});

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

@@ -0,0 +1,32 @@
+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__/session-init-poller.test.ts

@@ -0,0 +1,102 @@
+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-switch-channel.test.tsx

@@ -0,0 +1,307 @@
+/**
+ * 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);
+  });
+});

package/src/tui/__tests__/slash-routing-effects.test.ts

@@ -9,7 +9,10 @@ import {
   BundlePluginLoader,
   PluginCommandSource,
 } from '@robota-sdk/agent-framework';
-import type { ICommandInteraction, IInteractiveSession } from '@robota-sdk/agent-framework';
+import type {
+  ICommandInteraction,
+  IInteractiveSession,
+} from '@robota-sdk/agent-interface-transport';
 import { TuiStateManager } from '../tui-state-manager.js';
 import { applySystemCommandResult } from '../hooks/useSlashRouting.js';
 import { CommandEffectQueue } from '../hooks/command-effect-queue.js';

package/src/tui/__tests__/status-activity.test.ts

@@ -11,10 +11,10 @@ describe('formatStatusActivity', () => {
     });
 
     expect(activity.kind).toBe('tools');
-    expect(activity.label).toBe('Tools x2');
+    expect(activity.label).toBe('Tools (2)');
     expect(activity.color).toBe('cyan');
     expect(activity.segments).toEqual(['queued']);
-    expect(activity.text).toBe('Tools x2 · queued');
+    expect(activity.text).toBe('Tools (2) · queued');
   });
 
   it('shows thinking as the primary model waiting state', () => {
@@ -39,7 +39,7 @@ describe('formatStatusActivity', () => {
     });
 
     expect(activity.kind).toBe('background');
-    expect(activity.label).toBe('Background x1');
+    expect(activity.label).toBe('Background (1)');
     expect(activity.color).toBe('cyan');
   });