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

package/src/__tests__/rename-broadcast-persistence.test.tsx

@@ -0,0 +1,140 @@
+/**
+ * CMD-004 Phase 2 Stage C — TC-10 (/rename persistence proof, TUI half).
+ *
+ * The spec gates deleting the TUI `renameSession` mutation on a red-first proof that `/rename`
+ * (1) persists HOST-side — the session executes the rename, no TUI handler involved — and
+ * (2) updates the TUI title via the broadcast `session_renamed` event.
+ *
+ * Runs the REAL TuiInteractionChannel over a real InteractiveSession (scripted provider) with a
+ * command module mirroring the real `/rename` contract (returns the `session-rename` host action
+ * on the split contract — Stage E deleted the legacy effect union).
+ *
+ * Red-first evidence: against pre-Stage-C code the broadcast half FAILED (the TUI only reacted to
+ * the legacy effect, which Stage B strips after host execution — so the title never updated).
+ */
+
+import { Text } from 'ink';
+import { render } from 'ink-testing-library';
+import React from 'react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createScriptedProvider } from '@robota-sdk/agent-core/testing';
+import { useSideEffects } from '../hooks/useSideEffects.js';
+import { TuiCliAdapterProvider } from '../tui-cli-adapter-context.js';
+import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
+
+import type { IUseSideEffectsOptions } from '../hooks/side-effects-types.js';
+import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
+import type { ICommandModule } from '@robota-sdk/agent-framework';
+
+const READY_DEADLINE_MS = 10_000;
+const POLL_MS = 25;
+
+async function waitUntil(predicate: () => boolean, deadlineMs = READY_DEADLINE_MS): Promise<void> {
+  const deadline = Date.now() + deadlineMs;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+  }
+  expect(predicate()).toBe(true);
+}
+
+/** Mirrors the real session-command `/rename` contract: NO mutation in the command, host action only. */
+const renameModule: ICommandModule = {
+  name: 'stage-c-rename-proof',
+  systemCommands: [
+    {
+      name: 'rename',
+      description: 'Rename the session (test mirror of the real /rename contract)',
+      requiresPermission: false,
+      execute: (_context, args) => ({
+        success: true,
+        message: `Session renamed to "${args}".`,
+        hostActions: [{ type: 'session-rename', name: args }],
+      }),
+    },
+  ],
+};
+
+function fakeCliAdapter(): ITuiCliAdapter {
+  return {
+    getUserSettingsPath: () => '/tmp/fake-settings.json',
+    readSettings: () => ({}),
+    reloadPluginCommandSource: vi.fn(),
+    applyActiveModelChange: vi.fn().mockReturnValue({ applied: true }),
+    getGitBranch: vi.fn().mockReturnValue(undefined),
+    getProviderDisplayName: vi.fn((type: string) => type),
+  } as unknown as ITuiCliAdapter;
+}
+
+describe('TC-10 — /rename persists host-side and the TUI title follows the broadcast', () => {
+  let channel: TuiInteractionChannel | undefined;
+
+  afterEach(async () => {
+    await channel?.stop();
+    channel = undefined;
+  });
+
+  it('host executes the rename; the TUI updates its title from session_renamed only', async () => {
+    const scripted = createScriptedProvider([{ text: 'unused in this test' }]);
+    channel = new TuiInteractionChannel({
+      cwd: process.cwd(),
+      provider: scripted.provider,
+      sessionName: 'Before Rename',
+      commandModules: [renameModule],
+    });
+    await channel.start();
+    const session = channel.getSession();
+    await waitUntil(() => {
+      try {
+        session.getContextState();
+        return true;
+      } catch {
+        return false; // allow-fallback: session init is asynchronous; poll until it is ready
+      }
+    });
+
+    const setSessionName = vi.fn();
+    const options = {
+      cwd: process.cwd(),
+      uiEventPort: session,
+      commandEffectQueue: {
+        enqueueEffects: () => undefined,
+        drain: () => undefined,
+        clear: () => undefined,
+      },
+      addEntry: vi.fn(),
+      baseHandleSubmit: (input: string) => channel!.handleInput(input),
+      setSessionName,
+      setStatusLineSettings: vi.fn(),
+      refreshStatusLineSettings: vi.fn(),
+      refreshAppearanceSettings: vi.fn(),
+      showSessionPickerOnStart: false,
+    } as unknown as IUseSideEffectsOptions;
+
+    const submitRef: { current: ((input: string) => Promise<void>) | null } = { current: null };
+    function Probe(): React.ReactElement {
+      const state = useSideEffects(options);
+      submitRef.current = state.handleSubmit;
+      return <Text>probe</Text>;
+    }
+    const instance = render(
+      <TuiCliAdapterProvider value={fakeCliAdapter()}>
+        <Probe />
+      </TuiCliAdapterProvider>,
+    );
+    await waitUntil(() => submitRef.current !== null);
+
+    await submitRef.current!('/rename Stage C Proof');
+
+    // (1) HOST persistence: the session itself performed the rename — no TUI mutation handler.
+    expect(session.getName()).toBe('Stage C Proof');
+
+    // (2) Title update via the broadcast `session_renamed` (the dual-carry legacy effect is
+    // stripped by the host applier, so this is the ONLY path that can update the title).
+    await waitUntil(() => setSessionName.mock.calls.length > 0, 3000);
+    expect(setSessionName).toHaveBeenCalledWith('Stage C Proof');
+
+    instance.unmount();
+  });
+});

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

