mixdog 0.9.63 → 0.9.64

package/scripts/tool-tui-presentation-test.mjs

@@ -1,286 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import {
-  aggregateToolCategoryEntry,
-  formatAggregateHeader,
-  summarizeToolArgs,
-  toolWorkUnit,
-} from '../src/runtime/shared/tool-surface.mjs';
-import {
-  normalizeToolTerminalStatus,
-  toolResultTerminalStatus,
-} from '../src/runtime/shared/tool-status.mjs';
-import {
-  aggregateBucketForCategory,
-  toolCallOutcome,
-} from '../src/tui/engine/tool-result-status.mjs';
-import { createToolCardResults } from '../src/tui/engine/tool-card-results.mjs';
-import {
-  appendAgentResponseTail,
-  formatAgentResponseRaw,
-} from '../src/tui/engine/agent-response-tail.mjs';
-import {
-  agentArgsWithResultMetadata,
-  parseAgentJob,
-} from '../src/tui/engine/agent-envelope.mjs';
-import {
-  agentActionTitle,
-  toolSearchLoadedSummary,
-} from '../src/tui/components/tool-execution/surface-detail.mjs';
-
-test('tool action copy keeps Add/Delete patch verbs and human read offsets', () => {
-  assert.equal(
-    toolWorkUnit('apply_patch', { patch: '*** Begin Patch\n*** Add File: new.mjs\n+x\n*** End Patch' }).done,
-    'Created',
-  );
-  assert.equal(
-    toolWorkUnit('apply_patch', { patch: '*** Begin Patch\n*** Delete File: old.mjs\n*** End Patch' }).active,
-    'Deleting',
-  );
-  assert.match(summarizeToolArgs('read', { path: 'a.mjs', offset: 0, limit: 10 }), /lines 1-10/);
-});
-
-test('load_tool presentation distinguishes first load from already-active repeats', () => {
-  assert.equal(
-    toolSearchLoadedSummary('Loaded deferred tools: shell\nAlready active: task'),
-    'Loaded: shell · Already active: task',
-  );
-  assert.equal(
-    toolSearchLoadedSummary(JSON.stringify({
-      selected: { tools: { added: [], already: ['shell', 'task'] } },
-    })),
-    'Already active: shell, task',
-  );
-});
-
-test('Agent aggregation is batch-scoped and keeps category action wording', () => {
-  const entry = aggregateToolCategoryEntry('agent', { type: 'spawn' }, 'Agent');
-  assert.equal(formatAggregateHeader({ [entry.key]: { ...entry, count: 2 } }, { pending: false }), 'Called 2 agents');
-  assert.notEqual(
-    aggregateBucketForCategory('Agent', { agentBatch: 1 }),
-    aggregateBucketForCategory('Agent', { agentBatch: 2 }),
-  );
-});
-
-test('agent spawn cards retain resolved model metadata from split result envelopes', () => {
-  const parsed = parseAgentJob([
-    'agent task: task_worker_1',
-    'status: running',
-    'type: spawn',
-    'target: worker sess_worker_1',
-    'agent: worker',
-    'provider: openai-oauth',
-    'model: gpt-5.6-terra',
-    'preset: agent-worker',
-    'effort: high',
-  ].join('\n'));
-  const args = agentArgsWithResultMetadata({ type: 'spawn', agent: 'worker' }, parsed);
-
-  assert.equal(args.tag, 'worker');
-  assert.equal(args.provider, 'openai-oauth');
-  assert.equal(args.model, 'gpt-5.6-terra');
-  assert.equal(args.effort, 'high');
-  assert.equal(agentActionTitle(args), 'Spawn Worker (GPT-5.6-Terra, worker)');
-});
-
-test('agent model enrichment preserves explicit args and combined envelopes', () => {
-  const combined = parseAgentJob([
-    'agent task: task_worker_2',
-    'type: spawn',
-    'model: openai-oauth/gpt-5.6-terra',
-  ].join('\n'));
-  assert.equal(combined.provider, 'openai-oauth');
-  assert.equal(combined.model, 'gpt-5.6-terra');
-
-  const split = parseAgentJob([
-    'agent task: task_worker_3',
-    'provider: openai-oauth',
-    'model: gpt-5.6-terra',
-  ].join('\n'));
-  const explicit = agentArgsWithResultMetadata({
-    provider: 'anthropic',
-    model: 'claude-opus-4-6',
-  }, split);
-  assert.equal(explicit.provider, 'anthropic');
-  assert.equal(explicit.model, 'claude-opus-4-6');
-});
-
-test('non-agent task diagnostics do not enrich model args', () => {
-  const shellDiagnostics = parseAgentJob([
-    'task_id: shell_task_1',
-    'provider: openai-oauth',
-    'model: gpt-5.6-terra',
-  ].join('\n'));
-  const args = agentArgsWithResultMetadata({ type: 'shell' }, shellDiagnostics);
-
-  assert.equal(args.provider, undefined);
-  assert.equal(args.model, undefined);
-
-  const shellCombinedDiagnostics = parseAgentJob([
-    'task_id: shell_task_2',
-    'model: openai-oauth/gpt-5.6-terra',
-  ].join('\n'));
-  const combinedArgs = agentArgsWithResultMetadata({ type: 'shell' }, shellCombinedDiagnostics);
-  assert.equal(combinedArgs.provider, undefined);
-  assert.equal(combinedArgs.model, undefined);
-});
-
-test('terminal result statuses stay separate from tool-call failure accounting', () => {
-  assert.equal(normalizeToolTerminalStatus('denied'), 'denied');
-  assert.equal(toolResultTerminalStatus('[status: cancelled]\n'), 'cancelled');
-
-  const state = {
-    items: [{
-      id: 'aggregate',
-      kind: 'tool',
-      result: null,
-      count: 1,
-      completedCount: 0,
-    }],
-  };
-  const aggregate = {
-    itemId: 'aggregate',
-    calls: new Map([['call_1', { name: 'web_fetch', args: {}, category: 'Web Research' }]]),
-    nextSummarySeq: 0,
-    ensureVisible: () => {},
-  };
-  const { patchToolCardResult } = createToolCardResults({
-    getState: () => state,
-    set: () => {},
-    patchItem: (id, patch) => {
-      const index = state.items.findIndex((item) => item.id === id);
-      state.items[index] = { ...state.items[index], ...patch };
-      return true;
-    },
-    markToolCallDone: () => {},
-    updateAgentJobCard: () => {},
-    buildAgentJobCardPatch: () => ({}),
-    agentStatusState: () => ({}),
-  });
-  const card = { itemId: 'aggregate', callId: 'call_1', done: false, aggregate };
-  assert.equal(patchToolCardResult(card, {
-    tool_call_id: 'call_1',
-    content: 'status: failed\nHTTP 404 Not Found',
-  }, new Map(), new Set()), true);
-  assert.equal(state.items[0].errorCount, 0);
-  assert.equal(state.items[0].callErrorCount, 0);
-  assert.equal(aggregate.calls.get('call_1').isError, false);
-});
-
-function patchAggregate(messages) {
-  const state = { items: [{ id: 'aggregate', kind: 'tool', result: null, count: messages.length, completedCount: 0 }] };
-  const aggregate = {
-    itemId: 'aggregate',
-    calls: new Map(messages.map((message) => [message.tool_call_id, {
-      name: 'shell',
-      args: {},
-      category: 'Shell',
-    }])),
-    nextSummarySeq: 0,
-    ensureVisible: () => {},
-  };
-  const { patchToolCardResult } = createToolCardResults({
-    getState: () => state,
-    set: () => {},
-    patchItem: (id, patch) => {
-      const index = state.items.findIndex((item) => item.id === id);
-      state.items[index] = { ...state.items[index], ...patch };
-      return true;
-    },
-    markToolCallDone: () => {},
-    updateAgentJobCard: () => {},
-    buildAgentJobCardPatch: () => ({}),
-    agentStatusState: () => ({}),
-  });
-  for (const message of messages) {
-    patchToolCardResult(
-      { itemId: 'aggregate', callId: message.tool_call_id, done: false, aggregate },
-      message,
-      new Map(),
-      new Set(),
-    );
-  }
-  return state.items[0];
-}
-
-test('exit detail stays successful and does not inflate Ok or Failed counts', () => {
-  const exit = 'Error: [shell-run-failed] [exit code: 1]\ncommand output';
-  const exitOnly = patchAggregate([{ tool_call_id: 'exit', content: exit, toolKind: 'error' }]);
-  assert.equal(exitOnly.errorCount, 0);
-  assert.equal(exitOnly.callErrorCount, 0);
-  assert.equal(exitOnly.exitErrorCount, 1);
-  assert.equal(exitOnly.result, 'Exit 1');
-
-  const mixed = patchAggregate([
-    { tool_call_id: 'failed', content: 'transport unavailable', isError: true },
-    { tool_call_id: 'exit', content: exit, isError: true },
-  ]);
-  assert.equal(mixed.errorCount, 1);
-  assert.equal(mixed.callErrorCount, 1);
-  assert.equal(mixed.exitErrorCount, 1);
-  assert.equal(mixed.result, '1 Failed · 1 Exit');
-});
-
-test('eager call outcome uses only envelope failure metadata', () => {
-  const exit = 'Error: [shell-run-failed] [exit code: 1]';
-  assert.equal(toolCallOutcome({ content: 'Error: domain failure' }, 'Error: domain failure').isCallError, false);
-  assert.equal(toolCallOutcome({ isError: true, content: 'ok-looking body' }, 'ok-looking body').isCallError, true);
-  assert.deepEqual(toolCallOutcome({ toolKind: 'error' }, exit), { isCallError: false, isExitError: true, exitCode: 1 });
-  assert.deepEqual(toolCallOutcome({ isError: true }, exit), { isCallError: false, isExitError: true, exitCode: 1 });
-  assert.equal(toolCallOutcome({ isError: true }, 'Error: [shell-run-failed] [timeout: 1s]').isCallError, true);
-});
-
-test('tail response aggregation is ordered, idempotent, and boundary-safe', () => {
-  const first = {
-    kind: 'tool',
-    agentDirection: 'inbound',
-    agentResponseKey: 'one',
-    agentResponseHasBody: true,
-    agentResponseEntries: [{ key: 'one', raw: 'body one', result: 'one', hasBody: true, isError: false }],
-  };
-  const secondPatch = appendAgentResponseTail(first, {
-    key: 'two', args: { type: 'result' }, rawResult: 'body two', result: 'two', hasBody: true,
-  }, 1);
-  const second = { ...first, ...secondPatch };
-  const thirdPatch = appendAgentResponseTail(second, {
-    key: 'three', args: { type: 'result' }, rawResult: 'body three', result: 'three', hasBody: true,
-  }, 2);
-  assert.equal(thirdPatch.count, 3);
-  assert.equal(
-    thirdPatch.rawResult,
-    '1. agent\nbody one\n\n2. agent\nbody two\n\n3. agent\nbody three',
-  );
-  const retryPatch = appendAgentResponseTail({ ...second, ...thirdPatch }, {
-    key: 'two', args: { type: 'result' }, rawResult: 'body two retry', result: 'two retry', hasBody: true,
-  }, 3);
-  assert.equal(retryPatch.count, 3);
-  assert.match(retryPatch.rawResult, /2\. agent\nbody two retry/);
-  assert.equal(appendAgentResponseTail({ kind: 'user' }, {
-    key: 'four', rawResult: 'body four', result: 'four', hasBody: true,
-  }), null);
-  assert.equal(formatAgentResponseRaw(retryPatch.agentResponseEntries).match(/\d+\. agent/g).length, 3);
-});
-
-test('failure preview upgrades its tail entry, but a boundary forces a new body card', () => {
-  const failurePreview = {
-    kind: 'tool',
-    agentDirection: 'inbound',
-    agentResponseKey: 'task_1',
-    agentResponseHasBody: false,
-    agentResponseEntries: [{
-      key: 'task_1', raw: 'failed preview', result: 'failed', hasBody: false, isError: true,
-    }],
-  };
-  const upgrade = appendAgentResponseTail(failurePreview, {
-    key: 'task_1', args: { type: 'result' }, rawResult: 'final body', result: 'final', hasBody: true, isError: false,
-  }, 1);
-  assert.equal(upgrade.count, 1);
-  assert.equal(upgrade.rawResult, '1. agent\nfinal body');
-  assert.equal(upgrade.isError, false);
-
-  const boundary = appendAgentResponseTail({ kind: 'assistant', text: 'intervening text' }, {
-    key: 'task_1', args: { type: 'result' }, rawResult: 'final body', result: 'final', hasBody: true,
-  });
-  assert.equal(boundary, null);
-});

