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

package/src/__tests__/pty/screen-005-prompt-footers.ptytest.ts

@@ -0,0 +1,135 @@
+/**
+ * SCREEN-005 User Execution Test Scenarios — prompt footers and key-hint affordance on the BUILT
+ * CLI binary in a real PTY (run by `test:pty`; requires `pnpm build:deps` first).
+ *
+ * Scenario 1: `/` opens the autocomplete → unified footer + `> ` indicator on the selected row.
+ * Scenario 2: a replayed model turn drives a CMD-004 ask in each shape (single-select,
+ *   multi-select with the dynamic `(min N)` segment, free-text) → all footers share the grammar.
+ * Scenario 3: a replayed Shell tool call opens the permission prompt → footer names the real keys
+ *   (`←→ Navigate · Enter Confirm`, no Esc); pressing Esc resolves nothing (documented hard-stop).
+ */
+
+import { mkdtempSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { spawnTui, writeTuiProviderSettings } from './pty-driver.js';
+import { formatKeyHints } from '../../key-hint-footer.js';
+import { LIST_PICKER_DEFAULT_FOOTER_HINTS } from '../../ListPicker.js';
+import { getMultiSelectFooterHints } from '../../MultiSelectList.js';
+import { PERMISSION_PROMPT_FOOTER_HINTS } from '../../PermissionPrompt.js';
+import { SLASH_AUTOCOMPLETE_FOOTER_HINTS } from '../../SlashAutocomplete.js';
+import { TEXT_PROMPT_FOOTER_HINTS } from '../../TextPrompt.js';
+
+import type { IPtySession } from './pty-driver.js';
+
+const FIXTURES = join(dirname(fileURLToPath(import.meta.url)), 'fixtures');
+const ASK_SHAPES_FIXTURE = join(FIXTURES, 'screen-005-ask-shapes.jsonl');
+const PERMISSION_FIXTURE = join(FIXTURES, 'screen-005-permission.jsonl');
+
+function escapeRegExp(text: string): RegExp {
+  return new RegExp(text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+}
+
+const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
+
+describe('SCREEN-005 prompt footers through the real binary', () => {
+  let projectDir: string;
+  let session: IPtySession | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'agent-screen005-pty-')));
+    writeTuiProviderSettings(projectDir);
+  });
+
+  afterEach(async () => {
+    await session?.disposeAsync();
+    session = undefined;
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('S1: slash autocomplete shows the unified footer and the > indicator on the selected row', async () => {
+    session = spawnTui({ projectDir, homeDir: join(projectDir, 'home') });
+    await session.waitFor(/Type a message or \/help/);
+
+    await session.sendKeys('/');
+    const expectedFooter = formatKeyHints(SLASH_AUTOCOMPLETE_FOOTER_HINTS);
+    await session.waitFor(escapeRegExp(expectedFooter), 20_000);
+
+    const frame = session.snapshot();
+    expect(frame).toContain(expectedFooter);
+    // The highlighted first row carries the selection indicator in front of the command name.
+    expect(frame).toMatch(/> \/\w+/);
+  }, 60_000);
+
+  it('S2: single-select, multi-select (dynamic min segment), and free-text asks share the grammar', async () => {
+    session = spawnTui({
+      projectDir,
+      homeDir: join(projectDir, 'home'),
+      args: ['--session-log', ASK_SHAPES_FIXTURE, '--name', 'shapes-fixture'],
+    });
+    await session.waitFor(/Type a message or \/help/);
+
+    await session.sendKeys('go');
+    await session.pressEnter();
+
+    // Shape 1 — single-select (ListPicker default footer).
+    await session.waitFor(/PICK_SINGLE/, 20_000);
+    await session.waitFor(escapeRegExp(formatKeyHints(LIST_PICKER_DEFAULT_FOOTER_HINTS)), 10_000);
+    expect(session.snapshot()).toContain('> Red'); // indicator on the highlighted option
+    await session.pressEnter(); // answer "Red"
+
+    // Shape 2 — multi-select: min segment shows until satisfiable, then drops.
+    await session.waitFor(/PICK_MULTI/, 20_000);
+    const unsatisfied = formatKeyHints(
+      getMultiSelectFooterHints({ canConfirm: false, minSelect: 1 }),
+    );
+    await session.waitFor(escapeRegExp(unsatisfied), 10_000);
+    const beforeToggle = session.outputOffset();
+    await session.sendKeys(' '); // toggle Alpha → selection satisfiable
+    const satisfied = formatKeyHints(getMultiSelectFooterHints({ canConfirm: true, minSelect: 1 }));
+    await session.waitForSince(beforeToggle, escapeRegExp(satisfied), 10_000);
+    await session.pressEnter(); // confirm
+
+    // Shape 3 — free-text (TextPrompt footer).
+    await session.waitFor(/TYPE_TEXT/, 20_000);
+    await session.waitFor(escapeRegExp(formatKeyHints(TEXT_PROMPT_FOOTER_HINTS)), 10_000);
+    await session.sendKeys('hello');
+    await session.pressEnter();
+
+    // The replayed follow-up proves every ask resolved through the shared-grammar prompts.
+    await session.waitFor(/ALL_SHAPES_DONE/, 20_000);
+  }, 60_000);
+
+  it('S3: permission prompt names the real keys and Esc resolves nothing (explicit hard-stop)', async () => {
+    session = spawnTui({
+      projectDir,
+      homeDir: join(projectDir, 'home'),
+      args: ['--session-log', PERMISSION_FIXTURE, '--name', 'perm-fixture'],
+    });
+    await session.waitFor(/Type a message or \/help/);
+
+    await session.sendKeys('go');
+    await session.pressEnter();
+
+    // The replayed Shell call needs approval in default permission mode → prompt renders.
+    await session.waitFor(/Permission Required/, 20_000);
+    const expectedFooter = formatKeyHints(PERMISSION_PROMPT_FOOTER_HINTS);
+    await session.waitFor(escapeRegExp(expectedFooter), 10_000);
+
+    // Esc is suppressed (a dismissal would be an implicit deny): nothing resolves, the prompt stays.
+    session.pressEscape();
+    await delay(500);
+    const afterEsc = session.snapshot();
+    expect(afterEsc).not.toContain('AFTER_PERMISSION_FLOW');
+    expect(afterEsc).toContain('Allow [y]'); // prompt still displayed, still unresolved
+
+    // Resolve explicitly (allow) once the prompt is armed → the tool runs and the turn continues.
+    await session.waitFor(/> Allow \[y\]/, 10_000);
+    await session.sendKeys('y');
+    await session.waitFor(/AFTER_PERMISSION_FLOW/, 20_000);
+  }, 60_000);
+});

