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

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

@@ -0,0 +1,282 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi } from 'vitest';
+import StatusBar from '../StatusBar.js';
+import SessionStatusBar from '../SessionStatusBar.js';
+import { ScreenReaderProvider } from '../screen-reader-context.js';
+import { TuiCliAdapterProvider } from '../tui-cli-adapter-context.js';
+import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
+
+describe('StatusBar', () => {
+  const baseProps = {
+    permissionMode: 'default' as const,
+    modelName: 'test-model',
+    sessionId: 'sess-1',
+    isThinking: false,
+    activeToolCount: 0,
+    activeBackgroundTaskCount: 0,
+    hasPendingPrompt: false,
+    contextPercentage: 10,
+    contextUsedTokens: 1000,
+    contextMaxTokens: 200000,
+  };
+
+  it('renders without session name', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('test-model');
+    expect(frame).not.toContain('Mode: default');
+  });
+
+  it('hides default permission mode', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} permissionMode="default" />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('Mode:');
+    expect(frame).not.toContain('default');
+  });
+
+  it('shows non-default permission modes', () => {
+    for (const permissionMode of ['plan', 'acceptEdits', 'bypassPermissions'] as const) {
+      const { lastFrame, unmount } = render(
+        <StatusBar {...baseProps} permissionMode={permissionMode} />,
+      );
+      const frame = lastFrame()!;
+      expect(frame).toContain('Mode:');
+      expect(frame).toContain(permissionMode);
+      unmount();
+    }
+  });
+
+  it('renders session name when provided', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} sessionName="my-feature" />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('my-feature');
+  });
+
+  it('does not show session name when undefined', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} sessionName={undefined} />);
+    const frame = lastFrame()!;
+    // Should not have extra separator for missing name
+    expect(frame).not.toContain('my-feature');
+  });
+
+  it('renders model name', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('test-model');
+  });
+
+  it('renders provider display name and model when provided', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} providerDisplayName="Anthropic" />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Anthropic');
+    expect(frame).toContain('test-model');
+  });
+
+  it('renders the active model effort when provided', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} effort="high" />);
+    expect(lastFrame()).toContain('Effort: high');
+  });
+
+  it('renders auto as the provider-default effort selection', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} effort="auto" />);
+    expect(lastFrame()).toContain('Effort: auto');
+  });
+
+  it('does not render message count in the status bar', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('msgs:');
+  });
+
+  it('shows thinking indicator when isThinking is true', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} isThinking={true} />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('Activity:');
+    expect(frame).toContain('Thinking');
+    expect(frame.indexOf('Thinking')).toBeLessThan(frame.indexOf('test-model'));
+  });
+
+  it('does not duplicate thinking state in secondary status text', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} isThinking={true} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Thinking');
+    expect(frame).not.toContain('thinking...');
+    expect(frame).not.toContain('msgs:');
+  });
+
+  it('hides the lower-right prompt-processing indicator while idle', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} isThinking={false} />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('thinking...');
+  });
+
+  it('prioritizes tool activity in the primary scan path', () => {
+    const { lastFrame } = render(
+      <StatusBar
+        {...baseProps}
+        isThinking={true}
+        activeToolCount={2}
+        activeBackgroundTaskCount={1}
+        hasPendingPrompt={true}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('Activity:');
+    expect(frame).toContain('Tools (2)');
+    expect(frame).not.toContain('Tools x2');
+    expect(frame).toContain('queued');
+    expect(frame).not.toContain('thinking...');
+    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 (3)');
+    expect(frame.indexOf('Background (3)')).toBeLessThan(frame.indexOf('test-model'));
+  });
+
+  it('keeps the activity segment compact for narrow terminals', () => {
+    const { lastFrame } = render(
+      <StatusBar
+        {...baseProps}
+        isThinking={true}
+        activeToolCount={12}
+        activeBackgroundTaskCount={9}
+        hasPendingPrompt={true}
+      />,
+    );
+    const frame = lastFrame()!;
+    const firstLine = frame.split('\n')[0] ?? '';
+    const activityEnd = firstLine.indexOf('test-model');
+    const activitySegment = firstLine.slice(0, activityEnd);
+    expect(activitySegment).toContain('Tools (12)');
+    expect(activitySegment.length).toBeLessThanOrEqual(40);
+  });
+
+  it('renders git branch when provided', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} gitBranch="feat/status-line" />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('feat/status-line');
+  });
+
+  it('does not render git branch when visibility is disabled', () => {
+    const { lastFrame } = render(
+      <StatusBar {...baseProps} gitBranch="feat/status-line" showGitBranch={false} />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('feat/status-line');
+  });
+
+  it('TC-03: shows the active preset id when set and non-default', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} activePresetId="autonomous-builder" />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Preset:');
+    expect(frame).toContain('autonomous-builder');
+  });
+
+  it('TC-03: hides the default active preset', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} activePresetId="default" />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('Preset:');
+  });
+
+  it('TC-03: hides the preset label when no active preset is provided', () => {
+    const { lastFrame } = render(<StatusBar {...baseProps} activePresetId={undefined} />);
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('Preset:');
+  });
+});
+
+/**
+ * CLI-2004 TC-16 / TC-21 — § Solution 13, asserted through `SessionStatusBar` (the way the App
+ * reaches `StatusBar`) so the threading is covered too.
+ *
+ * The two halves are asserted TOGETHER on purpose: they pull in opposite directions — one field is
+ * rendered MORE in the mode, two are rendered LESS — and stating them apart is how they drift into
+ * contradicting each other.
+ */
+describe('CLI-2004: the status line in screen-reader mode', () => {
+  const sessionProps = {
+    cwd: '/tmp/project',
+    permissionMode: 'default' as const,
+    modelId: 'test-model',
+    sessionId: 'sess-1',
+    isThinking: false,
+    activeToolCount: 0,
+    activeBackgroundTaskCount: 0,
+    hasPendingPrompt: false,
+    contextState: { percentage: 42, usedTokens: 1000, maxTokens: 200000 },
+    settings: { enabled: true, gitBranch: false } as never,
+    activePresetId: 'reviewer',
+  };
+
+  function cliAdapter(): ITuiCliAdapter {
+    return {
+      getUserSettingsPath: () => '/tmp/fake-settings.json',
+      readSettings: () => ({}),
+      reloadPluginCommandSource: vi.fn(),
+      applyActiveModelChange: vi.fn(),
+      getGitBranch: vi.fn().mockReturnValue(undefined),
+      getProviderDisplayName: vi.fn((type: string) => type),
+    } as unknown as ITuiCliAdapter;
+  }
+
+  function renderStatus(enabled: boolean, overrides: Record<string, unknown> = {}): string {
+    const { lastFrame, unmount } = render(
+      <ScreenReaderProvider enabled={enabled}>
+        <TuiCliAdapterProvider value={cliAdapter()}>
+          <SessionStatusBar {...sessionProps} {...overrides} />
+        </TuiCliAdapterProvider>
+      </ScreenReaderProvider>,
+    );
+    const frame = lastFrame() ?? '';
+    unmount();
+    return frame;
+  }
+
+  it('TC-16: renders the permission mode even when it is `default`', () => {
+    const frame = renderStatus(true);
+    expect(frame).toContain('Mode:');
+    expect(frame).toContain('default');
+  });
+
+  it('TC-16: still hides the `default` permission mode outside the mode', () => {
+    const frame = renderStatus(false);
+    expect(frame).not.toContain('Mode:');
+  });
+
+  it('TC-21: suppresses the volatile fields and keeps the stable ones', () => {
+    const frame = renderStatus(true, { isThinking: true, activeToolCount: 2 });
+
+    // Volatile — re-rendered on their own cadence and on every token.
+    expect(frame).not.toContain('Context:');
+    expect(frame).not.toContain('42%');
+    expect(frame).not.toContain('Idle');
+    expect(frame).not.toContain('Thinking');
+
+    // Stable — anchors a reader can go back to.
+    expect(frame).toContain('Mode:');
+    expect(frame).toContain('default');
+    expect(frame).toContain('Preset:');
+    expect(frame).toContain('reviewer');
+    expect(frame).toContain('test-model');
+  });
+
+  it('TC-21: renders all four exactly as today outside the mode', () => {
+    const frame = renderStatus(false, {
+      isThinking: true,
+      activeToolCount: 2,
+      permissionMode: 'plan',
+    });
+
+    expect(frame).toContain('Context:');
+    expect(frame).toContain('42%');
+    expect(frame).toContain('Mode:');
+    expect(frame).toContain('plan');
+    expect(frame).toContain('Preset:');
+    expect(frame).toContain('test-model');
+  });
+});

