subrouter-cli 0.0.0-stage → 0.1.0

package/test/adapters.test.ts

@@ -0,0 +1,205 @@
+// OpenAI adapter tests — request building, response parsing, stream assembly.
+// The fixture was recorded live from the router by scripts/sse-harness.ts (M0).
+
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import {
+  OpenAiStreamParser,
+  mapFinishReason,
+  parseCompleteBody,
+  parseToolArgs,
+  toWireBody,
+} from '../src/adapters/openai.ts';
+import { RouterError } from '../src/client.ts';
+import type { ChatMessage, ChatRequest, StreamEvent } from '../src/types.ts';
+
+function baseRequest(overrides: Partial<ChatRequest> = {}): ChatRequest {
+  return {
+    model: 'opencode/deepseek-v4-pro',
+    dialect: 'openai',
+    messages: [{ role: 'user', content: 'hi' }],
+    system: 'you are sub',
+    stream: false,
+    ...overrides,
+  };
+}
+
+describe('toWireBody', () => {
+  it('folds the system prompt into a system message', () => {
+    const wire = toWireBody(baseRequest());
+    assert.deepEqual((wire.messages as unknown[])[0], { role: 'system', content: 'you are sub' });
+    assert.equal(wire.model, 'opencode/deepseek-v4-pro');
+    assert.equal(wire.stream, false);
+  });
+
+  it('serializes assistant tool calls with JSON-string arguments', () => {
+    const assistant: ChatMessage = {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{ id: 'call_1', name: 'read_file', arguments: { path: 'a.ts' }, argumentsJson: '{"path":"a.ts"}' }],
+    };
+    const wire = toWireBody(baseRequest({ messages: [assistant] }));
+    const msg = (wire.messages as Record<string, unknown>[])[1]; // [0] is the folded system message
+    assert.deepEqual(msg.tool_calls, [
+      { id: 'call_1', type: 'function', function: { name: 'read_file', arguments: '{"path":"a.ts"}' } },
+    ]);
+    assert.equal(msg.content, undefined); // empty content dropped on tool_calls-only turns
+  });
+
+  it('maps tool messages to role tool + tool_call_id', () => {
+    const tool: ChatMessage = { role: 'tool', content: 'result', toolCallId: 'call_1' };
+    const wire = toWireBody(baseRequest({ messages: [tool], system: '' }));
+    assert.deepEqual(wire.messages, [{ role: 'tool', tool_call_id: 'call_1', content: 'result' }]);
+  });
+
+  it('emits the tools array in function form', () => {
+    const wire = toWireBody(
+      baseRequest({
+        tools: [{ name: 'read_file', description: 'read', parameters: { type: 'object' }, requiresApproval: false }],
+      }),
+    );
+    assert.deepEqual(wire.tools, [
+      { type: 'function', function: { name: 'read_file', description: 'read', parameters: { type: 'object' } } },
+    ]);
+  });
+});
+
+describe('parseToolArgs', () => {
+  it('parses valid object JSON', () => {
+    const { arguments: args, invalid } = parseToolArgs('{"a":1}');
+    assert.deepEqual(args, { a: 1 });
+    assert.equal(invalid, false);
+  });
+  it('flags malformed JSON and arrays', () => {
+    assert.equal(parseToolArgs('not json').invalid, true);
+    assert.equal(parseToolArgs('[1,2]').invalid, true);
+    assert.equal(parseToolArgs('').arguments !== undefined, true);
+  });
+});
+
+describe('parseCompleteBody', () => {
+  it('parses a plain text response', () => {
+    const turn = parseCompleteBody({
+      choices: [{ index: 0, message: { role: 'assistant', content: 'hi' }, finish_reason: 'stop' }],
+      usage: { prompt_tokens: 9, completion_tokens: 3 },
+    });
+    assert.equal(turn.message.content, 'hi');
+    assert.equal(turn.stopReason, 'stop');
+    assert.deepEqual(turn.usage, { inputTokens: 9, outputTokens: 3 });
+  });
+
+  it('parses tool calls with lenient arguments', () => {
+    const turn = parseCompleteBody({
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: 'assistant',
+            content: '',
+            tool_calls: [
+              { id: 'c1', type: 'function', function: { name: 'echo', arguments: '{"x":1}' } },
+              { id: 'c2', type: 'function', function: { name: 'echo', arguments: 'bogus' } },
+            ],
+          },
+          finish_reason: 'tool_calls',
+        },
+      ],
+    });
+    assert.equal(turn.stopReason, 'tool_calls');
+    assert.equal(turn.message.toolCalls?.[0].name, 'echo');
+    assert.deepEqual(turn.message.toolCalls?.[0].arguments, { x: 1 });
+    assert.equal(turn.message.toolCalls?.[1].argumentsInvalid, true);
+    assert.deepEqual(turn.message.toolCalls?.[1].arguments, {});
+  });
+
+  it('rejects an invalid envelope', () => {
+    assert.throws(() => parseCompleteBody({}), RouterError);
+  });
+});
+
+describe('mapFinishReason', () => {
+  it('maps the known reasons', () => {
+    assert.equal(mapFinishReason('stop'), 'stop');
+    assert.equal(mapFinishReason('tool_calls'), 'tool_calls');
+    assert.equal(mapFinishReason('length'), 'length');
+    assert.equal(mapFinishReason('content_filter'), 'refusal');
+    assert.equal(mapFinishReason('weird'), 'unknown');
+  });
+});
+
+describe('OpenAiStreamParser', () => {
+  it('assembles text, reasoning, and chunked tool calls (live shape)', () => {
+    const parser = new OpenAiStreamParser();
+    const events: StreamEvent[] = [];
+    const feed = (payload: string): void => {
+      events.push(...parser.push(payload));
+    };
+    feed('{"choices":[{"index":0,"delta":{"role":"assistant","content":"I will"},"finish_reason":null}]}');
+    feed('{"choices":[{"index":0,"delta":{"reasoning_content":"thinking"},"finish_reason":null}]}');
+    feed('{"choices":[{"index":0,"delta":{"content":" call it."},"finish_reason":null}]}');
+    feed(
+      '{"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_1","type":"function","function":{"name":"echo","arguments":""}}]},"finish_reason":null}]}',
+    );
+    feed('{"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\\"x\\":1}"}}]},"finish_reason":null}]}');
+    feed('{"choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":10,"completion_tokens":5}}');
+
+    assert.deepEqual(
+      events.map((e) => e.kind),
+      ['text', 'reasoning', 'text', 'tool_call_start', 'tool_call_args', 'stop'],
+    );
+    const stop = events.at(-1);
+    assert.equal(stop?.kind, 'stop');
+    if (stop?.kind === 'stop') {
+      assert.equal(stop.stopReason, 'tool_calls');
+      assert.deepEqual(stop.usage, { inputTokens: 10, outputTokens: 5 });
+    }
+    const message = parser.assistantMessage();
+    assert.equal(message.content, 'I will call it.');
+    assert.equal(message.toolCalls?.[0].id, 'call_1');
+    assert.equal(message.toolCalls?.[0].name, 'echo');
+    assert.deepEqual(message.toolCalls?.[0].arguments, { x: 1 });
+  });
+
+  it('throws on an error frame', () => {
+    const parser = new OpenAiStreamParser();
+    assert.throws(() => parser.push('{"error":{"message":"bad stuff"}}'), /bad stuff/);
+  });
+
+  it('emits nothing after the stop event', () => {
+    const parser = new OpenAiStreamParser();
+    parser.push('{"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}');
+    assert.deepEqual(parser.push('{"choices":[{"index":0,"delta":{"content":"late"}}]}'), []);
+  });
+
+  it('parses the live recorded fixture end to end', () => {
+    const fixture = path.join(import.meta.dirname, 'fixtures', 'openai-tools.sse');
+    const text = fs.readFileSync(fixture, 'utf8');
+    const parser = new OpenAiStreamParser();
+    let stopReason = '';
+    let usage;
+    let sawReasoning = false;
+    for (const block of text.split('\n\n')) {
+      const line = block.trim();
+      if (!line.startsWith('data: ')) continue;
+      const payload = line.slice(6);
+      if (payload === '[DONE]') break;
+      for (const e of parser.push(payload)) {
+        if (e.kind === 'reasoning') sawReasoning = true;
+        if (e.kind === 'stop') {
+          stopReason = e.stopReason;
+          usage = e.usage;
+        }
+      }
+    }
+    assert.equal(stopReason, 'tool_calls');
+    assert.ok(usage);
+    assert.ok(sawReasoning, 'opencode models stream reasoning_content — must be surfaced');
+    const message = parser.assistantMessage();
+    assert.equal(message.toolCalls?.[0].name, 'echo');
+    assert.deepEqual(message.toolCalls?.[0].arguments, {
+      value: { message: 'Hello, world!', number: 42, valid: true },
+    });
+  });
+});