@@ -0,0 +1,201 @@
+import { describe, it, expect } from 'vitest';
+import type { IAIProvider } from '@robota-sdk/agent-core';
+import { createNodeHostSettingsSource } from '@robota-sdk/agent-framework';
+import { createNodeHostContributionSource } from '@robota-sdk/agent-framework';
+import type { EditCheckpointStore, IPromptHistoryOptions } from '@robota-sdk/agent-framework';
+import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
+import { toChannelOptions } from '../render.js';
+import { buildTuiSessionOptions } from '../tui-session-options.js';
+import type { IRenderOptions } from '../render.js';
+
+describe('toChannelOptions', () => {
+  it('keeps host model identifiers through render, channel, and session', () => {
+    const channel = toChannelOptions({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      promptFileReferenceTag: 'acme_files',
+      modelCommandToolPrefix: 'acme_command_',
+      observerFailureWarningCode: 'ACME_BACKGROUND_OBSERVER_FAILURE',
+      subagentHookEnvironmentNames: { agentId: 'ACME_AGENT_ID', agentType: 'ACME_AGENT_TYPE' },
+      commandHookShell: '/bin/bash',
+    });
+    const session = buildTuiSessionOptions(channel);
+    expect(session.promptFileReferenceTag).toBe('acme_files');
+    expect(session.modelCommandToolPrefix).toBe('acme_command_');
+    expect(session.observerFailureWarningCode).toBe('ACME_BACKGROUND_OBSERVER_FAILURE');
+    expect(session.subagentHookEnvironmentNames).toEqual({
+      agentId: 'ACME_AGENT_ID',
+      agentType: 'ACME_AGENT_TYPE',
+    });
+    expect('commandHookShell' in session && session.commandHookShell).toBe('/bin/bash');
+  });
+
+  it('keeps safe mode (no instructions, plugins or settings hooks) through render, channel, and session', () => {
+    const channel = toChannelOptions({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      bare: true,
+      skipConfiguredHooks: true,
+    });
+    const session = buildTuiSessionOptions(channel);
+    expect('bare' in session && session.bare).toBe(true);
+    expect('skipConfiguredHooks' in session && session.skipConfiguredHooks).toBe(true);
+  });
+
+  it('preserves host permission baselines through render, channel, and session', () => {
+    const baselinePermissionAllow = ['Read(custom/**)'];
+    const channel = toChannelOptions({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      baselinePermissionAllow,
+    });
+    const session = buildTuiSessionOptions(channel);
+    if (!('baselinePermissionAllow' in session)) {
+      throw new Error('TUI standard session options must preserve the host permission baseline.');
+    }
+    expect(session.baselinePermissionAllow).toBe(baselinePermissionAllow);
+  });
+  it('keeps the host task-context selection through render, channel, and session', () => {
+    const taskContext = { enabled: true, dir: 'custom/tasks' };
+    const channel = toChannelOptions({
+      cwd: '/test-project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      taskContext,
+    });
+    expect(channel.taskContext).toBe(taskContext);
+    const session = buildTuiSessionOptions(channel);
+    if (!('taskContext' in session)) {
+      throw new Error(
+        'TUI standard session options must preserve the host task-context selection.',
+      );
+    }
+    expect(session.taskContext).toBe(taskContext);
+  });
+
+  it('keeps the host contribution sources and skill roots through render, channel, and session', () => {
+    const sources = [createNodeHostContributionSource('/test-project')];
+    const skillRoots = [{ root: 'custom/skills', kind: 'skills' as const }];
+    const channel = toChannelOptions({
+      cwd: '/test-project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      contributionSources: sources,
+      skillRoots,
+    });
+    const session = buildTuiSessionOptions(channel);
+    if (!('contributionSources' in session) || !('skillRoots' in session)) {
+      throw new Error('TUI standard session options must preserve host skill discovery settings.');
+    }
+    expect(session.contributionSources).toBe(sources);
+    expect(session.skillRoots).toBe(skillRoots);
+  });
+
+  it('keeps the host user settings sources through render, channel, and session', () => {
+    const sources = [createNodeHostSettingsSource('user', '/test-home/settings.json')];
+    const channel = toChannelOptions({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      userSettingsSources: sources,
+    });
+    expect(buildTuiSessionOptions(channel).userSettingsSources).toBe(sources);
+  });
+
+  it('forwards the loop kill switch through the channel to the session', () => {
+    const options = toChannelOptions({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      disableSessionLoops: true,
+    });
+    expect(options.disableSessionLoops).toBe(true);
+    expect(buildTuiSessionOptions(options).disableSessionLoops).toBe(true);
+  });
+
+  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();
+  });
+
+  it('CLI-076: threads the display modelId into the channel model override', () => {
+    const channelOptions = toChannelOptions({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      modelId: 'claude-haiku-4-5-20251001',
+    });
+    // The status-line model id IS the session's model override (header == the model actually called).
+    expect(channelOptions.model).toBe('claude-haiku-4-5-20251001');
+  });
+
+  it('CLI-076: leaves model undefined when no modelId is resolved', () => {
+    const channelOptions = toChannelOptions({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+    });
+    expect(channelOptions.model).toBeUndefined();
+  });
+
+  it('threads the explicit checkpoint capability without deriving it from cwd', () => {
+    const editCheckpointStore = {} as EditCheckpointStore;
+    const channelOptions = toChannelOptions({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      editCheckpointStore,
+    });
+
+    expect(channelOptions.editCheckpointStore).toBe(editCheckpointStore);
+  });
+
+  it('SCREEN-1993: projects the prompt-history writer to the channel and on to the session options', () => {
+    const promptHistory = { writer: { append: () => undefined }, project: '/p' };
+    const channelOptions = toChannelOptions({
+      cwd: '/tmp/project',
+      provider: {} as IAIProvider,
+      cliAdapter: {} as ITuiCliAdapter,
+      promptHistory,
+    });
+    expect(channelOptions.promptHistory).toBe(promptHistory);
+    // The session-options union hides standard-only fields; read the projected field by name.
+    const session = (
+      options: ReturnType<typeof toChannelOptions>,
+    ): { promptHistory?: IPromptHistoryOptions } =>
+      buildTuiSessionOptions(options) as { promptHistory?: IPromptHistoryOptions };
+    expect(session(channelOptions).promptHistory).toBe(promptHistory);
+    expect(
+      session(
+        toChannelOptions({
+          cwd: '/tmp/project',
+          provider: {} as IAIProvider,
+          cliAdapter: {} as ITuiCliAdapter,
+        }),
+      ).promptHistory,
+    ).toBeUndefined();
+  });
+});