package/src/__tests__/pty/screen-006-no-color.ptytest.ts

@@ -0,0 +1,140 @@
+/**
+ * SCREEN-006 User Execution Test Scenarios — color/motion degradation and palette-token colors on
+ * the BUILT CLI binary in a real PTY (run by `test:pty`; requires `pnpm build:deps` first).
+ *
+ * Scenario 1 (NO_COLOR legibility): `NO_COLOR=1` through a replayed conversation → the raw pty
+ *   transcript contains ZERO SGR color sequences (30-38/40-48/90-97/100-107 params, incl. 38;5 /
+ *   48;5 extended forms). Because NO color code may appear at all, this also proves the repeated
+ *   waiting-state frames show zero WaveText color churn (motion is static: the
+ *   `isInteractiveColorTerminal()` gate creates no interval under NO_COLOR).
+ * Scenario 2 (normal-run consistency): color on → the persisted tool summary renders the
+ *   `STATUS_SYMBOL.success` glyph in the resolved theme's status color (green, ESC[32m — sourced
+ *   from `colors.status` through `statusGlyphColor`), the assistant label renders the accent token
+ *   (cyan, ESC[36m), and the markdown diff block carries the theme's diff SGR pairs (38;5;120 on
+ *   48;5;22 for added lines under the default `dark` theme).
+ *   Reachability note (recorded limit): a permission DENY short-circuits before tool-start, so the
+ *   framework emits no tool-summary entry for it — the denied (`yellowBright`) unification is
+ *   therefore pinned at component level (`message-list-rendering.test.tsx`), while this scenario
+ *   evidences the same glyph→status-colour sourcing end-to-end via the success kind.
+ */
+
+import { mkdtempSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { spawnTui, writeTuiProviderSettings } from './pty-driver.js';
+import { DARK_THEME } from '../../theme/built-in-themes.js';
+import { background, foreground } from '../../theme/index.js';
+
+import type { IPtySession } from './pty-driver.js';
+
+const FIXTURES = join(dirname(fileURLToPath(import.meta.url)), 'fixtures');
+const REPLAY_FIXTURE = join(FIXTURES, 'replay-conversation.jsonl');
+const COLORS_FIXTURE = join(FIXTURES, 'screen-006-colors.jsonl');
+
+/** SGR params that set a color (foreground/background, basic/bright/extended). */
+const COLOR_PARAM = /^(?:3[0-8]|39|4[0-8]|49|9[0-7]|10[0-7])$/;
+
+/** Every SGR color param present in a raw pty transcript (e.g. ['33', '38;5;210'→'38']). */
+function sgrColorParams(raw: string): string[] {
+  const params: string[] = [];
+  // eslint-disable-next-line no-control-regex -- scanning raw SGR escape bytes by design
+  for (const match of raw.matchAll(/\x1b\[([0-9;]*)m/g)) {
+    // In an extended sequence (38;5;n / 48;5;n) the payload params are not themselves
+    // color-setters, but the leading 38/48 is — flagging it is sufficient and exact.
+    for (const param of (match[1] === '' ? '0' : match[1]).split(';')) {
+      if (COLOR_PARAM.test(param)) {
+        params.push(param);
+        break; // one flagged param per sequence is enough evidence
+      }
+    }
+  }
+  return params;
+}
+
+describe('SCREEN-006 color/motion through the real binary', () => {
+  let projectDir: string;
+  let session: IPtySession | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'agent-screen006-pty-')));
+    writeTuiProviderSettings(projectDir);
+  });
+
+  afterEach(async () => {
+    await session?.disposeAsync();
+    session = undefined;
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('S1: NO_COLOR=1 → legible output, zero SGR color sequences, no animation', async () => {
+    session = spawnTui({
+      projectDir,
+      homeDir: join(projectDir, 'home'),
+      args: ['--session-log', REPLAY_FIXTURE],
+      env: { NO_COLOR: '1' },
+    });
+
+    await session.waitFor(/Type a message or \/help/);
+    await session.sendKeys('hello');
+    await session.pressEnter();
+
+    // The replayed turn completes and the output stays legible (content + labels present).
+    await session.waitFor(/REPLAYED_ANSWER_42/, 20_000);
+    await session.waitFor(/Type a message or \/help/, 20_000);
+
+    const stripped = session.snapshot();
+    expect(stripped).toContain('You:');
+    expect(stripped).toContain('REPLAYED_ANSWER_42');
+
+    // Zero SGR color sequences in the ENTIRE raw transcript — which also proves the
+    // waiting-state (WaveText) frames carried zero color churn under NO_COLOR.
+    expect(sgrColorParams(session.raw())).toEqual([]);
+  }, 60_000);
+
+  it('S2: color on → tool summary uses the themes status color, labels use accent, diff uses the themes pairs', async () => {
+    session = spawnTui({
+      projectDir,
+      homeDir: join(projectDir, 'home'),
+      args: ['--session-log', COLORS_FIXTURE],
+    });
+
+    await session.waitFor(/Type a message or \/help/);
+    await session.sendKeys('go');
+    await session.pressEnter();
+
+    // The replayed Shell call needs approval in default permission mode → allow it.
+    await session.waitFor(/Permission Required/, 20_000);
+    // Its keys answer once it is armed, which the selection cursor shows.
+    await session.waitFor(/> Allow \[y\]/, 10_000);
+    await session.sendKeys('y');
+
+    // The turn continues: the second replayed response carries the markdown diff block,
+    // and the persisted tool summary lands at turn end.
+    await session.waitFor(/SCREEN006_DIFF_DONE/, 20_000);
+    await session.waitFor(/✓ Shell/, 10_000);
+
+    const stripped = session.snapshot();
+    const raw = session.raw();
+
+    // Persisted tool summary: SSOT glyph + the theme's status colour (success → green, ESC[32m)
+    // rendered by the unified MessageList path (STATUS_SYMBOL + statusGlyphColor).
+    expect(stripped).toContain('✓ Shell');
+    // eslint-disable-next-line no-control-regex -- asserting on raw SGR escape bytes by design
+    expect(raw).toMatch(/\x1b\[32m[^\x1b]*✓ Shell/);
+
+    // Assistant label renders the accent token (cyan → ESC[36m ... "Fixture Agent:").
+    // eslint-disable-next-line no-control-regex -- asserting on raw SGR escape bytes by design
+    expect(raw).toMatch(/\x1b\[36m(?:\x1b\[[0-9;]*m)*Fixture Agent:/);
+
+    // Markdown diff block carries the resolved theme's SGR pair (added line: light green on a dark
+    // green background) — SCREEN-2002 moved the values into the theme, the bytes are unchanged.
+    const addedBackground = background(DARK_THEME.markdown.diffAddedBackground)('x').split('x')[0];
+    const addedForeground = foreground(DARK_THEME.markdown.diffAdded)('x').split('x')[0];
+    expect(raw).toContain(`${addedBackground}${addedForeground}`);
+    expect(stripped).toContain('+ added line');
+  }, 60_000);
+});

package/src/__tests__/pty/screen-010-scrollback.ptytest.ts

@@ -0,0 +1,123 @@
+/**
+ * SCREEN-010 TC-05: chat-window scrollback layout, on the real binary.
+ *
+ * Runs in the PTY vitest project against the BUILT CLI. Automates the former "manual" smoke
+ * (per the never-ask-the-user-to-test rule): generates committed output larger than a small viewport
+ * and asserts the committed history is emitted to the terminal's native scrollback while the input
+ * prompt + status bar stay pinned at the bottom. Once committed content is in scrollback and the input
+ * is pinned, native terminal scroll-back is the terminal's own behavior (not the app's), so this is
+ * the automatable essence of TC-05.
+ *
+ * CLI-2004 TC-22 adds the same proof under `--screen-reader`. Ink's `alternateScreen` defaults to
+ * false and nothing in the tree sets it — this is the GUARD on that, not new behaviour: the
+ * alternate screen has no scrollback, and reviewing earlier output is the whole reason a reader can
+ * use this TUI at all. The flagless case above cannot serve as the guard, because it asserts on the
+ * boot banner and on `Idle`, both of which the mode suppresses.
+ */
+
+import { mkdtempSync, rmSync, realpathSync } 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';
+
+/**
+ * The heading of the COMMITTED `/help` output, and the reason it is this precise.
+ *
+ * `Available commands` without the colon is also `/help`'s own DESCRIPTION, which the slash
+ * autocomplete renders while the command is still being typed — four times over, before Enter is
+ * handled at all. Waiting on that returns immediately and leaves the snapshot below racing the
+ * commit; the case then asserts "the prompt is below the committed output" against a frame in which
+ * nothing has been committed yet. It passed only because the commit usually won that race, and a
+ * loaded runner is where it does not. The colon appears only in the committed block.
+ */
+const COMMITTED_HELP_HEADING = /Available commands:/;
+
+/** Wait budgets: one `waitFor`, and a whole case, on a loaded CI runner. */
+const PROMPT_WAIT_MS = 30_000;
+const COMMANDS_WAIT_MS = 20_000;
+const CASE_TIMEOUT_MS = 60_000;
+
+describe('SCREEN-010 chat-window scrollback layout (real binary)', () => {
+  let projectDir: string;
+  let session: IPtySession | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'agent-scrollback-pty-')));
+    writeTuiProviderSettings(projectDir);
+  });
+
+  afterEach(async () => {
+    await session?.disposeAsync();
+    session = undefined;
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it(
+    'TC-05: committed history fills scrollback beyond the viewport while the input stays pinned',
+    async () => {
+      // Small viewport so the committed /help output exceeds it and scrolls into scrollback.
+      session = spawnTui({ projectDir, homeDir: join(projectDir, 'home'), rows: 16 });
+
+      await session.waitFor(/Type a message or \/help/);
+      await session.waitFor(/Idle/);
+
+      // /help commits a long command list (> 16 rows) to history → Ink <Static> → scrollback.
+      await session.sendKeys('/help');
+      await session.pressEnter();
+      await session.waitFor(COMMITTED_HELP_HEADING, COMMANDS_WAIT_MS);
+
+      const snap = session.snapshot();
+
+      // Committed content is present (emitted to scrollback), and the banner committed at boot remains.
+      const committedIdx = snap.search(COMMITTED_HELP_HEADING);
+      expect(committedIdx).toBeGreaterThanOrEqual(0);
+      expect((snap.match(/v\d+\.\d+\.\d+/g) ?? []).length).toBeGreaterThanOrEqual(1);
+
+      // The input prompt re-renders at the BOTTOM (live region): its last occurrence is below the
+      // committed command-list output — i.e. the input is pinned while committed history sits above it.
+      const lastPromptIdx = snap.lastIndexOf('Type a message');
+      expect(lastPromptIdx).toBeGreaterThan(committedIdx);
+
+      // The status bar is also pinned in the live region.
+      expect(snap.lastIndexOf('Idle')).toBeGreaterThan(committedIdx);
+    },
+    CASE_TIMEOUT_MS,
+  );
+
+  it(
+    'CLI-2004 TC-22: --screen-reader never switches to the alternate screen and keeps history in scrollback',
+    async () => {
+      session = spawnTui({
+        projectDir,
+        homeDir: join(projectDir, 'home'),
+        rows: 16,
+        args: ['--screen-reader'],
+        env: { PRODUCT_SCREEN_READER_STARTUP_QUIET_MS: '0' },
+      });
+
+      await session.waitFor(/Type a message or \/help/, PROMPT_WAIT_MS);
+
+      await session.sendKeys('/help');
+      await session.pressEnter();
+      await session.waitFor(/Available commands|\/exit/i, COMMANDS_WAIT_MS);
+
+      // No alternate-screen switch at ANY point in the run — the mode must not buy a tidy frame at
+      // the price of the terminal's own scrollback.
+      expect(session.raw()).not.toContain('\x1b[?1049h');
+
+      const snap = session.snapshot();
+      const committedIdx = snap.search(/Available commands|\/exit/i);
+      expect(committedIdx).toBeGreaterThanOrEqual(0);
+
+      // The input stays pinned below the committed history — asserted without the banner or `Idle`,
+      // which the mode suppresses.
+      expect(snap.lastIndexOf('Type a message')).toBeGreaterThan(committedIdx);
+    },
+    CASE_TIMEOUT_MS,
+  );
+});

