subrouter-cli 0.0.0-stage → 0.1.0

package/test/ui.test.ts

@@ -0,0 +1,635 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { test } from 'node:test';
+
+function render(script: string): string {
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', `
+    Object.defineProperty(process.stdout, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'columns', { value: 60 });
+    delete process.env.NO_COLOR;
+    const { ui, green } = await import('./src/ui.ts');
+    ${script}
+  `], { cwd: new URL('..', import.meta.url), encoding: 'utf8' });
+  assert.equal(child.status, 0, child.stderr);
+  return child.stdout;
+}
+
+const plain = (text: string): string => text.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+
+// Small screen emulator: verifies visible rows rather than just emitted ANSI bytes.
+function screen(output: string, rows = 24, columns = 60): string[] {
+  const grid = Array.from({ length: rows }, () => Array(columns).fill(' '));
+  let row = 0, col = 0, top = 0, bottom = rows - 1;
+  let saved = [0, 0];
+  const tokens = output.match(/\x1b\[[0-9;?]*[A-Za-z]|\x1b[78]|[^\x1b]/gu) ?? [];
+  for (const token of tokens) {
+    if (token === '\x1b7') { saved = [row, col]; continue; }
+    if (token === '\x1b8') { [row, col] = saved; continue; }
+    if (token.startsWith('\x1b[')) {
+      const args = token.slice(2, -1).split(';').map(Number);
+      switch (token.at(-1)) {
+        case 'H': row = (args[0] || 1) - 1; col = (args[1] || 1) - 1; break;
+        case 'r': top = (args[0] || 1) - 1; bottom = (args[1] || rows) - 1; row = col = 0; break;
+        case 'K':
+          if (grid[row]) grid[row].fill(' ', args[0] === 2 ? 0 : col);
+          break;
+        case 'J':
+          if (grid[row]) grid[row].fill(' ', col);
+          for (let r = row + 1; r < rows; r++) grid[r].fill(' ');
+          break;
+      }
+      continue;
+    }
+    if (token === '\r') { col = 0; continue; }
+    if (token === '\n') {
+      col = 0;
+      if (row === bottom) {
+        grid.splice(top, 1);
+        grid.splice(bottom, 0, Array(columns).fill(' '));
+      } else row = Math.min(rows - 1, row + 1);
+      continue;
+    }
+    if (row < rows && col < columns) grid[row][col++] = token;
+  }
+  return grid.map((line) => line.join('').trimEnd());
+}
+
+function dockRender(script: string): string {
+  return render(`
+    Object.defineProperty(process.stdin, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'rows', { value: 24, configurable: true });
+    ui.welcome('openai/test', '/tmp/project');
+    ui.composer('openai/test', green('❯ '), '', 0);
+    ${script}
+    process.stdout.write('SNAPSHOT_END');
+    ui.closeDock();
+  `).split('SNAPSHOT_END')[0];
+}
+
+test('permission approvals render as a bordered panel with a separate choice line', () => {
+  const rows = screen(dockRender(`
+    ui.openApproval('File permission required', ['write_file "Desktop/quick-file.txt"'],
+      ' type y to allow once · a to allow file changes this session · n to deny');
+    ui.setApprovalChoice('y', 1);
+  `));
+  assert.ok(rows.some((line) => line.includes('╭─ File permission required')));
+  assert.ok(rows.some((line) => line.includes('│ write_file "Desktop/quick-file.txt"')));
+  assert.ok(rows.some((line) => line.includes('type y to allow once')));
+  assert.ok(rows.some((line) => line.includes('╰─ › y')));
+  assert.ok(rows.some((line) => line === '❯'));
+  assert.ok(rows.every((line) => !line.includes('Allow file change [y/a/n]')));
+});
+
+test('approval panel keeps the path and composer visible in a ten-row terminal', () => {
+  const out = dockRender(`
+    Object.defineProperty(process.stdout, 'rows', { value: 10, configurable: true });
+    process.stdout.emit('resize');
+    ui.openApproval('File permission required', ['write_file "quick-file.txt"'], 'y once · a all · n deny');
+    ui.setApprovalChoice('n', 1);
+  `);
+  const rows = screen(out, 10);
+  assert.ok(!out.includes('\x1b[1;1r'));
+  assert.ok(rows.some((line) => line.includes('quick-file.txt')));
+  assert.ok(rows.some((line) => line.includes('╰─ › n')));
+  assert.ok(rows.some((line) => line === '❯'));
+});
+
+test('long approval details wrap and scroll without replacing the composer draft', () => {
+  const path = 'Desktop/' + 'a'.repeat(105) + '/destination.txt';
+  const out = dockRender(`
+    Object.defineProperty(process.stdout, 'rows', { value: 12, configurable: true });
+    process.stdout.emit('resize');
+    ui.composer('openai/test', green('❯ '), 'unsent draft', 12);
+    ui.openApproval('File permission required', [${JSON.stringify(path)}], 'y once · n deny');
+    ui.scrollApproval(100);
+    ui.setApprovalChoice('n', 1);
+  `);
+  const rows = screen(out, 12);
+  assert.ok(rows.some((line) => line.includes('/destination.txt')));
+  assert.ok(rows.some((line) => line.includes('↑')));
+  assert.ok(rows.some((line) => line.includes('╰─ › n')));
+  assert.ok(rows.some((line) => line.includes('❯ unsent draft')));
+  const dismissed = screen(dockRender(`
+    ui.openApproval('File permission required', ['write_file "test"'], 'y once · n deny');
+    ui.closeApproval();
+  `));
+  assert.ok(dismissed.every((line) => !line.includes('File permission required')));
+});
+
+test('absolute permission warning remains visible during steering and command controls', () => {
+  for (const commandMode of [false, true]) {
+    const out = dockRender(`
+      ui.setMode('ABSOLUTE — NO APPROVALS');
+      ui.setStatus('running run_command · ctrl+c stop');
+      ui.setSteering(1, ['pending message']);
+      ui.commandNotice('working');
+      ui.setCommandMode(${commandMode});
+    `);
+    assert.ok(screen(out).some((line) => line.includes('ABSOLUTE — NO APPROVALS')));
+  }
+});
+
+test('absolute acknowledgement warning is removed from the chat after its prompt closes', () => {
+  const out = dockRender(`
+    ui.say('existing chat');
+    const warningStart = ui.chatPosition();
+    ui.say('WARNING: ABSOLUTE PERMISSIONS — ENTIRE DRIVE, NO APPROVALS');
+    const warningEnd = ui.chatPosition();
+    ui.say('agent output while confirmation is open');
+    ui.removeChat(warningStart, warningEnd);
+  `);
+  const lines = screen(out);
+  assert.ok(lines.includes('existing chat'));
+  assert.ok(lines.includes('agent output while confirmation is open'));
+  assert.ok(lines.every((line) => !line.includes('WARNING: ABSOLUTE PERMISSIONS')));
+});
+
+test('removing the absolute warning preserves and updates an active chat tool card', () => {
+  const rows = screen(dockRender(`
+    ui.startTool('write_file');
+    const start = ui.chatPosition();
+    ui.say('WARNING: ABSOLUTE PERMISSIONS — ENTIRE DRIVE, NO APPROVALS');
+    const end = ui.chatPosition();
+    ui.preview('Write(a.txt)', ['+ content']);
+    ui.removeChat(start, end);
+    ui.finishActivity('write_file', '✓ write_file');
+  `));
+  assert.equal(rows.filter((line) => line.includes('Write(a.txt)')).length, 1);
+  assert.ok(rows.some((line) => line.includes('+ content')));
+  assert.ok(rows.every((line) => !line.includes('WARNING: ABSOLUTE PERMISSIONS')));
+});
+
+test('TTY startup shows a distinct header and model-aware composer', () => {
+  const out = render(`
+    ui.welcome('openai/test-model', '/tmp/project');
+    ui.composer('openai/test-model', green('❯ '), '', 0);
+  `);
+  const text = plain(out);
+  assert.match(text, /sub  \/tmp\/project/);
+  assert.match(text, /What are we building\?/);
+  assert.match(text, /─ openai\/test-model ─+/);
+  assert.ok(text.endsWith('❯ '));
+});
+
+test('composer redraw clears both rows and updates the model', () => {
+  const out = render(`
+    ui.composer('openai/first', green('❯ '), '', 0);
+    ui.composer('openai/second', green('❯ '), 'hello', 5);
+    ui.say('done');
+  `);
+  assert.equal(out.split('\x1b[1A').length - 1, 2);
+  assert.match(plain(out), /openai\/second/);
+  assert.ok(out.endsWith('done\n'));
+});
+
+test('long input stays within the composer row', () => {
+  const out = render(`ui.composer('openai/test', '❯ ', 'x'.repeat(200), 200);`);
+  assert.ok(plain(out).split('\n').every((line) => line.length <= 59));
+});
+
+test('NO_COLOR set after import disables styling and spinner animation', () => {
+  const out = render(`
+    process.env.NO_COLOR = '1';
+    ui.welcome('openai/test', '/tmp/project');
+    ui.spinner('loading').start(0).stop('done');
+  `);
+  assert.ok(!out.includes('\x1b['));
+  assert.match(out, /sub  \/tmp\/project/);
+  assert.match(out, /loading/);
+  assert.match(out, /done/);
+});
+
+test('thinking animates in the chat area without duplicating it in the footer or moving the draft', () => {
+  const out = dockRender(`
+    ui.composer('openai/test', green('❯ '), 'my draft', 8);
+    ui.setStatus('thinking · ctrl+c stop');
+    for (const frame of ['⠋', '⠙', '⠹']) ui.activity('thinking', frame + ' thinking');
+  `);
+  const lines = screen(out);
+  assert.equal(lines.filter((line) => line.includes('thinking')).length, 1);
+  assert.ok(lines.findIndex((line) => line.includes('⠹ thinking')) < 19);
+  assert.equal(lines[20], '❯ my draft');
+  assert.ok(lines.slice(19).every((line) => !line.includes('thinking')));
+  assert.match(lines[22], /ctrl\+c stop/);
+});
+
+test('thinking is transient: streaming text replaces it and scrollback does not retain old frames', () => {
+  const completed = screen(dockRender(`
+    ui.setStatus('thinking · ctrl+c stop');
+    ui.activity('thinking', '⠋ thinking');
+    ui.finishActivity('thinking', '');
+    ui.streamText('Visible response');
+    ui.endTurn();
+    ui.setStatus('ready');
+  `));
+  assert.ok(completed.some((line) => line === 'Visible response'));
+  assert.ok(completed.every((line) => !line.includes('thinking')));
+  const scrolled = screen(dockRender(`
+    for (let i = 0; i < 40; i++) ui.say('message ' + i);
+    ui.setStatus('thinking · ctrl+c stop');
+    ui.activity('thinking', '⠙ thinking');
+    ui.scrollChat(10);
+    ui.activity('thinking', '⠹ thinking');
+  `));
+  assert.ok(scrolled.every((line) => !line.includes('thinking')));
+  const live = screen(dockRender(`
+    for (let i = 0; i < 40; i++) ui.say('message ' + i);
+    ui.setStatus('thinking · ctrl+c stop');
+    ui.activity('thinking', '⠙ thinking');
+    ui.scrollChat(10);
+    ui.activity('thinking', '⠹ thinking');
+    ui.scrollChat(-Infinity);
+  `));
+  assert.equal(live.filter((line) => line.includes('thinking')).length, 1);
+  assert.ok(live.some((line) => line === 'message 39'));
+});
+
+test('thinking survives command geometry changes and becomes static under NO_COLOR', () => {
+  const lines = screen(dockRender(`
+    process.env.NO_COLOR = '1';
+    ui.setStatus('thinking · ctrl+c stop');
+    ui.spinner('thinking').start();
+    ui.menu(['first', 'second'], 0);
+    ui.closeMenu();
+    ui.setUsage('12 in / 7 out', 'account: 20 rpm');
+  `));
+  assert.equal(lines.filter((line) => line.includes('thinking')).length, 1);
+  assert.ok(lines.findIndex((line) => line.includes('● thinking')) < 18);
+  assert.equal(lines[19], '❯');
+  assert.equal(lines[23], 'account: 20 rpm');
+});
+
+test('chat scrolls above the bottom-anchored input and provider usage', () => {
+  const out = dockRender(`
+    ui.setUsage('12 in / 7 out · openai: 5h 80% available');
+    for (let i = 0; i < 50; i++) ui.say('answer ' + i);
+    ui.composer('openai/test', green('❯ '), 'hello', 5);
+  `);
+  const lines = screen(out);
+  assert.equal(lines[17], 'answer 49');
+  assert.match(lines[19], /─+ openai\/test ─$/);
+  assert.equal(lines[20], '❯ hello');
+  assert.equal(lines[21], '─'.repeat(59));
+  assert.equal(lines[22], 'ask before writes · effort auto · ready');
+  assert.equal(lines[23], '12 in / 7 out · openai: 5h 80% available');
+});
+
+test('model popup is attached below the bar and selection restores the chat region', () => {
+  const opened = dockRender(`ui.menu(['first', 'second'], 1, 0);`);
+  const rows = screen(opened);
+  assert.match(rows[18], /openai\/test/);
+  assert.equal(rows[19], '❯');
+  assert.equal(rows[20], '─'.repeat(59));
+  assert.equal(rows[21], '  first');
+  assert.equal(rows[22], '› second');
+  assert.match(rows[23], /enter select/);
+  const closed = dockRender(`
+    ui.menu(['first', 'second'], 1, 0);
+    ui.closeMenu();
+    ui.say('selection complete');
+    ui.composer('openai/second', green('❯ '), '', 0);
+  `);
+  assert.ok(closed.includes('\x1b[1;19r'));
+  assert.match(screen(closed)[19], /openai\/second/);
+  assert.ok(!screen(closed).some((line) => line.includes('enter select')));
+});
+
+test('account limits and command feedback stay below the bar, outside chat', () => {
+  const out = dockRender(`
+    ui.say('agent answer');
+    ui.setUsage('openai: 5h 80% available', 'account: 60 rpm · day 0/1,000 tokens');
+    ui.commandNotice('model saved');
+  `);
+  const rows = screen(out);
+  assert.match(rows[18], /openai\/test/);
+  assert.equal(rows[19], '❯');
+  assert.equal(rows[21], 'model saved');
+  assert.equal(rows[22], 'openai: 5h 80% available');
+  assert.equal(rows[23], 'account: 60 rpm · day 0/1,000 tokens');
+  assert.ok(!rows.slice(0, 18).some((line) => /model saved|account:/.test(line)));
+});
+
+test('filtering command options resizes the menu without stale rows', () => {
+  const out = dockRender(`
+    ui.menu(['one', 'two', 'three', 'four'], 0, 0);
+    ui.menu(['one'], 0, 0);
+  `);
+  const rows = screen(out);
+  assert.equal(rows[22], '› one');
+  assert.match(rows[23], /enter select/);
+  assert.ok(!rows.some((line) => /two|three|four/.test(line)));
+});
+
+test('usage panel wraps long lines, scrolls below input and closes cleanly', () => {
+  const out = dockRender(`
+    ui.panel(['x'.repeat(100), ...Array.from({ length: 10 }, (_, i) => 'pool ' + i)]);
+    ui.scrollPanel(4);
+  `);
+  const rows = screen(out);
+  assert.equal(rows[13], '❯');
+  assert.equal(rows[15], 'pool 2');
+  assert.match(rows[23], /r refresh/);
+  const closed = dockRender(`ui.panel(['usage']); ui.closePanel();`);
+  assert.ok(!screen(closed).some((line) => line === 'usage'));
+});
+
+test('command notices clear on new input or agent activity', () => {
+  const out = dockRender(`
+    ui.commandNotice('model saved');
+    ui.composer('openai/test', '❯ ', 'hello', 5);
+    ui.commandNotice('another notice');
+    ui.setStatus('thinking');
+  `);
+  const rows = screen(out);
+  assert.equal(rows[22], 'ask before writes · effort auto · ctrl+c stop');
+});
+
+test('dock uses semantic colors for model, effort, activity and availability', () => {
+  const out = dockRender(`
+    ui.setEffort('high');
+    ui.setStatus('thinking');
+    ui.activity('thinking', '⠋ thinking');
+    ui.setUsage('915 in / 82 out · opencode: 5h 100% · 7d 36% · monthly 10% available',
+      'account: 60 rpm · day 374,311,594/unlimited tokens · week $200/$500');
+  `);
+  assert.ok(out.includes('\x1b[38;2;143;167;255m\x1b[1m openai/test ─'));
+  assert.ok(out.includes('\x1b[38;2;143;167;255m\x1b[1msub'));
+  assert.ok(out.includes('\x1b[38;2;166;116;255meffort high\x1b[0m'));
+  assert.ok(out.includes('\x1b[38;2;166;116;255m❯ '));
+  assert.ok(out.includes('\x1b[38;2;166;116;255m⠋\x1b[0m\x1b[2m thinking\x1b[0m'));
+  assert.ok(out.includes('\x1b[38;2;143;167;255m\x1b[1m100%'));
+  assert.ok(out.includes('\x1b[93m\x1b[1m36%'));
+  assert.ok(out.includes('\x1b[91m\x1b[1m10%'));
+  assert.match(screen(out)[22], /915 in \/ 82 out · opencode/);
+  const noColor = dockRender(`
+    process.env.NO_COLOR = '1';
+    ui.setEffort('high');
+    ui.setUsage('opencode: 5h 100% available');
+    process.stdout.write('COLOR_OFF');
+    ui.composer('openai/test', '❯ ', '', 0);
+  `).split('COLOR_OFF')[1];
+  assert.ok(!/\x1b\[[\d;]*m/.test(noColor));
+});
+
+test('file preview and tool activity update one in-flow chat card', () => {
+  const out = dockRender(`
+    ui.say('previous conversation');
+    ui.beginTurn();
+    ui.startTool('write_file');
+    ui.preview('Write(x.ts) · +1 lines', ['+ const first = 1;']);
+    ui.preview('Write(x.ts) · +2 lines', ['+ const first = 1;', '+ const second = 2;']);
+    const spinner = ui.spinner('write_file {"path":"x.ts"}').start(100000);
+    spinner.stop('✓ write_file');
+    ui.say('final answer after tool');
+  `);
+  const rows = screen(out);
+  assert.equal(rows.filter((line) => line.includes('const first = 1')).length, 1);
+  assert.equal(rows.filter((line) => line.includes('const second = 2')).length, 1);
+  assert.equal(rows.filter((line) => line.includes('Write(x.ts)')).length, 1);
+  const card = rows.findIndex((line) => /1 tool · ✓ Write\(x.ts\)/.test(line));
+  assert.ok(card > rows.indexOf('previous conversation'));
+  assert.ok(card < rows.indexOf('final answer after tool'));
+  assert.ok(card < 19);
+  assert.equal(rows[20], '❯');
+  const nextTurn = screen(dockRender(`
+    ui.startTool('write_file'); ui.preview('Write(x.ts)', ['+ code']);
+    ui.beginTurn(); ui.say('new turn');
+  `));
+  assert.ok(nextTurn.some((line) => line.includes('Write(x.ts)')));
+  assert.ok(nextTurn.some((line) => line.includes('new turn')));
+});
+
+test('tool spinner updates its in-flow card without duplicating frames or moving the composer', () => {
+  const rows = screen(dockRender(`
+    ui.say('existing history');
+    ui.startTool('grep');
+    ui.activity('grep', '⠋ grep');
+    ui.activity('grep', '⠙ grep');
+    ui.activity('grep', '⠹ grep');
+  `));
+  assert.equal(rows.filter((line) => line.includes('grep')).length, 1);
+  assert.ok(rows.findIndex((line) => line.includes('⠹ grep')) > rows.indexOf('existing history'));
+  assert.ok(rows.findIndex((line) => line.includes('⠹ grep')) < 19);
+  assert.equal(rows[20], '❯');
+});
+
+test('in-flow tool cards survive command controls and fit tiny dock heights', () => {
+  const out = dockRender(`
+    ui.startTool('write_file'); ui.preview('Write(x.ts)', ['+ one', '+ two']);
+    ui.menu(['effort high'], 0, 0); ui.closeMenu();
+    Object.defineProperty(process.stdout, 'rows', { value: 10, configurable: true });
+    process.stdout.emit('resize');
+  `);
+  assert.ok(!out.includes('\x1b[1;1r'));
+  const rows = screen(out, 10);
+  assert.equal(rows[6], '❯');
+  assert.ok(rows.some((line) => line.includes('Write(x.ts)')));
+});
+
+test('repeated command menus do not scroll empty space or fill chat with blank lines', () => {
+  const out = dockRender(`
+    ui.say('existing answer');
+    process.stdout.write('MENU_START');
+    for (let i = 0; i < 10; i++) {
+      ui.menu(['model', 'usage', 'effort', 'help'], 0, 0);
+      ui.menu(['model'], 0, 0);
+      ui.closeMenu();
+      ui.panel(['provider usage', 'account limits']);
+      ui.closePanel();
+    }
+    process.stdout.write('MENU_END');
+  `);
+  const menuOutput = out.split('MENU_START')[1].split('MENU_END')[0];
+  assert.ok(!menuOutput.includes('\n'), 'menu layout must not write blank lines when chat has room');
+  const rows = screen(out);
+  assert.ok(rows.includes('existing answer'));
+  assert.ok(rows.some((line) => line.includes('sub  /tmp/project')));
+});
+
+test('opening controls only scrolls chat when real content needs room', () => {
+  const out = dockRender(`
+    for (let i = 0; i < 50; i++) ui.say('answer ' + i);
+    ui.menu(['first', 'second'], 1, 0);
+  `);
+  assert.equal(screen(out)[16], 'answer 49');
+  assert.equal(screen(out)[22], '› second');
+});
+
+test('command controls hide footer clutter and restore it when dismissed', () => {
+  const opened = dockRender(`
+    ui.setUsage('provider footer', 'account footer');
+    ui.setCommandMode(true);
+    ui.panel(['Usage', 'openai: 5h 80% available', 'Account limits', '60 rpm']);
+  `);
+  const rows = screen(opened);
+  assert.ok(!rows.some((line) => /provider footer|account footer|ask before writes|effort auto/.test(line)));
+  assert.equal(rows.filter((line) => line.includes('80% available')).length, 1);
+  const closed = dockRender(`
+    ui.setUsage('provider footer', 'account footer');
+    ui.setCommandMode(true); ui.panel(['Usage']);
+    ui.closePanel(); ui.setCommandMode(false);
+  `);
+  assert.equal(screen(closed)[22], 'provider footer');
+  assert.equal(screen(closed)[23], 'account footer');
+});
+
+test('queued image names stay in the footer and disappear without changing dock height', () => {
+  const queued = dockRender(`ui.setAttachments(['shot.png', 'diagram.jpg']);`);
+  const rows = screen(queued);
+  assert.equal(rows[20], '❯');
+  assert.equal(rows[22], '2 images attached · shot.png · diagram.jpg');
+  const cleared = dockRender(`ui.setAttachments(['shot.png']); ui.setAttachments([]);`);
+  assert.equal(screen(cleared)[22], 'ask before writes · effort auto · ready');
+});
+
+test('steering queue updates the existing footer without moving or clearing the draft', () => {
+  const out = dockRender(`
+    ui.setSteering(0); ui.setStatus('responding · ctrl+c stop');
+    ui.composer('openai/test', '❯ ', 'still typing', 12);
+    ui.setSteering(2);
+  `);
+  const rows = screen(out);
+  assert.equal(rows[20], '❯ still typing');
+  assert.match(rows[22], /2 steering queued · responding/);
+  const cleared = dockRender(`ui.setSteering(2); ui.setSteering(null); ui.setStatus('ready');`);
+  assert.equal(screen(cleared)[22], 'ask before writes · effort auto · ready');
+});
+
+test('queued steering appears in muted message rows and clears without moving the composer', () => {
+  const pending = dockRender(`
+    ui.setSteering(2, ['first direction', 'second direction']);
+    ui.composer('openai/test', '❯ ', 'draft', 5);
+  `);
+  const rows = screen(pending);
+  assert.equal(rows[16], '› first direction');
+  assert.equal(rows[17], '› second direction');
+  assert.match(rows[18], /pending · sent at next model call/);
+  assert.equal(rows[20], '❯ draft');
+  assert.ok(pending.includes('\x1b[48;2;56;56;56;38;2;160;160;160m› first direction'));
+  const cleared = dockRender(`ui.setSteering(1, ['queued only']); ui.setSteering(0);`);
+  assert.ok(!screen(cleared).some((row) => /queued only|pending ·/.test(row)));
+  assert.equal(screen(cleared)[20], '❯');
+  const compact = dockRender(`
+    ui.startTool('write_file'); ui.preview('Write(x.ts)', ['+ one', '+ two', '+ three']);
+    ui.setSteering(5, ['one', 'two', 'three', 'four', '界'.repeat(100)]);
+    Object.defineProperty(process.stdout, 'rows', { value: 10, configurable: true });
+    process.stdout.emit('resize');
+  `);
+  assert.equal(screen(compact, 10)[6], '❯');
+  assert.ok(!compact.includes('\x1b[1;1r'));
+  const overflow = dockRender(`ui.setSteering(5, ['one', 'two', 'three', 'four', '界'.repeat(100)]);`);
+  assert.ok(screen(overflow).some((row) => row.includes('2 earlier')));
+  assert.ok(screen(overflow).some((row) => row.endsWith('…')));
+  const noColor = dockRender(`process.env.NO_COLOR = '1'; ui.setSteering(1, ['plain pending']);`);
+  assert.ok(!noColor.slice(noColor.indexOf('plain pending') - 40).includes('\x1b[48;'));
+});
+
+test('multiple replies retain one blank separator even when model output has oversized boundary gaps', () => {
+  const out = dockRender(`
+    const { MarkdownStream } = await import('./src/markdown.ts');
+    for (const prompt of ['hi', 'e', 'edt4']) {
+      ui.submitInput('❯ ', prompt);
+      ui.say('');
+      const md = new MarkdownStream();
+      md.write('\\n\\n\\nReply to ' + prompt + '.\\n\\n\\n');
+      md.flush(); ui.endTurn();
+      ui.say('');
+    }
+  `);
+  const rows = screen(out);
+  for (const prompt of ['hi', 'e', 'edt4']) {
+    const input = rows.indexOf('❯ ' + prompt);
+    assert.ok(input >= 0);
+    assert.equal(rows[input + 1], '');
+    assert.equal(rows[input + 2], 'Reply to ' + prompt + '.');
+  }
+  assert.equal(rows.indexOf('❯ e') - rows.indexOf('Reply to hi.'), 2);
+  assert.equal(rows.indexOf('❯ edt4') - rows.indexOf('Reply to e.'), 2);
+});
+
+test('history scrolling preserves the anchored composer and viewed content during streaming', () => {
+  const scrolled = dockRender(`
+    for (let i = 0; i < 50; i++) ui.say('answer ' + i);
+    ui.composer('openai/test', '❯ ', 'draft', 5);
+    ui.scrollChat(8);
+    ui.say('new streaming answer');
+  `);
+  const rows = screen(scrolled);
+  assert.equal(rows[17], 'answer 41');
+  assert.equal(rows[20], '❯ draft');
+  assert.match(rows[22], /history · PgDn to live/);
+  const live = dockRender(`
+    for (let i = 0; i < 50; i++) ui.say('answer ' + i);
+    ui.scrollChat(8); ui.say('new answer'); ui.scrollChat(-1000);
+    ui.streamText('live'); ui.endTurn();
+  `);
+  assert.ok(screen(live).includes('new answer'));
+  assert.ok(screen(live).includes('live'));
+  assert.equal(screen(live)[20], '❯');
+  const resized = dockRender(`
+    for (let i = 0; i < 50; i++) ui.say('answer ' + i);
+    ui.scrollChat(8);
+    Object.defineProperty(process.stdout, 'rows', { value: 12, configurable: true });
+    process.stdout.emit('resize');
+  `);
+  assert.equal(screen(resized, 12)[8], '❯');
+  assert.match(screen(resized, 12)[10], /history/);
+});
+
+test('full-width streamed lines continue correctly after a viewport repaint', () => {
+  const out = dockRender(`
+    ui.streamText('x'.repeat(60));
+    process.stdout.emit('resize');
+    ui.streamText('next'); ui.endTurn();
+  `);
+  assert.ok(screen(out).includes('x'.repeat(60)));
+  assert.ok(screen(out).includes('next'));
+});
+
+test('resizing reanchors the bar and terminal shutdown restores scroll margins', () => {
+  const out = dockRender(`
+    Object.defineProperty(process.stdout, 'rows', { value: 12, configurable: true });
+    process.stdout.emit('resize');
+  `);
+  assert.ok(out.includes('\x1b[1;7r'));
+  assert.match(screen(out, 12)[7], /openai\/test/);
+  const exited = render(`
+    Object.defineProperty(process.stdin, 'isTTY', { value: true });
+    ui.welcome('openai/test', '/tmp/project');
+    ui.closeDock();
+  `);
+  assert.ok(exited.includes('\x1b[r'));
+  assert.ok(exited.includes('\x1b[?25h'));
+  assert.ok(exited.includes('\x1b[?1000h\x1b[?1006h'));
+  assert.ok(exited.includes('\x1b[?1000l\x1b[?1006l'));
+});
+
+test('width-only resize keeps partial streamed text on the same chat line', () => {
+  const out = dockRender(`
+    ui.streamText('hel');
+    process.stdout.emit('resize');
+    ui.streamText('lo');
+    ui.endTurn();
+  `);
+  assert.ok(screen(out).includes('hello'));
+});
+
+test('growing the terminal erases the former dock footprint', () => {
+  const out = dockRender(`
+    Object.defineProperty(process.stdout, 'rows', { value: 30, configurable: true });
+    process.stdout.emit('resize');
+  `);
+  const rows = screen(out, 30);
+  assert.equal(rows.filter((line) => line.includes('openai/test')).length, 1);
+  assert.equal(rows.filter((line) => line.includes('ask before writes')).length, 1);
+});
+
+test('tiny resize cancels the popup without emitting invalid scroll margins', () => {
+  const out = dockRender(`
+    ui.menu(['first', 'second'], 1, 0, () => process.stdout.write('CANCELLED'));
+    Object.defineProperty(process.stdout, 'rows', { value: 8, configurable: true });
+    process.stdout.emit('resize');
+  `);
+  assert.ok(!out.includes('\x1b[1;1r'));
+  assert.ok(out.includes('CANCELLED'));
+});