package/src/__tests__/render-lifecycle.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { waitForRenderAndStop } from '../render.js';
+
+describe('renderApp lifecycle ownership', () => {
+  it('awaits active channel teardown after Ink exits', async () => {
+    let release: (() => void) | undefined;
+    const stop = vi.fn(() => new Promise<void>((resolve) => (release = resolve)));
+    let settled = false;
+
+    const outcome = waitForRenderAndStop(
+      async () => {},
+      () => ({ stop }),
+    ).then(() => {
+      settled = true;
+    });
+    await Promise.resolve();
+
+    expect(stop).toHaveBeenCalledTimes(1);
+    expect(settled).toBe(false);
+    release?.();
+    await outcome;
+    expect(settled).toBe(true);
+  });
+
+  it('propagates channel teardown failure to the renderApp caller', async () => {
+    const stopError = new Error('transport stop failed');
+
+    await expect(
+      waitForRenderAndStop(
+        async () => {},
+        () => ({ stop: vi.fn().mockRejectedValue(stopError) }),
+      ),
+    ).rejects.toBe(stopError);
+  });
+});

package/src/__tests__/render-markdown.test.ts

@@ -0,0 +1,164 @@
+import chalk from 'chalk';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { renderMarkdown } from '../render-markdown.js';
+import { DARK_DALTONIZED_THEME, DARK_THEME } from '../theme/built-in-themes.js';
+import { foreground } from '../theme/index.js';
+
+const ANSI_LIGHT_RED = '\u001b[38;5;210m';
+const ANSI_LIGHT_GREEN = '\u001b[38;5;120m';
+const ANSI_DARK_RED_BACKGROUND = '\u001b[48;5;52m';
+const ANSI_DARK_GREEN_BACKGROUND = '\u001b[48;5;22m';
+// SCREEN-2002: the rows are styled through chalk now, which closes a background+foreground pair with
+// its own paired resets instead of the blanket `ESC[0m` the hand-written escapes used. The colours
+// and their order are unchanged; this is the one recorded byte difference.
+const ANSI_RESET_FOREGROUND = '\u001b[39m';
+const ANSI_RESET_BACKGROUND = '\u001b[49m';
+const CODE_BLOCK_INDENT = '    ';
+/** Any SGR introducer — a plain block must carry none. */
+const SGR_ANY = '\u001b[';
+
+describe('renderMarkdown', () => {
+  it('renders diff fenced code blocks with addition and removal colors', () => {
+    const output = renderMarkdown(
+      ['Before', '', '```diff', '- const oldValue = true;', '+ const newValue = true;', '```'].join(
+        '\n',
+      ),
+      { color: true },
+    );
+
+    expect(output).toContain(`${ANSI_DARK_RED_BACKGROUND}${ANSI_LIGHT_RED}`);
+    expect(output).toContain(`${CODE_BLOCK_INDENT}- const oldValue = true;`);
+    expect(output).toContain(`${ANSI_DARK_GREEN_BACKGROUND}${ANSI_LIGHT_GREEN}`);
+    expect(output).toContain(`${CODE_BLOCK_INDENT}+ const newValue = true;`);
+  });
+
+  it('pads added and removed diff rows before applying background colors', () => {
+    const codeBlockWidth = 24;
+    const removedRow = `${CODE_BLOCK_INDENT}- removed`.padEnd(codeBlockWidth);
+    const addedRow = `${CODE_BLOCK_INDENT}+ added`.padEnd(codeBlockWidth);
+    const output = renderMarkdown(['```diff', '- removed', '+ added', '```'].join('\n'), {
+      color: true,
+      codeBlockWidth,
+    });
+
+    expect(output).toContain(
+      `${ANSI_DARK_RED_BACKGROUND}${ANSI_LIGHT_RED}${removedRow}${ANSI_RESET_FOREGROUND}${ANSI_RESET_BACKGROUND}`,
+    );
+    expect(output).toContain(
+      `${ANSI_DARK_GREEN_BACKGROUND}${ANSI_LIGHT_GREEN}${addedRow}${ANSI_RESET_FOREGROUND}${ANSI_RESET_BACKGROUND}`,
+    );
+  });
+
+  it('keeps diff fenced code block content readable when color is disabled', () => {
+    const output = renderMarkdown(
+      ['```diff', '- removed line', '+ added line', ' unchanged line', '```'].join('\n'),
+      { color: false },
+    );
+
+    expect(output).toContain('- removed line');
+    expect(output).toContain('+ added line');
+    expect(output).toContain(' unchanged line');
+    expect(output).not.toContain(ANSI_LIGHT_RED);
+    expect(output).not.toContain(ANSI_LIGHT_GREEN);
+    expect(output).not.toContain(ANSI_DARK_RED_BACKGROUND);
+    expect(output).not.toContain(ANSI_DARK_GREEN_BACKGROUND);
+  });
+
+  it('keeps regular fenced code blocks as code output', () => {
+    const output = renderMarkdown(['```ts', 'const value: string = "ok";', '```'].join('\n'), {
+      color: false,
+    });
+
+    expect(output).toContain('const value: string = "ok";');
+  });
+
+  /**
+   * SCREEN-2002 TC-03 — the theme reaches `cli-highlight`.
+   *
+   * This is the unit's most dependency-fragile claim, and the failure it guards against is SILENT:
+   * `cli-highlight` falls back PER KEY to its own `DEFAULT_THEME`, whose `keyword` is red and whose
+   * `addition` is green. If the theme stopped reaching it, a daltonized run would quietly get the
+   * red/green pair back with every other surface still daltonized, and nothing else in the suite
+   * would notice.
+   */
+  describe('SCREEN-2002 TC-03: syntax highlighting follows the theme', () => {
+    const TS_BLOCK = ['```ts', 'const value = 1;', '```'].join('\n');
+    const TRUECOLOR = 3;
+    const previousLevel = chalk.level;
+    afterEach(() => {
+      chalk.level = previousLevel;
+    });
+
+    const openCode = (color: string): string => foreground(color)('x').split('x')[0] ?? '';
+
+    it('colours a keyword with the theme s value, not cli-highlight s default', () => {
+      chalk.level = TRUECOLOR;
+      const daltonized = renderMarkdown(TS_BLOCK, {
+        color: true,
+        theme: DARK_DALTONIZED_THEME,
+      });
+
+      expect(daltonized).toContain(openCode(DARK_DALTONIZED_THEME.syntax.keyword));
+      // Recorded, because it bounds what this test can prove: `cli-highlight` depends on chalk 4 and
+      // resolves to its OWN instance, so `chalk.level` set here does not reach it and its per-key
+      // fallback emits nothing in-process — it is only coloured in a real terminal. The positive
+      // assertion above is therefore the whole guard; a `not.toContain` on the fallback's colour
+      // would be inert. The end-to-end colour is evidenced by the PTY scenario instead.
+      expect(DARK_THEME.syntax.keyword).not.toBe(DARK_DALTONIZED_THEME.syntax.keyword);
+    });
+
+    it('renders a code block as plain indented text when highlighting is off', () => {
+      chalk.level = TRUECOLOR;
+      const plain = renderMarkdown(TS_BLOCK, {
+        color: true,
+        theme: DARK_DALTONIZED_THEME,
+        syntaxHighlighting: false,
+      });
+
+      expect(plain).toContain(`${CODE_BLOCK_INDENT}const value = 1;`);
+      expect(plain).not.toContain(openCode(DARK_DALTONIZED_THEME.syntax.keyword));
+      expect(plain).not.toContain(SGR_ANY);
+    });
+  });
+
+  /**
+   * CLI-2004 TC-04 — the `Header: value` flattening, asserted at the single choke point every
+   * render path shares. A box-drawn grid is read aloud as its rules; the pairing is the content.
+   */
+  describe('CLI-2004 TC-04: screen-reader table flattening', () => {
+    const TABLE = ['| A | B |', '|---|---|', '| 1 | 2 |'].join('\n');
+    const BOX_DRAWING = /[\u2502\u2500\u250c\u2510\u2514\u2518\u251c\u2524\u252c\u2534\u253c]/u;
+
+    it('flattens a table to one `Header: value` line per cell in the mode', () => {
+      const output = renderMarkdown(TABLE, { color: false, screenReader: true });
+
+      const lines = output.split('\n').map((line) => line.trim());
+      expect(lines).toContain('A: 1');
+      expect(lines).toContain('B: 2');
+      expect(lines.indexOf('A: 1')).toBeLessThan(lines.indexOf('B: 2'));
+      expect(output).not.toMatch(BOX_DRAWING);
+    });
+
+    it('separates rows with a blank line so the row boundary is audible', () => {
+      const twoRows = ['| A | B |', '|---|---|', '| 1 | 2 |', '| 3 | 4 |'].join('\n');
+      const output = renderMarkdown(twoRows, { color: false, screenReader: true });
+
+      expect(output).toContain('A: 1\nB: 2\n\nA: 3\nB: 4');
+    });
+
+    it('leaves the box-drawn grid exactly as it is outside the mode', () => {
+      const output = renderMarkdown(TABLE, { color: false });
+
+      expect(output).toMatch(BOX_DRAWING);
+      expect(output).not.toContain('A: 1');
+    });
+  });
+
+  it('keeps inline markdown formatting readable', () => {
+    const output = renderMarkdown('Use **bold** and `code` here.', { color: false });
+
+    expect(output).toContain('bold');
+    expect(output).toContain('code');
+  });
+});