package/src/__tests__/pty/screen-1993-scrollback.ptytest.ts

@@ -0,0 +1,124 @@
+/**
+ * SCREEN-1993 TC-10: the transcript decision's evidence, on the real binary.
+ *
+ * The item asked for a way to "search prompt history and conversation transcripts"; the spec ships
+ * prompt-history search and REJECTS an in-app transcript viewer because the terminal's own scrollback
+ * already holds the whole transcript (`<Static>` commits every message, and nothing ever switches to
+ * the alternate screen, which has no scrollback). That reason is only as good as its proof: resume a
+ * persisted session of more than 100 messages in a small viewport and assert every message text is
+ * in the captured output without a single key pressed — and that `ESC [ ? 1049 h` never appears.
+ */
+
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } 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';
+
+const SESSION_ID = 'screen-1993-transcript';
+const TURNS = 60; // 120 messages: 60 user prompts and 60 assistant replies
+const PROMPT_WAIT_MS = 30_000;
+const FIXTURE_YEAR = 2026;
+const CASE_TIMEOUT_MS = 90_000;
+
+function messageText(index: number, role: 'user' | 'assistant'): string {
+  return role === 'user'
+    ? `transcript prompt ${index} of ${TURNS}`
+    : `transcript reply ${index} of ${TURNS}`;
+}
+
+/** A persisted session in the store's versioned envelope: `messages` for the model, `history` for the UI. */
+function seedSession(homeDir: string, cwd: string): void {
+  const at = (index: number): string =>
+    new Date(Date.UTC(FIXTURE_YEAR, 0, 1, 0, 0, index)).toISOString();
+  const messages = [];
+  const history = [];
+  for (let index = 1; index <= TURNS; index += 1) {
+    for (const role of ['user', 'assistant'] as const) {
+      const content = messageText(index, role);
+      messages.push({
+        id: `m-${role}-${index}`,
+        timestamp: at(index),
+        state: 'complete',
+        role,
+        content,
+      });
+      history.push({
+        id: `${role}-${index}`,
+        timestamp: at(index),
+        category: 'chat',
+        type: role,
+        data: { role, content },
+      });
+    }
+  }
+  const sessionsDir = join(homeDir, 'state', 'sessions');
+  mkdirSync(sessionsDir, { recursive: true });
+  writeFileSync(
+    join(sessionsDir, `${SESSION_ID}.json`),
+    JSON.stringify({
+      schemaVersion: 1,
+      record: {
+        id: SESSION_ID,
+        name: 'transcript-fixture',
+        cwd,
+        createdAt: at(0),
+        updatedAt: at(TURNS),
+        messages,
+        history,
+      },
+    }),
+    'utf8',
+  );
+}
+
+describe('SCREEN-1993 TC-10: the resumed transcript lives in native scrollback', () => {
+  let projectDir: string;
+  let session: IPtySession | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'agent-1993-scrollback-')));
+    writeTuiProviderSettings(projectDir);
+    seedSession(join(projectDir, 'home'), projectDir);
+  });
+
+  afterEach(async () => {
+    await session?.disposeAsync();
+    session = undefined;
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it(
+    'every one of 120 restored messages is in the terminal output with no key pressed, and no alternate screen',
+    async () => {
+      session = spawnTui({
+        projectDir,
+        homeDir: join(projectDir, 'home'),
+        rows: 16,
+        args: ['--resume', SESSION_ID, '--name', 'transcript-fixture'],
+      });
+      await session.waitFor(/Type a message or \/help/, PROMPT_WAIT_MS);
+      await session.waitFor(new RegExp(messageText(TURNS, 'assistant')), PROMPT_WAIT_MS);
+
+      const snapshot = session.snapshot();
+      const missing: string[] = [];
+      for (let index = 1; index <= TURNS; index += 1) {
+        for (const role of ['user', 'assistant'] as const) {
+          if (!snapshot.includes(messageText(index, role))) missing.push(messageText(index, role));
+        }
+      }
+      expect(missing).toEqual([]);
+      // The transcript is above the live region: the input is pinned below the last message.
+      expect(snapshot.lastIndexOf('Type a message')).toBeGreaterThan(
+        snapshot.indexOf(messageText(TURNS, 'assistant')),
+      );
+      // The alternate screen has no scrollback; the TUI never enters it.
+      expect(session.raw()).not.toContain('\x1b[?1049h');
+    },
+    CASE_TIMEOUT_MS,
+  );
+});