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

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');
   });
 

package/src/tui/__tests__/status-bar.test.tsx

@@ -109,18 +109,19 @@ describe('StatusBar', () => {
     );
     const frame = lastFrame()!;
     expect(frame).not.toContain('Activity:');
-    expect(frame).toContain('Tools x2');
+    expect(frame).toContain('Tools (2)');
+    expect(frame).not.toContain('Tools x2');
     expect(frame).toContain('queued');
     expect(frame).not.toContain('thinking...');
-    expect(frame.indexOf('Tools x2')).toBeLessThan(frame.indexOf('test-model'));
+    expect(frame.indexOf('Tools (2)')).toBeLessThan(frame.indexOf('test-model'));
     expect(frame).not.toContain('Thinking...');
   });
 
   it('shows background activity when no foreground execution is active', () => {
     const { lastFrame } = render(<StatusBar {...baseProps} activeBackgroundTaskCount={3} />);
     const frame = lastFrame()!;
-    expect(frame).toContain('Background x3');
-    expect(frame.indexOf('Background x3')).toBeLessThan(frame.indexOf('test-model'));
+    expect(frame).toContain('Background (3)');
+    expect(frame.indexOf('Background (3)')).toBeLessThan(frame.indexOf('test-model'));
   });
 
   it('keeps the activity segment compact for narrow terminals', () => {
@@ -137,7 +138,7 @@ describe('StatusBar', () => {
     const firstLine = frame.split('\n')[0] ?? '';
     const activityEnd = firstLine.indexOf('test-model');
     const activitySegment = firstLine.slice(0, activityEnd);
-    expect(activitySegment).toContain('Tools x12');
+    expect(activitySegment).toContain('Tools (12)');
     expect(activitySegment.length).toBeLessThanOrEqual(40);
   });
 

package/src/tui/__tests__/tui-channel-init-failure.test.ts

@@ -0,0 +1,57 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IAIProvider } from '@robota-sdk/agent-core';
+
+vi.mock('@robota-sdk/agent-framework', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('@robota-sdk/agent-framework')>();
+
+  class FakeInteractiveSession {
+    on(): void {}
+    off(): void {}
+    getFullHistory(): unknown[] {
+      return [];
+    }
+    getContextState(): never {
+      throw new Error('ENOENT: session store unreadable');
+    }
+    getName(): string | undefined {
+      return undefined;
+    }
+    getSession(): { getSessionId: () => string } {
+      return { getSessionId: () => 'test-session' };
+    }
+    async shutdown(): Promise<void> {}
+  }
+
+  return { ...mod, InteractiveSession: FakeInteractiveSession };
+});
+
+import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
+
+describe('TuiInteractionChannel init failure surfacing', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('TC-05: a real init error records a session-init-error entry and sets error state', async () => {
+    const channel = new TuiInteractionChannel({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+    });
+    await channel.start();
+
+    vi.advanceTimersByTime(400);
+
+    const entries = channel.stateManager.history;
+    const initError = entries.find((e) => e.type === 'session-init-error');
+    expect(initError).toBeDefined();
+    const message = (initError?.data as { message?: string } | undefined)?.message ?? '';
+    expect(message).toContain('Session initialization failed');
+    expect(message).toContain('ENOENT');
+
+    await channel.stop();
+  });
+});

package/src/tui/__tests__/tui-state-manager.test.ts

@@ -5,7 +5,7 @@
 
 import { describe, it, expect, vi } from 'vitest';
 import { TuiStateManager } from '../tui-state-manager.js';
-import type { IToolState, IExecutionResult } from '@robota-sdk/agent-framework';
+import type { IExecutionResult, IToolState } from '@robota-sdk/agent-interface-transport';
 
 function makeResult(overrides?: Partial<IExecutionResult>): IExecutionResult {
   return {

package/src/tui/background-task-row-format.ts

@@ -1,6 +1,6 @@
 import { formatExecutionWorkspaceEntryRow } from './execution-workspace-view-model.js';
 
-import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-framework';
+import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-interface-transport';
 
 export interface IBackgroundTaskRow {
   connector: '├' | '└';

package/src/tui/execution-workspace-view-model.ts

@@ -3,7 +3,7 @@ import type {
   IExecutionWorkspaceEntry,
   IExecutionWorkspaceSnapshot,
   TExecutionWorkspaceStatus,
-} from '@robota-sdk/agent-framework';
+} from '@robota-sdk/agent-interface-transport';
 
 const ACTIVE_STATUSES: readonly TExecutionWorkspaceStatus[] = [
   'active',

package/src/tui/flows/input-area-flow.ts

@@ -1,7 +1,7 @@
 import { isSlashCommand, tokeniseSlashCommand } from '@robota-sdk/agent-framework';
 
 import type { IHistoryEntry, TUniversalValue } from '@robota-sdk/agent-core';
-import type { ICommand } from '@robota-sdk/agent-framework';
+import type { ICommand } from '@robota-sdk/agent-interface-transport';
 
 export interface IAutocompleteInputKey {
   upArrow?: boolean;

package/src/tui/flows/permission-prompt-flow.ts

@@ -67,7 +67,7 @@ export function applyPermissionPromptInput(
   };
 }
 
-export function getPermissionDecision(index: number): TPermissionPromptDecision {
+function getPermissionDecision(index: number): TPermissionPromptDecision {
   if (index === 0) return true;
   if (index === 1) return 'allow-session';
   if (index === 2) return 'allow-project';