package/test/anthropic.test.ts

@@ -0,0 +1,246 @@
+// Anthropic adapter tests — hand-built fixtures in the 2023-06-01 Messages shapes
+// (the user's key has no live anthropic model, so these pin the spec).
+
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  ANTHROPIC_DEFAULT_MAX_TOKENS,
+  AnthropicStreamParser,
+  mapAnthropicStopReason,
+  parseAnthropicCompleteBody,
+  toAnthropicBody,
+} from '../src/adapters/anthropic.ts';
+import { toWireBody } from '../src/adapters/openai.ts';
+import { RouterError } from '../src/client.ts';
+import type { ChatMessage, ChatRequest, StreamEvent, ToolCall } from '../src/types.ts';
+
+type Wire = Record<string, unknown>;
+
+function baseRequest(overrides: Partial<ChatRequest> = {}): ChatRequest {
+  return {
+    model: 'anthropic/claude-sonnet-5',
+    dialect: 'anthropic',
+    messages: [{ role: 'user', content: 'hi' }],
+    system: 'you are sub',
+    stream: true,
+    ...overrides,
+  };
+}
+
+const call: ToolCall = {
+  id: 'toolu_1',
+  name: 'read_file',
+  arguments: { path: 'a.ts' },
+  argumentsJson: '{"path":"a.ts"}',
+};
+
+describe('toAnthropicBody', () => {
+  it('folds the system prompt to the top level and defaults max_tokens to 8192', () => {
+    const wire = toAnthropicBody(baseRequest());
+    assert.equal(wire.system, 'you are sub');
+    assert.equal(wire.max_tokens, ANTHROPIC_DEFAULT_MAX_TOKENS);
+    assert.deepEqual(wire.messages, [{ role: 'user', content: 'hi' }]);
+    assert.equal(wire.stream, true);
+  });
+
+  it('serializes assistant tool calls as tool_use blocks with parsed input', () => {
+    const assistant: ChatMessage = { role: 'assistant', content: 'let me look', toolCalls: [call] };
+    const wire = toAnthropicBody(baseRequest({ messages: [assistant] }));
+    assert.deepEqual((wire.messages as Wire[])[0].content, [
+      { type: 'text', text: 'let me look' },
+      { type: 'tool_use', id: 'toolu_1', name: 'read_file', input: { path: 'a.ts' } },
+    ]);
+  });
+
+  it('drops content-less assistant turns', () => {
+    const empty: ChatMessage = { role: 'assistant', content: '' };
+    const wire = toAnthropicBody(baseRequest({ messages: [empty, { role: 'user', content: 'hi' }] }));
+    assert.deepEqual(wire.messages, [{ role: 'user', content: 'hi' }]);
+  });
+
+  it('batches consecutive tool results into one user turn with is_error', () => {
+    const messages: ChatMessage[] = [
+      { role: 'tool', content: 'result a', toolCallId: 't1' },
+      { role: 'tool', content: 'failed b', toolCallId: 't2', isError: true },
+    ];
+    const wire = toAnthropicBody(baseRequest({ messages }));
+    const wireMessages = wire.messages as Wire[];
+    assert.equal(wireMessages.length, 1);
+    assert.deepEqual(wireMessages[0], {
+      role: 'user',
+      content: [
+        { type: 'tool_result', tool_use_id: 't1', content: 'result a', is_error: false },
+        { type: 'tool_result', tool_use_id: 't2', content: 'failed b', is_error: true },
+      ],
+    });
+  });
+
+  it('flushes the batch when a non-tool message intervenes', () => {
+    const messages: ChatMessage[] = [
+      { role: 'tool', content: 'a', toolCallId: 't1' },
+      { role: 'user', content: 'more context' },
+      { role: 'tool', content: 'b', toolCallId: 't2' },
+    ];
+    const wireMessages = toAnthropicBody(baseRequest({ messages })).messages as Wire[];
+    assert.deepEqual(wireMessages.map((m) => m.role), ['user', 'user', 'user']);
+    assert.deepEqual(wireMessages[0].content, [{ type: 'tool_result', tool_use_id: 't1', content: 'a', is_error: false }]);
+    assert.deepEqual(wireMessages[2].content, [{ type: 'tool_result', tool_use_id: 't2', content: 'b', is_error: false }]);
+  });
+
+  it('emits tools in input_schema form', () => {
+    const wire = toAnthropicBody(
+      baseRequest({
+        tools: [{ name: 'read_file', description: 'read', parameters: { type: 'object' }, requiresApproval: false }],
+      }),
+    );
+    assert.deepEqual(wire.tools, [{ name: 'read_file', description: 'read', input_schema: { type: 'object' } }]);
+  });
+});
+
+describe('mapAnthropicStopReason', () => {
+  it('maps the known reasons', () => {
+    assert.equal(mapAnthropicStopReason('end_turn'), 'stop');
+    assert.equal(mapAnthropicStopReason('stop_sequence'), 'stop');
+    assert.equal(mapAnthropicStopReason('tool_use'), 'tool_calls');
+    assert.equal(mapAnthropicStopReason('max_tokens'), 'length');
+    assert.equal(mapAnthropicStopReason('refusal'), 'refusal');
+    assert.equal(mapAnthropicStopReason('weird'), 'unknown');
+  });
+});
+
+describe('AnthropicStreamParser', () => {
+  it('assembles text, a tool use, and the stop event (spec shape)', () => {
+    const parser = new AnthropicStreamParser();
+    const events: StreamEvent[] = [];
+    const feed = (payload: string): void => {
+      events.push(...parser.push(payload));
+    };
+    feed('{"type":"message_start","message":{"usage":{"input_tokens":10,"output_tokens":1}}}');
+    feed('{"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}');
+    feed('{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Let me"}}');
+    feed('{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" check."}}');
+    feed('{"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"hidden"}}'); // ignored
+    feed('{"type":"content_block_stop","index":0}');
+    feed('{"type":"content_block_start","index":1,"content_block":{"type":"tool_use","id":"toolu_9","name":"read_file","input":{}}}');
+    feed('{"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"{\\"pa"}}');
+    feed('{"type":"content_block_delta","index":1,"delta":{"type":"input_json_delta","partial_json":"th\\":\\"a.ts\\"}"}}');
+    feed('{"type":"content_block_stop","index":1}');
+    feed('{"type":"message_delta","delta":{"stop_reason":"tool_use"},"usage":{"output_tokens":25}}');
+    feed('{"type":"message_stop"}');
+
+    assert.deepEqual(
+      events.map((e) => e.kind),
+      ['text', 'text', 'tool_call_start', 'tool_call_args', 'tool_call_args', 'stop'],
+    );
+    const stop = events.at(-1);
+    assert.equal(stop?.kind, 'stop');
+    if (stop?.kind === 'stop') {
+      assert.equal(stop.stopReason, 'tool_calls');
+      assert.deepEqual(stop.usage, { inputTokens: 10, outputTokens: 25 });
+    }
+    const message = parser.assistantMessage();
+    assert.equal(message.content, 'Let me check.');
+    assert.equal(message.toolCalls?.[0].id, 'toolu_9');
+    assert.equal(message.toolCalls?.[0].name, 'read_file');
+    assert.deepEqual(message.toolCalls?.[0].arguments, { path: 'a.ts' });
+  });
+
+  it('surfaces refusals as text', () => {
+    const parser = new AnthropicStreamParser();
+    const events = parser.push('{"type":"content_block_start","index":0,"content_block":{"type":"refusal","refusal":""}}');
+    assert.deepEqual(events, []);
+    events.push(...parser.push('{"type":"content_block_delta","index":0,"delta":{"type":"refusal_delta","refusal":"I cannot."}}'));
+    assert.deepEqual(events.map((e) => e.kind), ['text']);
+    assert.equal(parser.assistantMessage().content, 'I cannot.');
+  });
+
+  it('throws on an error event', () => {
+    const parser = new AnthropicStreamParser();
+    assert.throws(
+      () => parser.push('{"type":"error","error":{"type":"overloaded_error","message":"overloaded"}}'),
+      (err: unknown) => err instanceof RouterError && /overloaded/.test(err.message),
+    );
+  });
+
+  it('emits nothing after message_stop', () => {
+    const parser = new AnthropicStreamParser();
+    parser.push('{"type":"message_delta","delta":{"stop_reason":"end_turn"}}');
+    parser.push('{"type":"message_stop"}');
+    assert.deepEqual(parser.push('{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"late"}}'), []);
+  });
+});
+
+describe('parseAnthropicCompleteBody', () => {
+  it('parses text and tool_use blocks', () => {
+    const turn = parseAnthropicCompleteBody({
+      id: 'msg_1',
+      type: 'message',
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'I will read it.' },
+        { type: 'tool_use', id: 'toolu_2', name: 'read_file', input: { path: 'b.ts' } },
+      ],
+      stop_reason: 'tool_use',
+      usage: { input_tokens: 12, output_tokens: 8 },
+    });
+    assert.equal(turn.stopReason, 'tool_calls');
+    assert.equal(turn.message.content, 'I will read it.');
+    assert.deepEqual(turn.message.toolCalls?.[0].arguments, { path: 'b.ts' });
+    assert.equal(turn.message.toolCalls?.[0].argumentsJson, '{"path":"b.ts"}');
+    assert.deepEqual(turn.usage, { inputTokens: 12, outputTokens: 8 });
+  });
+
+  it('surfaces refusal blocks and maps the reason', () => {
+    const turn = parseAnthropicCompleteBody({
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'refusal', refusal: 'not allowed' }],
+      stop_reason: 'refusal',
+      usage: { input_tokens: 1, output_tokens: 2 },
+    });
+    assert.equal(turn.stopReason, 'refusal');
+    assert.equal(turn.message.content, 'not allowed');
+  });
+
+  it('throws on the error envelope', () => {
+    assert.throws(
+      () => parseAnthropicCompleteBody({ type: 'error', error: { type: 'api_error', message: 'bad key' } }),
+      (err: unknown) => err instanceof RouterError && /bad key/.test(err.message),
+    );
+  });
+});
+
+describe('round trips', () => {
+  it('an anthropic-parsed turn serializes back to both wire dialects', () => {
+    const turn = parseAnthropicCompleteBody({
+      type: 'message',
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'opening it' },
+        { type: 'tool_use', id: 'toolu_3', name: 'read_file', input: { path: 'c.ts' } },
+      ],
+      stop_reason: 'tool_use',
+      usage: { input_tokens: 3, output_tokens: 4 },
+    });
+    const anthropicWire = toAnthropicBody(baseRequest({ messages: [turn.message] })) as Wire;
+    const blocks = ((anthropicWire.messages as Wire[])[0].content as Wire[]) as Wire[];
+    assert.deepEqual(blocks[1], { type: 'tool_use', id: 'toolu_3', name: 'read_file', input: { path: 'c.ts' } });
+
+    const openaiWire = toWireBody(
+      baseRequest({ messages: [turn.message], dialect: 'openai' }),
+    );
+    const openaiMsg = (openaiWire.messages as Wire[])[1]; // [0] is the folded system message
+    assert.equal(openaiMsg.content, 'opening it');
+    assert.deepEqual(openaiMsg.tool_calls, [
+      { id: 'toolu_3', type: 'function', function: { name: 'read_file', arguments: '{"path":"c.ts"}' } },
+    ]);
+  });
+
+  it('an openai-shaped tool call round-trips through the anthropic wire', () => {
+    const assistant: ChatMessage = { role: 'assistant', content: '', toolCalls: [call] };
+    const anthropicWire = toAnthropicBody(baseRequest({ messages: [assistant] })) as Wire;
+    assert.deepEqual((anthropicWire.messages as Wire[])[0].content, [
+      { type: 'tool_use', id: 'toolu_1', name: 'read_file', input: { path: 'a.ts' } },
+    ]);
+  });
+});