package/src/__tests__/status-glyph.test.ts

@@ -0,0 +1,30 @@
+/**
+ * SCREEN-009: lock in the status-legibility invariant — every status kind pairs a non-empty
+ * SYMBOL with a color (never color alone), so the TUI stays legible on no-color terminals and
+ * for colorblind users. A new status kind that omits the symbol fails here.
+ */
+import { describe, it, expect } from 'vitest';
+import { STATUS_SYMBOL, statusGlyphColor, workspaceStatusKind } from '../status-glyph';
+
+import type { TUiStatusKind } from '../status-glyph';
+import { DARK_THEME } from '../theme/built-in-themes.js';
+
+describe('status-glyph SSOT (SCREEN-009)', () => {
+  it('every status kind has a non-empty symbol AND color (no color-only state)', () => {
+    const entries = Object.entries(STATUS_SYMBOL) as [TUiStatusKind, string][];
+    expect(entries.length).toBeGreaterThan(0);
+    for (const [kind, symbol] of entries) {
+      expect(symbol, `${kind} must have a symbol`).toBeTruthy();
+      expect(symbol.length, `${kind} symbol must be non-empty`).toBeGreaterThan(0);
+      // SCREEN-2002: the colour comes from the live theme, so the pairing is checked against one.
+      expect(statusGlyphColor(DARK_THEME.colors, kind), `${kind} must have a color`).toBeTruthy();
+    }
+  });
+
+  it('workspaceStatusKind maps to a glyph that exists in the SSOT', () => {
+    const kind = workspaceStatusKind('completed');
+    expect(kind).toBe('success');
+    expect(STATUS_SYMBOL[kind]).toBeTruthy();
+    expect(statusGlyphColor(DARK_THEME.colors, kind)).toBeTruthy();
+  });
+});