package/scripts/toolcall-args-test.mjs

@@ -1,239 +0,0 @@
-#!/usr/bin/env node
-// Regression tests pinning the native-provider (OpenAI-compat / claude-code / opencode)
-// tool_call arguments contract: completed-but-malformed arguments JSON is NEVER
-// thrown (which would kill the turn) NOR silently swallowed to {}. With a finish
-// signal observed it is surfaced as an invalid-args MARKER carried on the
-// arguments slot, so the dispatch loop feeds the parse error back to the model
-// as an is_error tool_result and the model self-corrects in the SAME turn.
-// Without a finish signal (mid-stream truncation) it remains a retryable
-// TruncatedStreamError — that transient behavior is deliberately preserved.
-// Unit-test style: synthetic inputs fed
-// directly to the exported parser, asserting the resulting outcome — no
-// network, no model.
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-import {
-    parseCompletedToolCallArgumentsJson,
-    toolCallsFromStreamAcc,
-    isInvalidToolArgsMarker,
-    formatInvalidToolArgsResult,
-} from '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs';
-import { parseSSEStream } from '../src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs';
-import { classifyError } from '../src/runtime/agent/orchestrator/providers/retry-classifier.mjs';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const STREAM_SRC = resolve(__dirname, '../src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs');
-const UTF8 = new TextEncoder();
-
-// Captures the synchronous throw of `fn` and returns the Error, failing if none.
-function captureThrow(fn) {
-    try {
-        const v = fn();
-        assert.fail(`expected throw, got resolved value: ${JSON.stringify(v)}`);
-    } catch (err) {
-        assert.ok(err instanceof Error, 'thrown value must be an Error');
-        return err;
-    }
-}
-
-test('A: valid arguments JSON parses to the intended object', () => {
-    const out = parseCompletedToolCallArgumentsJson(
-        '{"pattern":"x","path":"src"}', 'test', { finishReason: 'stop' });
-    assert.deepEqual(out, { pattern: 'x', path: 'src' });
-});
-
-test('B: empty/missing arguments default to {}', () => {
-    assert.deepEqual(parseCompletedToolCallArgumentsJson('', 'test', { finishReason: 'stop' }), {});
-    assert.deepEqual(parseCompletedToolCallArgumentsJson(null, 'test', { finishReason: 'stop' }), {});
-    assert.deepEqual(parseCompletedToolCallArgumentsJson(undefined, 'test'), {});
-});
-
-test('C: bareword JSON with finishReason → invalid-args marker (no throw, no salvage)', () => {
-    const bareword = '{"pattern": dispatchAiWrapped, "path": "src/agent"}';
-    const out = parseCompletedToolCallArgumentsJson(bareword, 'test', { finishReason: 'stop' });
-    assert.equal(isInvalidToolArgsMarker(out), true);
-    assert.equal(out.__invalidToolArgs, true);
-    assert.equal(out.__rawArguments, bareword);
-    assert.equal(typeof out.__parseError, 'string');
-    assert.ok(out.__parseError.length > 0, 'parse error message must be carried');
-    // Model-facing tool_result text uses the shared invalid-args template.
-    const msg = formatInvalidToolArgsResult({ name: 'grep', arguments: out });
-    assert.match(msg, /invalid JSON/);
-    assert.match(msg, /Re-issue this tool call with valid JSON arguments/);
-});
-
-test('C: bareword JSON without finishReason → retryable TruncatedStreamError', () => {
-    const bareword = '{"pattern": dispatchAiWrapped, "path": "src/agent"}';
-    // meta omitted entirely
-    const err1 = captureThrow(() => parseCompletedToolCallArgumentsJson(bareword, 'test'));
-    assert.equal(err1.name, 'TruncatedStreamError');
-    assert.equal(err1.code, 'TRUNCATED_STREAM');
-    assert.equal(err1.truncatedStream, true);
-    // meta present but finishReason unset
-    const err2 = captureThrow(() =>
-        parseCompletedToolCallArgumentsJson(bareword, 'test', { id: 'call_1', name: 'grep' }));
-    assert.equal(err2.name, 'TruncatedStreamError');
-    assert.equal(err2.code, 'TRUNCATED_STREAM');
-    assert.equal(err2.truncatedStream, true);
-});
-
-test('D: fully malformed "{" splits on finishReason just like bareword', () => {
-    const marker = parseCompletedToolCallArgumentsJson('{', 'test', { finishReason: 'stop' });
-    assert.equal(isInvalidToolArgsMarker(marker), true);
-    assert.equal(marker.__rawArguments, '{');
-
-    const transient = captureThrow(() =>
-        parseCompletedToolCallArgumentsJson('{', 'test'));
-    assert.equal(transient.name, 'TruncatedStreamError');
-    assert.equal(transient.code, 'TRUNCATED_STREAM');
-    assert.equal(transient.truncatedStream, true);
-});
-
-test('E: source no longer contains any salvageBarewordJson reference', () => {
-    const src = readFileSync(STREAM_SRC, 'utf8');
-    assert.equal(src.includes('salvageBarewordJson'), false,
-        'salvage helper must be fully removed');
-});
-
-// Stream-accumulation path: synthetic per-index accumulator + a parseToolCalls
-// shim that delegates to the real parser (same wiring as openai-compat.mjs).
-function parseToolCallsShim(choice, label) {
-    const calls = choice.message?.tool_calls;
-    if (!calls?.length) return undefined;
-    const finishReason = choice.finish_reason || null;
-    return calls
-        .filter((tc) => tc.type === 'function')
-        .map((tc) => ({
-            id: tc.id,
-            name: tc.function.name,
-            arguments: parseCompletedToolCallArgumentsJson(
-                tc.function.arguments, label,
-                { id: tc.id, name: tc.function.name, finishReason }),
-        }));
-}
-
-test('stream acc: valid accumulated arguments parse through to a tool call', () => {
-    const acc = new Map();
-    acc.set('n:0', {
-        id: 'call_a', type: 'function',
-        function: { name: 'grep', arguments: '{"pattern":"x","path":"src"}' },
-        _order: 1,
-    });
-    const out = toolCallsFromStreamAcc(acc, parseToolCallsShim, 'test', 'stop');
-    assert.deepEqual(out, [{ id: 'call_a', name: 'grep', arguments: { pattern: 'x', path: 'src' } }]);
-});
-
-test('stream acc: bareword with finish_reason → invalid-args marker on the call (no throw)', () => {
-    const acc = new Map();
-    acc.set('n:0', {
-        id: 'call_b', type: 'function',
-        function: { name: 'grep', arguments: '{"pattern": dispatchAiWrapped, "path": "src/agent"}' },
-        _order: 1,
-    });
-    const out = toolCallsFromStreamAcc(acc, parseToolCallsShim, 'test', 'stop');
-    assert.equal(Array.isArray(out), true);
-    assert.equal(out.length, 1);
-    assert.equal(out[0].id, 'call_b');
-    assert.equal(out[0].name, 'grep');
-    assert.equal(isInvalidToolArgsMarker(out[0].arguments), true);
-});
-
-test('retry-classifier: truncated stream (no finish) → transient (preserved behavior)', () => {
-    // The invalid-args marker is no longer a thrown Error, so there is nothing
-    // for classifyError to route — the dispatch loop handles it as a
-    // tool_result. Only the mid-stream truncation path still throws, and it
-    // must remain transient/retryable.
-    const transient = captureThrow(() =>
-        parseCompletedToolCallArgumentsJson('{', 'test'));
-    assert.equal(classifyError(transient), 'transient');
-});
-
-function responseFromSseText(text) {
-    return {
-        body: new ReadableStream({
-            start(controller) {
-                controller.enqueue(UTF8.encode(text));
-                controller.close();
-            },
-        }),
-    };
-}
-
-function livePingOnlyResponse(intervalMs = 5) {
-    let timer = null;
-    return {
-        body: new ReadableStream({
-            start(controller) {
-                timer = setInterval(() => {
-                    try { controller.enqueue(UTF8.encode(':ping\n\n')); }
-                    catch { if (timer) clearInterval(timer); }
-                }, intervalMs);
-            },
-            cancel() {
-                if (timer) clearInterval(timer);
-            },
-        }),
-    };
-}
-
-test('anthropic SSE: comments do not count as stream progress', async () => {
-    const state = { firstMessageTimeoutMs: 100 };
-    const progressKinds = [];
-    const result = await parseSSEStream(
-        responseFromSseText([
-            ':ping',
-            '',
-            'event: message_start',
-            'data: {"type":"message_start","message":{"model":"claude-test","usage":{"input_tokens":1}}}',
-            '',
-            'event: content_block_delta',
-            'data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"hi"}}',
-            '',
-            'event: message_stop',
-            'data: {"type":"message_stop"}',
-            '',
-        ].join('\n')),
-        null,
-        null,
-        (kind) => progressKinds.push(kind),
-        null,
-        state,
-        null,
-    );
-    assert.equal(result.content, 'hi');
-    assert.deepEqual(
-        progressKinds,
-        ['transport', 'semantic', 'text'],
-        'the comment emits nothing; message_start and text each report only their exact kinds',
-    );
-});
-
-test('anthropic SSE: ping-only stream times out before empty-stream guard can hang', async () => {
-    const controller = new AbortController();
-    const progressKinds = [];
-    await assert.rejects(
-        () => parseSSEStream(
-            livePingOnlyResponse(),
-            controller.signal,
-            (reason) => controller.abort(reason),
-            (kind) => progressKinds.push(kind),
-            null,
-            { firstMessageTimeoutMs: 30 },
-            null,
-        ),
-        (err) => {
-            assert.equal(err.code, 'EEMPTYSTREAM');
-            assert.equal(err.isEmptyStream, true);
-            assert.equal(err.firstByteTimeout, true);
-            return true;
-        },
-    );
-    assert.deepEqual(
-        progressKinds,
-        [],
-        'ping-only SSE must emit no transport, semantic, or content progress',
-    );
-});