package/src/__tests__/rendered-markdown-styling.test.tsx

@@ -0,0 +1,98 @@
+/**
+ * SCREEN-006 × #2222: the markdown renderer's own SGR must SURVIVE to the frame.
+ *
+ * `renderMarkdown` sanitizes untrusted markdown BEFORE `marked-terminal` styles it, so the escape
+ * codes in its OUTPUT are this package's own — the theme's diff pairs, heading emphasis.
+ * Routing that output back through `SafeText` sanitizes it a second time and strips exactly those
+ * codes, and it does so silently: the text still renders, just colourless. Every assertion in
+ * `streaming-indicator.test.tsx` and the tool-diff suite is on TEXT, so all of them stay green
+ * while the colour is gone — which is how the regression reached a release.
+ *
+ * These are the assertions that go red for that, one per render site that renders markdown.
+ */
+
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import StreamingIndicator from '../StreamingIndicator.js';
+import ToolDiffBlock from '../ToolDiffBlock.js';
+import { DARK_THEME } from '../theme/built-in-themes.js';
+import { foreground } from '../theme/index.js';
+
+import type { IDiffLine } from '@robota-sdk/agent-interface-session';
+
+/** The opening SGR a theme colour produces, for an assertion about the rendered bytes. */
+function openCode(color: string): string {
+  const [open] = foreground(color)('x').split('x');
+  return open ?? '';
+}
+
+const DIFF_LINES: IDiffLine[] = [
+  { type: 'hunk', text: '@@ -1,2 +1,2 @@', lineNumber: 1 },
+  { type: 'remove', text: 'const a = 1;', lineNumber: 1 },
+  { type: 'add', text: 'const a = 2;', lineNumber: 1 },
+];
+
+const DIFF_MARKDOWN = [
+  '```diff',
+  '@@ -1,2 +1,2 @@',
+  '- const a = 1;',
+  '+ const a = 2;',
+  '```',
+].join('\n');
+
+describe('markdown styling survives the render site (SCREEN-006)', () => {
+  let originalForceColor: string | undefined;
+  let originalNoColor: string | undefined;
+
+  beforeEach(() => {
+    // `renderMarkdown` colours only for an interactive colour terminal; the test process is not one.
+    originalForceColor = process.env.FORCE_COLOR;
+    originalNoColor = process.env.NO_COLOR;
+    delete process.env.NO_COLOR;
+    process.env.FORCE_COLOR = '1';
+  });
+
+  afterEach(() => {
+    if (originalForceColor === undefined) delete process.env.FORCE_COLOR;
+    else process.env.FORCE_COLOR = originalForceColor;
+    if (originalNoColor === undefined) delete process.env.NO_COLOR;
+    else process.env.NO_COLOR = originalNoColor;
+  });
+
+  it('ToolDiffBlock keeps the added/removed diff colours', () => {
+    const { lastFrame } = render(<ToolDiffBlock file="src/a.ts" lines={DIFF_LINES} />);
+    const frame = lastFrame() ?? '';
+
+    expect(frame).toContain('const a = 2;');
+    // SCREEN-2002: the diff colours come from the resolved theme; the default theme's values are the
+    // ones this suite pinned before the theme existed.
+    expect(frame).toContain(openCode(DARK_THEME.markdown.diffAdded));
+    expect(frame).toContain(openCode(DARK_THEME.markdown.diffRemoved));
+    expect(frame).toContain(openCode(DARK_THEME.markdown.diffHunk)); // the @@ hunk header
+  });
+
+  it('StreamingIndicator keeps the colours of a diff block in streamed text', () => {
+    const { lastFrame } = render(<StreamingIndicator text={DIFF_MARKDOWN} activeTools={[]} />);
+    const frame = lastFrame() ?? '';
+
+    expect(frame).toContain('const a = 2;');
+    expect(frame).toContain(openCode(DARK_THEME.markdown.diffAdded));
+    expect(frame).toContain(openCode(DARK_THEME.markdown.diffRemoved));
+  });
+
+  it('StreamingIndicator still sanitizes what arrives from OUTSIDE the renderer', () => {
+    // The other direction of the same boundary: `renderMarkdown` sanitizes its INPUT, so an escape
+    // sequence in the model's text is gone before `marked-terminal` ever sees it. Switching this
+    // site to `RenderedText` must not reopen that.
+    const { lastFrame } = render(
+      <StreamingIndicator text={`before]8;;https://evil.exampleclick]8;;after`} activeTools={[]} />,
+    );
+    const frame = lastFrame() ?? '';
+
+    expect(frame).not.toContain('evil.example');
+    expect(frame).not.toContain(']8;;');
+    expect(frame).toContain('before');
+  });
+});