package/src/__tests__/streaming-indicator.test.tsx

@@ -0,0 +1,177 @@
+import React from 'react';
+import { describe, it, expect } from 'vitest';
+import { render } from 'ink-testing-library';
+import StreamingIndicator from '../StreamingIndicator.js';
+import { ScreenReaderProvider } from '../screen-reader-context.js';
+
+describe('StreamingIndicator', () => {
+  it('renders empty when no tools and no text', () => {
+    const { lastFrame } = render(<StreamingIndicator text="" activeTools={[]} />);
+    expect(lastFrame()).not.toContain('Thinking');
+  });
+
+  it('shows a generic thinking state when foreground work has no text or tools yet', () => {
+    const { lastFrame } = render(<StreamingIndicator text="" activeTools={[]} isThinking={true} />);
+
+    expect(lastFrame()).toContain('Thinking...');
+  });
+
+  it('shows Tools: section with running tool', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[{ toolName: 'Bash', firstArg: 'ls -la', isRunning: true }]}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('Tools:');
+    expect(frame).toContain('Bash(ls -la)');
+  });
+
+  it('shows ⟳ for running and ✓ for completed tools', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[
+          { toolName: 'Read', firstArg: '/src/index.ts', isRunning: false },
+          { toolName: 'Bash', firstArg: 'ls', isRunning: true },
+        ]}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('✓ Read(/src/index.ts)');
+    expect(frame).toContain('⟳ Bash(ls)');
+  });
+
+  it('shows Assistant: section with streaming text', () => {
+    const { lastFrame } = render(<StreamingIndicator text="Hello world" activeTools={[]} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Assistant:');
+    expect(frame).toContain('Hello world');
+    expect(frame).not.toContain('Tools:');
+  });
+
+  it('preserves CJK and emoji text in streaming output', () => {
+    const text = '긴 한국어 응답과 emoji 🎉 를 스트리밍합니다';
+    const { lastFrame } = render(<StreamingIndicator text={text} activeTools={[]} />);
+
+    expect(lastFrame()).toContain(text);
+  });
+
+  it('shows Tools: before Assistant: when both present', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text="Analyzing..."
+        activeTools={[{ toolName: 'Read', firstArg: 'file.ts', isRunning: false }]}
+      />,
+    );
+    const frame = lastFrame()!;
+    const toolsIndex = frame.indexOf('Tools:');
+    const assistantIndex = frame.indexOf('Assistant:');
+    expect(toolsIndex).toBeGreaterThanOrEqual(0);
+    expect(assistantIndex).toBeGreaterThanOrEqual(0);
+    expect(toolsIndex).toBeLessThan(assistantIndex);
+  });
+
+  it('does not show Thinking... when tools are active', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[{ toolName: 'Glob', firstArg: '**/*.md', isRunning: true }]}
+      />,
+    );
+    expect(lastFrame()).not.toContain('Thinking...');
+  });
+
+  it('does not show Thinking... when text is present', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator text="Some response" activeTools={[]} isThinking={true} />,
+    );
+    expect(lastFrame()).not.toContain('Thinking...');
+  });
+
+  it('shows multiple tools in order', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[
+          { toolName: 'Read', firstArg: 'a.ts', isRunning: false },
+          { toolName: 'Bash', firstArg: 'echo hi', isRunning: false },
+          { toolName: 'Glob', firstArg: '**/*.md', isRunning: true },
+        ]}
+      />,
+    );
+    const frame = lastFrame()!;
+    const readIdx = frame.indexOf('Read(a.ts)');
+    const bashIdx = frame.indexOf('Bash(echo hi)');
+    const globIdx = frame.indexOf('Glob(**/*.md)');
+    expect(readIdx).toBeLessThan(bashIdx);
+    expect(bashIdx).toBeLessThan(globIdx);
+  });
+
+  it('renders tool diffs through markdown diff body format', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator
+        text=""
+        activeTools={[
+          {
+            toolName: 'Edit',
+            firstArg: '/src/index.ts',
+            isRunning: false,
+            result: 'success',
+            diffFile: '/src/index.ts',
+            diffLines: [
+              { type: 'remove', lineNumber: 1, text: 'const oldValue = true;' },
+              { type: 'add', lineNumber: 1, text: 'const newValue = true;' },
+            ],
+          },
+        ]}
+      />,
+    );
+
+    const frame = lastFrame() ?? '';
+    expect(frame).toContain('/src/index.ts');
+    expect(frame).toContain('- 1 | const oldValue = true;');
+    expect(frame).toContain('+ 1 | const newValue = true;');
+    expect(frame).not.toContain('│ 1 - const oldValue = true;');
+  });
+});
+
+/** CLI-2004 TC-19 — the progress indicator collapses to one static line in the mode. */
+describe('CLI-2004 TC-19: StreamingIndicator in screen-reader mode', () => {
+  function renderInMode(element: React.ReactElement): string {
+    const { lastFrame, unmount } = render(
+      <ScreenReaderProvider enabled={true}>{element}</ScreenReaderProvider>,
+    );
+    const frame = lastFrame() ?? '';
+    unmount();
+    return frame;
+  }
+
+  it('renders a single static line for a thinking turn', () => {
+    const frame = renderInMode(<StreamingIndicator text="" activeTools={[]} isThinking={true} />);
+    expect(frame.split('\n').filter((line) => line.trim().length > 0)).toHaveLength(1);
+    expect(frame).toContain('thinking:');
+    expect(frame).not.toContain('Thinking...');
+  });
+
+  it('folds running tools and streamed text into that one line', () => {
+    const frame = renderInMode(
+      <StreamingIndicator
+        text="partial answer"
+        activeTools={[{ toolName: 'Bash', firstArg: 'ls', isRunning: true }]}
+        isThinking={true}
+      />,
+    );
+    expect(frame.split('\n').filter((line) => line.trim().length > 0)).toHaveLength(1);
+    expect(frame).toContain('tool:');
+    expect(frame).toContain('partial answer');
+  });
+
+  it('leaves the multi-line indicator unchanged outside the mode', () => {
+    const { lastFrame } = render(
+      <StreamingIndicator text="Hello" activeTools={[]} isThinking={true} />,
+    );
+    expect(lastFrame()).toContain('Assistant:');
+  });
+});