package/test/auto-ui.test.ts

@@ -0,0 +1,106 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { test } from 'node:test';
+
+const root = new URL('..', import.meta.url);
+
+test('guarded auto runs routine commands; file-only/ask modes and unknown commands still prompt', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-auto-ui-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', String.raw`
+    import assert from 'node:assert/strict';
+    import fs from 'node:fs';
+    Object.defineProperty(process.stdin, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'rows', { value: 24 });
+    Object.defineProperty(process.stdout, 'columns', { value: 100 });
+    process.stdin.setRawMode = () => {};
+    process.chdir(process.env.HOME);
+    const { ui } = await import(${JSON.stringify(new URL('../src/ui.ts', import.meta.url).href)});
+    const { LineInput } = await import(${JSON.stringify(new URL('../src/lineinput.ts', import.meta.url).href)});
+    const { startRepl } = await import(${JSON.stringify(new URL('../src/repl.ts', import.meta.url).href)});
+    const requests = [], prompts = [], modes = [], cards = [];
+    let status = '';
+    const setStatus = ui.setStatus.bind(ui), setMode = ui.setMode.bind(ui), startTool = ui.startTool.bind(ui);
+    ui.setStatus = (value) => { status = value; setStatus(value); };
+    ui.setMode = (value) => { modes.push(value); setMode(value); };
+    ui.startTool = (name, preview) => { cards.push(preview); startTool(name, preview); };
+    const question = LineInput.prototype.question;
+    LineInput.prototype.question = function(prompt) { prompts.push(prompt); return question.call(this, prompt); };
+    const client = {
+      listModels: async () => [{ id: 'openai/test' }], usage: async () => ({}),
+      chat: async (req) => {
+        requests.push(structuredClone(req));
+        if (req.messages.at(-1).role === 'tool') return { message: { role: 'assistant', content: 'Done.' }, stopReason: 'stop' };
+        const user = req.messages.at(-1).content;
+        const name = user === 'file' ? 'write_file' : 'run_command';
+        const args = user === 'file' ? { path: 'new-file', content: 'hello' } : { command: user === 'risk' ? 'printf bad > marker' : 'pwd' };
+        return { message: { role: 'assistant', content: '', toolCalls: [{ id: 'c' + requests.length, name, arguments: args, argumentsJson: JSON.stringify(args) }] }, stopReason: 'tool_calls' };
+      },
+    };
+    startRepl({ client, model: 'openai/test', autoMode: true, config: { apiKey: 'synthetic-key', maxToolRounds: 25, maxOutputTokens: 8192, autoApprove: false } });
+    const key = (text) => process.stdin.emit('data', Buffer.from(text));
+    const until = async (predicate) => {
+      const deadline = Date.now() + 5000;
+      while (!predicate() && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 5));
+      assert.ok(predicate()); await new Promise(setImmediate);
+    };
+    key('routine\r'); await until(() => requests.length === 2 && status === 'ready');
+    assert.equal(prompts.length, 0);
+    assert.equal(JSON.parse(requests[1].messages.at(-1).content).status, 'completed');
+    assert.ok(cards.some((card) => card.title === 'Terminal command · auto'));
+    key('/mode files\r'); await until(() => status === 'ready');
+    key('routine\r'); await until(() => prompts.length === 1);
+    key('a\r'); await until(() => requests.length === 4 && status === 'ready');
+    assert.match(requests[3].messages.at(-1).content, /denied/);
+    key('/mode auto\r'); await until(() => status === 'ready');
+    key('risk\r'); await until(() => prompts.length === 2);
+    key('n\r'); await until(() => requests.length === 6 && status === 'ready');
+    assert.ok(!fs.existsSync('marker'));
+    key('file\r'); await until(() => requests.length === 8 && status === 'ready');
+    assert.equal(prompts.length, 2);
+    assert.equal(fs.readFileSync('new-file', 'utf8'), 'hello');
+    key('/mode\r'); await until(() => status === 'choose permission mode');
+    key('\x1b[A\x1b[A\r'); await until(() => status === 'ready');
+    assert.equal(modes.at(-1), 'ask before writes');
+    key('file\r'); await until(() => prompts.length === 3);
+    key('n\r'); await until(() => requests.length === 10 && status === 'ready');
+    assert.ok(modes.includes('files allowed · commands ask'));
+    assert.ok(modes.includes('guarded auto'));
+    key('/exit\r');
+  `], { cwd: root, encoding: 'utf8', timeout: 15000, env: { ...process.env, HOME: home, NO_COLOR: '1' } });
+  assert.equal(child.status, 0, child.stderr || String(child.error));
+  assert.ok(!child.stdout.includes('synthetic-key'));
+});
+
+test('CLI distinguishes guarded auto from file-only auto and honors file config defaults', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-auto-cli-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  fs.mkdirSync(path.join(home, '.config/subrouter-cli'), { recursive: true });
+  fs.writeFileSync(path.join(home, '.config/subrouter-cli/config.json'), JSON.stringify({ auto_approve: true }));
+  for (const [flags, expected] of [[[], 'files allowed · commands ask'], [['--auto'], 'guarded auto'], [['--auto-approve'], 'files allowed · commands ask']] as const) {
+    const child = spawnSync(process.execPath, ['--input-type=module', '-e', String.raw`
+      import assert from 'node:assert/strict';
+      process.argv = [process.execPath, 'sub', '--model', 'openai/test', ...${JSON.stringify(flags)}];
+      process.chdir(process.env.HOME);
+      const { RouterClient } = await import(${JSON.stringify(new URL('../src/client.ts', import.meta.url).href)});
+      RouterClient.prototype.listModels = async () => [{ id: 'openai/test' }];
+      RouterClient.prototype.usage = async () => ({});
+      const { ui } = await import(${JSON.stringify(new URL('../src/ui.ts', import.meta.url).href)});
+      let mode;
+      const setMode = ui.setMode.bind(ui);
+      ui.setMode = (value) => { mode = value; setMode(value); };
+      await import(${JSON.stringify(new URL('../src/index.ts', import.meta.url).href)});
+      assert.equal(mode, ${JSON.stringify(expected)});
+      process.stdin.emit('end');
+    `], { cwd: root, encoding: 'utf8', timeout: 5000, env: { ...process.env, HOME: home, SUBROUTER_API_KEY: 'synthetic-key' }, input: '' });
+    assert.equal(child.status, 0, child.stderr || String(child.error));
+    assert.ok(!child.stdout.includes('synthetic-key'));
+  }
+  const conflict = spawnSync(process.execPath, ['src/index.ts', '--auto', '--auto-approve'], { cwd: root, encoding: 'utf8', timeout: 5000, env: { ...process.env, HOME: home } });
+  assert.equal(conflict.status, 2);
+  assert.match(conflict.stderr, /not both/);
+});

package/test/chatviewport.test.ts

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { stripVTControlCharacters as plain } from 'node:util';
+import { ChatViewport } from '../src/chatviewport.ts';
+
+test('viewport clamps scrolling and preserves the viewed rows during streaming', () => {
+  const view = new ChatViewport();
+  view.append(Array.from({ length: 30 }, (_, i) => `answer ${i}`).join('\n'), 40);
+  assert.deepEqual(view.visible(40, 5), ['answer 25', 'answer 26', 'answer 27', 'answer 28', 'answer 29']);
+  view.scroll(8, 40, 5);
+  const history = view.visible(40, 5);
+  view.append('\nnew answer\nstreaming', 40);
+  assert.deepEqual(view.visible(40, 5), history);
+  view.scroll(Infinity, 40, 5);
+  assert.equal(view.visible(40, 5)[0], 'answer 0');
+  view.scroll(-Infinity, 40, 5);
+  assert.equal(view.visible(40, 5).at(-1), 'streaming');
+  view.clear();
+  assert.equal(view.offset, 0);
+  assert.deepEqual(view.visible(40, 5), ['']);
+});
+
+test('styled history reflows on resize without leaking terminal controls', () => {
+  const view = new ChatViewport();
+  view.append('\x1b[92mabcdef\n界é界\x1b[0m\x1b[2K', 10);
+  assert.deepEqual(view.rows(3).map(plain), ['abc', 'def', '界é', '界']);
+  assert.ok(view.rows(3).every((row) => row.startsWith('\x1b[92m')));
+  assert.deepEqual(view.rows(10).map(plain), ['abcdef', '界é界']);
+  assert.deepEqual(view.caret(10, 5), { row: 2, column: 6 });
+});
+
+test('viewport retains a pending full-width wrap and supports rewritten lines', () => {
+  const view = new ChatViewport();
+  view.append('12345', 5);
+  assert.deepEqual(view.caret(5, 3), { row: 1, column: 6 });
+  view.append('6', 5);
+  assert.deepEqual(view.visible(5, 3), ['12345', '6']);
+  view.append('\r\x1b[Kdone', 5);
+  assert.deepEqual(view.visible(5, 3), ['done']);
+});
+
+test('display history is bounded to the latest ten thousand logical lines', () => {
+  const view = new ChatViewport();
+  view.append(Array.from({ length: 10050 }, (_, i) => String(i)).join('\n'), 80);
+  view.scroll(Infinity, 80, 10);
+  assert.equal(view.visible(80, 10)[0], '50');
+  view.append('\nlast', 80);
+  assert.equal(view.visible(80, 10)[0], '51');
+});