package/scripts/tui-ambiguous-width-test.mjs

@@ -1,113 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import sliceAnsi from 'slice-ansi';
-import stringWidth from 'string-width';
-
-// Make the Windows Terminal policy deterministic on every test host. Dynamic
-// imports matter because both policy copies resolve the gate once at load.
-process.env.MIXDOG_TUI_AMBIGUOUS_WIDE = '1';
-
-const [{ displayStringWidth }, {
-  default: wrapText,
-  sliceTextByDisplayWidth,
-  sliceTextByDisplayWidthWithPolicy,
-}, { default: Output }] = await Promise.all([
-  import('../vendor/ink/build/display-width.js'),
-  import('../vendor/ink/build/wrap-text.js'),
-  import('../vendor/ink/build/output.js'),
-]);
-
-const BODY = '①첫째 ②둘째 ③셋째 한국어 본문 텍스트가 이어집니다';
-
-test('Windows Terminal wide glyph wrapping keeps every transcript body line in budget', () => {
-  const budget = 12;
-  const lines = wrapText(BODY, budget, 'wrap').split('\n');
-  assert.ok(lines.length > 1, 'harness input must wrap');
-  for (const line of lines) {
-    assert.ok(
-      displayStringWidth(line) <= budget,
-      `${JSON.stringify(line)} is ${displayStringWidth(line)} cells (budget ${budget})`,
-    );
-  }
-});
-
-test('Output materializes the reserved cell after a policy-widened glyph', () => {
-  const text = '②{ M }';
-  assert.equal(stringWidth(text), 6, 'plain/native cursor advance is the broken 1-cell baseline');
-  assert.equal(displayStringWidth(text), 7, 'Ink layout reserves two cells for ②');
-
-  const output = new Output({ width: 20, height: 1 });
-  output.write(0, 0, text, { transformers: [] });
-  const rendered = output.get().output;
-
-  assert.equal(rendered, '② { M }', 'serialized bytes must advance over the reserved cell');
-  assert.equal(stringWidth(rendered), 7, 'emitted terminal cursor width matches the 7-cell layout');
-
-  const excluded = new Output({ width: 20, height: 1 });
-  excluded.write(0, 0, '└A ←B ↻C', { transformers: [] });
-  assert.equal(excluded.get().output, '└A ←B ↻C', 'box/figure glyphs must not gain padding');
-});
-
-test('horizontal output clipping uses the wide-glyph display columns', () => {
-  const budget = 12;
-  const output = new Output({ width: 40, height: 1 });
-  output.clip({ x1: 0, x2: budget });
-  output.write(0, 0, BODY, { transformers: [] });
-  output.unclip();
-
-  const rendered = output.get().output;
-  assert.ok(
-    stringWidth(rendered) <= budget,
-    `${JSON.stringify(rendered)} escaped clip at ${stringWidth(rendered)} emitted cells`,
-  );
-});
-
-test('left-edge clipping drops a glyph intersected by x1 and keeps mixed Korean text aligned', () => {
-  const output = new Output({ width: 40, height: 1 });
-  output.clip({ x1: 3, x2: 15 });
-  output.write(0, 0, '가①나②다③ 한국어', { transformers: [] });
-  output.unclip();
-
-  const rendered = output.get().output;
-  assert.ok(rendered.startsWith('   나'), JSON.stringify(rendered));
-  assert.ok(stringWidth(rendered) <= 15);
-});
-
-test('one-cell clip drops a two-cell circled digit instead of crossing x2', () => {
-  const output = new Output({ width: 10, height: 1 });
-  output.clip({ x1: 0, x2: 1 });
-  output.write(0, 0, '①A', { transformers: [] });
-  output.unclip();
-
-  const rendered = output.get().output;
-  assert.equal(rendered, '');
-  assert.ok(displayStringWidth(rendered) <= 1);
-});
-
-test('policy-off and no-problem slices preserve upstream slice-ansi bytes', () => {
-  const styledProblem = '\x1b[31m①AB\x1b[39m';
-  assert.equal(
-    sliceTextByDisplayWidthWithPolicy(styledProblem, 0, 2, false),
-    sliceAnsi(styledProblem, 0, 2),
-  );
-
-  const styledPlain = '\x1b[31mplain\x1b[39m';
-  assert.equal(
-    sliceTextByDisplayWidth(styledPlain, 1, 4),
-    sliceAnsi(styledPlain, 1, 4),
-  );
-
-  const excludedArrows = '\x1b[36m←↑→↓ ↻ tail\x1b[39m';
-  assert.equal(
-    sliceTextByDisplayWidth(excludedArrows, 1, 7),
-    sliceAnsi(excludedArrows, 1, 7),
-  );
-});
-
-test('left clipping re-opens parameterized OSC 8 hyperlinks', () => {
-  const open = '\x1b]8;id=x;https://example.test\x07';
-  const linked = `${open}가①나\x1b]8;;\x07`;
-  const sliced = sliceTextByDisplayWidth(linked, 2, 6);
-  assert.ok(sliced.startsWith(open), JSON.stringify(sliced));
-  assert.match(sliced, /①나/);
-});