package/src/__tests__/terminal-capabilities.test.ts

@@ -0,0 +1,153 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  IME_CURSOR_SETTINGS,
+  TERMINAL_PROFILES,
+  REPRESENTATIVE_IME_PTY_CELLS,
+  cellLabel,
+  expectedImeCursorEnabled,
+} from './helpers/terminal-profiles.js';
+import {
+  isInteractiveColorTerminal,
+  supportsImeCursorPositioning,
+} from '../terminal-capabilities.js';
+
+const ORIG_TTY = process.stdout.isTTY;
+
+function setTty(value: boolean): void {
+  Object.defineProperty(process.stdout, 'isTTY', { value, configurable: true });
+}
+
+describe('isInteractiveColorTerminal', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    Object.defineProperty(process.stdout, 'isTTY', { value: ORIG_TTY, configurable: true });
+  });
+
+  it('NO_COLOR present disables even when empty (the SCREEN-008 regression)', () => {
+    vi.stubEnv('FORCE_COLOR', undefined);
+    setTty(true);
+    vi.stubEnv('NO_COLOR', '');
+    expect(isInteractiveColorTerminal()).toBe(false);
+    vi.stubEnv('NO_COLOR', '1');
+    expect(isInteractiveColorTerminal()).toBe(false);
+  });
+
+  it('honors FORCE_COLOR (0 → off, non-zero → on)', () => {
+    vi.stubEnv('NO_COLOR', undefined);
+    setTty(false);
+    vi.stubEnv('FORCE_COLOR', '0');
+    expect(isInteractiveColorTerminal()).toBe(false);
+    vi.stubEnv('FORCE_COLOR', '1');
+    expect(isInteractiveColorTerminal()).toBe(true);
+  });
+
+  it('falls back to stdout.isTTY when no env override', () => {
+    vi.stubEnv('NO_COLOR', undefined);
+    vi.stubEnv('FORCE_COLOR', undefined);
+    setTty(true);
+    expect(isInteractiveColorTerminal()).toBe(true);
+    setTty(false);
+    expect(isInteractiveColorTerminal()).toBe(false);
+  });
+});
+
+describe('supportsImeCursorPositioning (CLI-062)', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    Object.defineProperty(process.stdout, 'isTTY', { value: ORIG_TTY, configurable: true });
+  });
+
+  it('on for a plain interactive TTY, off for a non-TTY', () => {
+    vi.stubEnv('ROBOTA_IME_CURSOR', undefined);
+    vi.stubEnv('TERM_PROGRAM', undefined);
+    setTty(true);
+    expect(supportsImeCursorPositioning()).toBe(true);
+    setTty(false);
+    expect(supportsImeCursorPositioning()).toBe(false);
+  });
+
+  it('I5: Apple_Terminal is OFF by default (Korean-IME SIGSEGV is an Apple-side bug)', () => {
+    vi.stubEnv('ROBOTA_IME_CURSOR', undefined);
+    setTty(true);
+    vi.stubEnv('TERM_PROGRAM', 'Apple_Terminal');
+    expect(supportsImeCursorPositioning()).toBe(false);
+  });
+
+  it('I5: ROBOTA_IME_CURSOR=1 opts Apple_Terminal in explicitly', () => {
+    setTty(true);
+    vi.stubEnv('TERM_PROGRAM', 'Apple_Terminal');
+    vi.stubEnv('ROBOTA_IME_CURSOR', '1');
+    expect(supportsImeCursorPositioning({ override: true })).toBe(true);
+  });
+
+  it('ignores an ambient Robota override without a host choice', () => {
+    setTty(true);
+    vi.stubEnv('TERM_PROGRAM', 'Apple_Terminal');
+    vi.stubEnv('ROBOTA_IME_CURSOR', '1');
+    expect(supportsImeCursorPositioning()).toBe(false);
+  });
+
+  it('ROBOTA_IME_CURSOR=0 is a kill switch even on a capable terminal', () => {
+    setTty(true);
+    vi.stubEnv('TERM_PROGRAM', undefined);
+    vi.stubEnv('ROBOTA_IME_CURSOR', '0');
+    expect(supportsImeCursorPositioning({ override: false })).toBe(false);
+  });
+});
+
+/**
+ * CLI-062 terminal matrix — capability half.
+ *
+ * Terminal detection is ASSERTED here, never assumed: every emulator in the matrix is applied as
+ * the environment handshake it really exports (see helpers/terminal-profiles.ts for how each row's
+ * values were obtained), and the gate's verdict is compared against the shared expectation the pty
+ * matrix asserts behaviourally. The macOS rows (Terminal.app, iTerm2) cannot run their emulator on
+ * a non-macOS machine, but their env branch — including Apple_Terminal's default-off I5 branch —
+ * is fully exercised by stubbing the variables those terminals set.
+ */
+describe('CLI-062 terminal matrix — supportsImeCursorPositioning per terminal', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    Object.defineProperty(process.stdout, 'isTTY', { value: ORIG_TTY, configurable: true });
+  });
+
+  for (const profile of TERMINAL_PROFILES) {
+    for (const override of IME_CURSOR_SETTINGS) {
+      const expected = expectedImeCursorEnabled(profile, override);
+      it(`${cellLabel(profile, override)} → ${expected ? 'ENABLED' : 'disabled'}`, () => {
+        setTty(true);
+        // A real terminal exports only its own variables; anything the matrix does not set must
+        // be genuinely absent, or a leaked TERM_PROGRAM would silently decide the verdict.
+        for (const key of ['TERM', 'TERM_PROGRAM', 'TERM_PROGRAM_VERSION', 'COLORTERM']) {
+          vi.stubEnv(key, undefined);
+        }
+        for (const [key, value] of Object.entries(profile.env)) vi.stubEnv(key, value);
+        vi.stubEnv('ROBOTA_IME_CURSOR', override);
+
+        expect(
+          supportsImeCursorPositioning({
+            override: override === '1' ? true : override === '0' ? false : undefined,
+          }),
+        ).toBe(expected);
+      });
+    }
+  }
+
+  it('every matrix row keeps its provenance honest (measured rows name a real capture)', () => {
+    for (const profile of TERMINAL_PROFILES) {
+      expect(profile.note.length, profile.id).toBeGreaterThan(0);
+      if (profile.provenance === 'measured') {
+        expect(profile.note, profile.id).toMatch(/Captured|pty harness/);
+      }
+    }
+  });
+
+  it('keeps the process-spawning PTY tier to four boundary representatives', () => {
+    expect(REPRESENTATIVE_IME_PTY_CELLS).toEqual([
+      { profileId: 'ghostty', override: undefined },
+      { profileId: 'apple-terminal', override: undefined },
+      { profileId: 'apple-terminal', override: '1' },
+      { profileId: 'ghostty', override: '0' },
+    ]);
+  });
+});