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

package/src/tui/SlashAutocomplete.tsx

@@ -1,7 +1,7 @@
 import { Box, Text, useStdout } from 'ink';
 import React, { useState, useEffect } from 'react';
 
-import type { ICommand } from '@robota-sdk/agent-framework';
+import type { ICommand } from '@robota-sdk/agent-interface-transport';
 
 interface IProps {
   /** Filtered list of commands to display */

package/src/tui/StreamingIndicator.tsx

@@ -9,7 +9,7 @@ import React from 'react';
 import { renderMarkdown } from './render-markdown.js';
 import ToolDiffBlock from './ToolDiffBlock.js';
 
-import type { IToolState } from '@robota-sdk/agent-framework';
+import type { IToolState } from '@robota-sdk/agent-interface-transport';
 
 function getToolStyle(t: IToolState): {
   color: string;

package/src/tui/TransportTUI.tsx

@@ -7,8 +7,8 @@
 import { Box, Text, useInput } from 'ink';
 import React, { useState, useCallback } from 'react';
 
-import type { IInteractiveSession } from '@robota-sdk/agent-framework';
 import type {
+  IInteractiveSession,
   ITransportEntry,
   ITransportRegistryView,
 } from '@robota-sdk/agent-interface-transport';

package/src/tui/TuiInteractionChannel.ts

@@ -12,37 +12,40 @@ import {
 } from '@robota-sdk/agent-core';
 import { InteractiveSession, CommandRegistry } from '@robota-sdk/agent-framework';
 
+import { createSessionInitPoller } from './flows/session-init-poller.js';
 import { CommandEffectQueue, type ICommandEffectQueue } from './hooks/command-effect-queue.js';
 import { applySystemCommandResult } from './hooks/useSlashRouting.js';
 import { generateSessionName } from './session-naming.js';
 import { TuiStateManager } from './tui-state-manager.js';
 
+import type { ISessionInitPoller, TSessionInitFailure } from './flows/session-init-poller.js';
 import type { IPermissionRequest } from './types.js';
 import type { IAIProvider, TPermissionMode, TSessionEndReason } from '@robota-sdk/agent-core';
 import type { TToolArgs } from '@robota-sdk/agent-core';
-import type { IInteractionChannel } from '@robota-sdk/agent-framework';
-import type {
-  InteractionEvent,
-  IActionRequest,
-  IActionResponse,
-  ICommandInfo,
-} from '@robota-sdk/agent-framework';
 import type {
   IBackgroundTaskRunner,
   ICommandHostAdapters,
   ICommandModule,
-  IInteractiveSession,
-  IInteractiveSessionStore,
   TSubagentRunnerFactory,
-  IExecutionWorkspaceEvent,
-  IExecutionDetailPage,
-  IExecutionResult,
   TShellExecFn,
 } from '@robota-sdk/agent-framework';
-import type { TPermissionResultValue } from '@robota-sdk/agent-framework';
-import type { ITransportRegistryView } from '@robota-sdk/agent-interface-transport';
+import type {
+  IActionRequest,
+  IActionResponse,
+  ICommandInfo,
+  IExecutionDetailPage,
+  IExecutionResult,
+  IExecutionWorkspaceEvent,
+  IInteractionChannel,
+  IInteractiveSession,
+  IInteractiveSessionStore,
+  ITransportRegistryView,
+  InteractionEvent,
+  TPermissionResultValue,
+} from '@robota-sdk/agent-interface-transport';
 
 const SESSION_INIT_POLL_MS = 200;
+const SESSION_INIT_TIMEOUT_MS = 15000;
 
 export interface ITuiInteractionChannelOptions {
   cwd: string;
@@ -92,7 +95,7 @@ export class TuiInteractionChannel implements IInteractionChannel {
 
   private autoNameTriggered = false;
   private sessionStarted = false;
-  private initCheckInterval: ReturnType<typeof setInterval> | null = null;
+  private initPoller: ISessionInitPoller | null = null;
   private permissionQueue: Array<{
     toolName: string;
     toolArgs: TToolArgs;
@@ -369,6 +372,9 @@ export class TuiInteractionChannel implements IInteractionChannel {
     const onSkillActivation = (): void => {
       manager.syncHistory(session.getFullHistory());
     };
+    const onMemoryEvent = (): void => {
+      manager.syncHistory(session.getFullHistory());
+    };
     const onExecutionWorkspaceEvent = (event: IExecutionWorkspaceEvent): void => {
       manager.syncExecutionWorkspaceSnapshot(event.snapshot);
     };
@@ -384,6 +390,7 @@ export class TuiInteractionChannel implements IInteractionChannel {
     session.on('context_update', manager.onContextUpdate);
     session.on('compact', onCompact);
     session.on('skill_activation', onSkillActivation);
+    session.on('memory_event', onMemoryEvent);
     session.on('execution_workspace_event', onExecutionWorkspaceEvent);
   }
 
@@ -413,36 +420,51 @@ export class TuiInteractionChannel implements IInteractionChannel {
   }
 
   private startInitCheck(): void {
-    this.initCheckInterval = setInterval(() => {
-      this.runInitCheck();
-    }, SESSION_INIT_POLL_MS);
+    this.initPoller = createSessionInitPoller({
+      check: () => this.runInitCheck(),
+      intervalMs: SESSION_INIT_POLL_MS,
+      timeoutMs: SESSION_INIT_TIMEOUT_MS,
+      onReady: () => undefined,
+      onFailure: (failure) => this.onInitFailure(failure),
+    });
+    this.initPoller.start();
   }
 
+  /** Throws while the session is not ready; the init poller classifies the error. */
   private runInitCheck(): void {
-    try {
-      const ctx = this.interactiveSession.getContextState();
-      this.stateManager.setContextState({
-        percentage: ctx.usedPercentage,
-        usedTokens: ctx.usedTokens,
-        maxTokens: ctx.maxTokens,
-      });
-      const restored = this.interactiveSession.getFullHistory();
-      if (restored.length > 0) {
-        this.stateManager.syncHistory(restored);
-      }
-      this.syncExecutionWorkspace();
-      this.stopInitCheck();
-    } catch {
-      // allow-fallback: session initializes asynchronously; poll until ready
-      /* Not yet initialized */
+    const ctx = this.interactiveSession.getContextState();
+    this.stateManager.setContextState({
+      percentage: ctx.usedPercentage,
+      usedTokens: ctx.usedTokens,
+      maxTokens: ctx.maxTokens,
+    });
+    const restored = this.interactiveSession.getFullHistory();
+    if (restored.length > 0) {
+      this.stateManager.syncHistory(restored);
     }
+    this.syncExecutionWorkspace();
+  }
+
+  private onInitFailure(failure: TSessionInitFailure): void {
+    const message =
+      failure.kind === 'timeout'
+        ? `Session initialization timed out after ${SESSION_INIT_TIMEOUT_MS / 1000}s${
+            failure.lastError ? ` (last error: ${failure.lastError.message})` : ''
+          }`
+        : `Session initialization failed: ${failure.error.message}`;
+    this.stateManager.onError();
+    this.stateManager.addEntry({
+      id: `session-init-error-${Date.now()}`,
+      timestamp: new Date(),
+      category: 'event',
+      type: 'session-init-error',
+      data: { message },
+    });
   }
 
   private stopInitCheck(): void {
-    if (this.initCheckInterval !== null) {
-      clearInterval(this.initCheckInterval);
-      this.initCheckInterval = null;
-    }
+    this.initPoller?.stop();
+    this.initPoller = null;
   }
 
   private syncExecutionWorkspace(): void {

package/src/tui/UsageSummaryEntry.tsx

@@ -3,7 +3,7 @@ import { Box, Text } from 'ink';
 import React from 'react';
 
 import type { IHistoryEntry } from '@robota-sdk/agent-core';
-import type { IUsageSnapshot } from '@robota-sdk/agent-framework';
+import type { IUsageSnapshot } from '@robota-sdk/agent-interface-transport';
 
 const TOKEN_COMPACT_THRESHOLD = 1000;
 

package/src/tui/__tests__/PluginTUI.test.tsx

@@ -3,7 +3,7 @@ import React from 'react';
 import { render } from 'ink-testing-library';
 import { describe, it, expect, vi } from 'vitest';
 import PluginTUI from '../PluginTUI.js';
-import type { ICommandPluginAdapter } from '@robota-sdk/agent-framework';
+import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-transport';
 
 function mockCallbacks(): ICommandPluginAdapter {
   return {

package/src/tui/__tests__/SlashAutocomplete.test.tsx

@@ -2,7 +2,7 @@ import React from 'react';
 import { render } from 'ink-testing-library';
 import { describe, it, expect } from 'vitest';
 import SlashAutocomplete from '../SlashAutocomplete.js';
-import type { ICommand } from '@robota-sdk/agent-framework';
+import type { ICommand } from '@robota-sdk/agent-interface-transport';
 
 // ink-testing-library fixes stdout.columns = 100
 // outer box chrome = 4 → rowWidth = 96 in tests

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

@@ -68,7 +68,7 @@ import {
 import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
 
 import type { IAIProvider, IHistoryEntry } from '@robota-sdk/agent-core';
-import type { IExecutionResult } from '@robota-sdk/agent-framework';
+import type { IExecutionResult } from '@robota-sdk/agent-interface-transport';
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 

package/src/tui/__tests__/TuiInteractionChannel.lifecycle.test.ts

@@ -53,8 +53,11 @@ vi.mock('@robota-sdk/agent-framework', async () => {
 import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
 
 import type { IAIProvider } from '@robota-sdk/agent-core';
-import type { IExecutionResult, IInteractiveSession } from '@robota-sdk/agent-framework';
-import type { ITransportRegistryView } from '@robota-sdk/agent-interface-transport';
+import type {
+  IExecutionResult,
+  IInteractiveSession,
+  ITransportRegistryView,
+} from '@robota-sdk/agent-interface-transport';
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 

package/src/tui/__tests__/TuiInteractionChannel.requestAction.test.ts

@@ -29,7 +29,7 @@ vi.mock('@robota-sdk/agent-framework', async () => {
 import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
 
 import type { IAIProvider } from '@robota-sdk/agent-core';
-import type { IActionRequest } from '@robota-sdk/agent-framework';
+import type { IActionRequest } from '@robota-sdk/agent-interface-transport';
 
 function makeChannel(): TuiInteractionChannel {
   return new TuiInteractionChannel({

package/src/tui/__tests__/background-task-panel.test.tsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import { describe, expect, it } from 'vitest';
 import { render } from 'ink-testing-library';
-import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-framework';
+import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-interface-transport';
 import BackgroundTaskPanel from '../BackgroundTaskPanel.js';
 
 function makeEntry(overrides: Partial<IExecutionWorkspaceEntry>): IExecutionWorkspaceEntry {

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-framework';
+import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-interface-transport';
 import { formatBackgroundTaskRow } from '../background-task-row-format.js';
 
 function makeEntry(overrides: Partial<IExecutionWorkspaceEntry>): IExecutionWorkspaceEntry {

package/src/tui/__tests__/channel-factory-integration.test.ts

@@ -0,0 +1,138 @@
+/**
+ * CLI-B11 TC-02: real-store channel factory integration.
+ *
+ * The official CI equivalent of real-resume-verify-v3.mjs: build the channel
+ * exactly the way render.tsx does (toChannelOptions + TuiInteractionChannel)
+ * over a REAL project session store with a persisted conversation, and assert
+ * the restored model context is non-empty. No store/session mocks.
+ */
+
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { createProjectSessionStore } from '@robota-sdk/agent-framework';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { createScriptedProvider } from '../../testing/scripted-provider.js';
+import { toChannelOptions, type IRenderOptions } from '../render.js';
+import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
+
+import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
+import type { TUniversalMessage } from '@robota-sdk/agent-core';
+import type { IInteractiveSessionStore } from '@robota-sdk/agent-interface-transport';
+
+const RESTORE_DEADLINE_MS = 10_000;
+const POLL_MS = 50;
+
+function fakeCliAdapter(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),
+  };
+}
+
+function persistConversation(store: IInteractiveSessionStore, id: string, cwd: string): void {
+  const messages: TUniversalMessage[] = [
+    { role: 'user', content: 'Remember the number 42.' } as TUniversalMessage,
+    { role: 'assistant', content: 'Noted: 42.' } as TUniversalMessage,
+    { role: 'user', content: 'And the city is Busan.' } as TUniversalMessage,
+    { role: 'assistant', content: 'Noted: Busan.' } as TUniversalMessage,
+  ];
+  store.save({
+    id,
+    cwd,
+    createdAt: '2026-06-13T00:00:00.000Z',
+    updatedAt: '2026-06-13T00:00:00.000Z',
+    messages,
+  });
+}
+
+describe('channel factory restores persisted context (CLI-B11 TC-02)', () => {
+  let cwd: string;
+  let channel: TuiInteractionChannel | undefined;
+
+  beforeEach(() => {
+    cwd = mkdtempSync(join(tmpdir(), 'robota-b11-int-'));
+  });
+
+  afterEach(async () => {
+    await channel?.stop();
+    channel = undefined;
+    rmSync(cwd, { recursive: true, force: true });
+  });
+
+  it('createChannel(sessionId) over a real FileSessionStore yields usedTokens > 0', async () => {
+    const store = createProjectSessionStore(cwd);
+    const sessionId = 'b11-restore-session';
+    persistConversation(store, sessionId, cwd);
+
+    // Exactly the render.tsx factory: toChannelOptions(options, resumeSessionId).
+    const scripted = createScriptedProvider([{ text: 'unused in this test' }]);
+    const options: IRenderOptions = {
+      cwd,
+      provider: scripted.provider,
+      sessionStore: store,
+      cliAdapter: fakeCliAdapter(join(cwd, 'settings.json')),
+    };
+    channel = new TuiInteractionChannel(toChannelOptions(options, sessionId));
+    await channel.start();
+
+    // Restoration is asynchronous (pendingRestoreMessages inject after init).
+    const deadline = Date.now() + RESTORE_DEADLINE_MS;
+    let usedTokens = 0;
+    while (Date.now() < deadline) {
+      try {
+        // allow-fallback: session init is asynchronous; poll until it is ready
+        usedTokens = channel.getSession().getContextState().usedTokens;
+        if (usedTokens > 0) break;
+      } catch {
+        // allow-fallback: session init is asynchronous; poll until it is ready
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    }
+
+    // The persisted messages were injected into the model context — the exact
+    // signal that was 0 in the 2026-05-31 bug. (getFullHistory() is the display
+    // log restored from record.history, which this record intentionally omits.)
+    expect(usedTokens).toBeGreaterThan(0);
+  });
+
+  it('a channel created WITHOUT resumeSessionId starts with an empty context (control)', async () => {
+    const store = createProjectSessionStore(cwd);
+    persistConversation(store, 'b11-other-session', cwd);
+
+    const scripted = createScriptedProvider([{ text: 'unused' }]);
+    const options: IRenderOptions = {
+      cwd,
+      provider: scripted.provider,
+      sessionStore: store,
+      cliAdapter: fakeCliAdapter(join(cwd, 'settings.json')),
+    };
+    channel = new TuiInteractionChannel(toChannelOptions(options, undefined));
+    await channel.start();
+
+    const deadline = Date.now() + RESTORE_DEADLINE_MS;
+    let ready = false;
+    while (Date.now() < deadline && !ready) {
+      try {
+        // allow-fallback: session init is asynchronous; poll until it is ready
+        channel.getSession().getContextState();
+        ready = true;
+      } catch {
+        // allow-fallback: session init is asynchronous; poll until it is ready
+        await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+      }
+    }
+
+    expect(ready).toBe(true);
+    expect(channel.getSession().getFullHistory()).toHaveLength(0);
+  });
+});

package/src/tui/__tests__/execution-workspace-switcher.test.tsx

@@ -4,7 +4,7 @@ import { render } from 'ink-testing-library';
 import type {
   IExecutionWorkspaceEntry,
   IExecutionWorkspaceSnapshot,
-} from '@robota-sdk/agent-framework';
+} from '@robota-sdk/agent-interface-transport';
 import ExecutionWorkspaceSwitcher from '../ExecutionWorkspaceSwitcher.js';
 import ExecutionWorkspaceDetailPane from '../ExecutionWorkspaceDetailPane.js';
 

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

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest';
 import type {
   IExecutionWorkspaceEntry,
   IExecutionWorkspaceSnapshot,
-} from '@robota-sdk/agent-framework';
+} from '@robota-sdk/agent-interface-transport';
 import {
   countActiveBackgroundWorkspaceEntries,
   formatExecutionDetailRecord,

package/src/tui/__tests__/fixtures/provider-setup-prompt-driver.tsx

@@ -15,7 +15,7 @@ import React from 'react';
 import InteractivePrompt from '../../InteractivePrompt.js';
 
 import type { IAIProvider, IProviderDefinition } from '@robota-sdk/agent-core';
-import type { TCommandInteractionPrompt as TInteractivePrompt } from '@robota-sdk/agent-framework';
+import type { TCommandInteractionPrompt as TInteractivePrompt } from '@robota-sdk/agent-interface-transport';
 
 const openaiDefaults = {
   apiKey: '$ENV:OPENAI_API_KEY',

package/src/tui/__tests__/input-area-flow.test.ts

@@ -13,7 +13,7 @@ import {
   resolveTabCompletion,
   shouldSubmitInput,
 } from '../flows/input-area-flow.js';
-import type { ICommand } from '@robota-sdk/agent-framework';
+import type { ICommand } from '@robota-sdk/agent-interface-transport';
 import {
   createAssistantMessage,
   createSystemMessage,

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