mixdog 0.7.18 → 0.8.0

package/scripts/io-complex-smoke.mjs

@@ -1,667 +0,0 @@
-#!/usr/bin/env node
-/**
- * Complex I/O smoke suite for Mixdog builtin read/edit behavior.
- *
- * Usage:
- *   node scripts/io-complex-smoke.mjs
- *   MIXDOG_SMOKE_ROOT=C:\path\to\cache\mixdog\0.x.y node scripts/io-complex-smoke.mjs
- *
- * The suite imports builtin.mjs from MIXDOG_SMOKE_ROOT when provided, while
- * keeping all fixture files and read snapshots inside fresh temp directories.
- */
-
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const SOURCE_ROOT = resolve(HERE, '..');
-const PLUGIN_ROOT = resolve(process.env.MIXDOG_SMOKE_ROOT || SOURCE_ROOT);
-const WORKDIR = join(tmpdir(), `mixdog-io-complex-work-${process.pid}-${Date.now()}`);
-const DATA_DIR = join(tmpdir(), `mixdog-io-complex-data-${process.pid}-${Date.now()}`);
-const BASE_SCOPE = `io-complex-${process.pid}-${Date.now()}`;
-
-process.env.CLAUDE_PLUGIN_ROOT = PLUGIN_ROOT;
-process.env.CLAUDE_PLUGIN_DATA = DATA_DIR;
-process.env.MIXDOG_HINT_LEVEL ||= 'normal';
-
-const { parseJsonNextCalls } = await import(pathToFileURL(join(SOURCE_ROOT, 'src/agent/orchestrator/tools/next-call-utils.mjs')).href);
-const builtinUrl = pathToFileURL(join(PLUGIN_ROOT, 'src/agent/orchestrator/tools/builtin.mjs')).href;
-const { executeBuiltinTool } = await import(builtinUrl);
-const patchUrl = pathToFileURL(join(PLUGIN_ROOT, 'src/agent/orchestrator/tools/patch.mjs')).href;
-const { executePatchTool, closeNativePatchServerForTests } = await import(patchUrl);
-const readDedupUrl = pathToFileURL(join(PLUGIN_ROOT, 'src/agent/orchestrator/session/read-dedup.mjs')).href;
-const { extractTouchedPathsFromPatch } = await import(readDedupUrl);
-
-let passed = 0;
-let failed = 0;
-
-mkdirSync(WORKDIR, { recursive: true });
-mkdirSync(DATA_DIR, { recursive: true });
-
-console.log(`[io-smoke] pluginRoot=${PLUGIN_ROOT}`);
-console.log(`[io-smoke] workdir=${WORKDIR}`);
-
-await scenario('parallel read array', async (scope) => {
-    put('read-array/a.txt', 'one\ntwo\nthree\n');
-    const out = await tool('read', { path: ['read-array/a.txt', 'read-array/a.txt'] }, scope);
-    expectIncludes(out, 'one');
-    expectIncludes(out, 'three');
-});
-
-await scenario('object-array same-file ranges', async (scope) => {
-    put('ranges.txt', rangeLines('range-line', 8));
-    const out = await tool('read', {
-        path: [
-            { path: 'ranges.txt', offset: 0, limit: 2 },
-            { path: 'ranges.txt', offset: 4, limit: 2 },
-        ],
-    }, scope);
-    expectIncludes(out, 'range-line-1');
-    expectIncludes(out, 'range-line-5');
-});
-
-await scenario('short unseen gap edit now succeeds (read-window gate retired)', async (scope) => {
-    put('gap-short.txt', linesWith(30, 20, 'xx'));
-    await tool('read', { path: 'gap-short.txt', offset: 0, limit: 2 }, scope);
-    const out = await tool('edit', { path: 'gap-short.txt', old_string: 'xx', new_string: 'yy' }, scope);
-    expectIncludes(out, 'Edited:');
-    expectTrue(!String(out).includes('next_call:'), out);
-    expectIncludes(get('gap-short.txt'), 'yy');
-});
-
-await scenario('strong unique unseen gap auto-covers', async (scope) => {
-    const oldText = 'AUTO_COVER_TARGET_alpha_beta_gamma_1234567890';
-    put('gap-strong.txt', linesWith(30, 20, oldText));
-    await tool('read', { path: 'gap-strong.txt', offset: 0, limit: 2 }, scope);
-    const out = await tool('edit', { path: 'gap-strong.txt', old_string: oldText, new_string: 'AUTO_COVER_REPLACED' }, scope);
-    expectIncludes(out, 'Edited:');
-    expectIncludes(get('gap-strong.txt'), 'AUTO_COVER_REPLACED');
-});
-
-await scenario('large edit lands without route hint', async (scope) => {
-    const oldBlock = rangeLines('large-old', 34) + 'large-old-target\n';
-    const newBlock = oldBlock.replace('large-old-target', 'large-new-target');
-    put('large-edit-auto.txt', `before\n${oldBlock}after\n`);
-    const out = await tool('edit', {
-        path: 'large-edit-auto.txt',
-        old_string: oldBlock,
-        new_string: newBlock,
-    }, scope);
-    expectIncludes(out, 'Edited: large-edit-auto.txt');
-    expectIncludes(get('large-edit-auto.txt'), 'large-new-target');
-});
-
-await scenario('large delete lands without route hint', async (scope) => {
-    const oldBlock = rangeLines('delete-large', 31);
-    put('large-delete-auto.txt', `before\n${oldBlock}after\n`);
-    const out = await tool('edit', {
-        path: 'large-delete-auto.txt',
-        old_string: oldBlock,
-        new_string: '',
-    }, scope);
-    expectIncludes(out, 'Edited: large-delete-auto.txt');
-    expectEquals(get('large-delete-auto.txt'), 'before\nafter\n');
-});
-
-await scenario('replace_all unseen gap edit now succeeds (read-window gate retired)', async (scope) => {
-    const oldText = 'REPLACE_ALL_TARGET_alpha_beta_gamma_1234567890';
-    put('gap-replace-all.txt', linesWith(30, 20, oldText));
-    await tool('read', { path: 'gap-replace-all.txt', offset: 0, limit: 2 }, scope);
-    const out = await tool('edit', {
-        path: 'gap-replace-all.txt',
-        old_string: oldText,
-        new_string: 'REPLACE_ALL_CHANGED',
-        replace_all: true,
-    }, scope);
-    expectIncludes(out, 'Edited:');
-    expectIncludes(get('gap-replace-all.txt'), 'REPLACE_ALL_CHANGED');
-});
-
-await scenario('cross-file batch preflight rollback', async (scope) => {
-    put('batch-rb/a.txt', 'alpha\n');
-    put('batch-rb/b.txt', 'beta\n');
-    await tool('read', { path: ['batch-rb/a.txt', 'batch-rb/b.txt'] }, scope);
-    const out = await tool('edit', {
-        edits: [
-            { path: 'batch-rb/a.txt', old_string: 'alpha', new_string: 'ALPHA' },
-            { path: 'batch-rb/b.txt', old_string: 'missing', new_string: 'BETA' },
-        ],
-    }, scope);
-    expectIncludes(out, 'batch edit preflight failed');
-    expectEquals(get('batch-rb/a.txt'), 'alpha\n');
-    expectEquals(get('batch-rb/b.txt'), 'beta\n');
-});
-
-await scenario('cross-file batch success', async (scope) => {
-    put('batch-ok/a.txt', 'alpha\n');
-    put('batch-ok/b.txt', 'beta\n');
-    await tool('read', { path: ['batch-ok/a.txt', 'batch-ok/b.txt'] }, scope);
-    const out = await tool('edit', {
-        edits: [
-            { path: 'batch-ok/a.txt', old_string: 'alpha', new_string: 'ALPHA' },
-            { path: 'batch-ok/b.txt', old_string: 'beta', new_string: 'BETA' },
-        ],
-    }, scope);
-    expectIncludes(out, 'OK batch-ok/a.txt');
-    expectIncludes(out, 'OK batch-ok/b.txt');
-    expectEquals(get('batch-ok/a.txt'), 'ALPHA\n');
-    expectEquals(get('batch-ok/b.txt'), 'BETA\n');
-});
-
-await scenario('same-file sequential multi-edit', async (scope) => {
-    put('multi-seq.txt', 'first\nsecond\n');
-    await tool('read', { path: 'multi-seq.txt' }, scope);
-    const out = await tool('edit', {
-        path: 'multi-seq.txt',
-        edits: [
-            { old_string: 'first', new_string: 'FIRST' },
-            { old_string: 'second', new_string: 'SECOND' },
-        ],
-    }, scope);
-    expectIncludes(out, 'Edited:');
-    expectEquals(get('multi-seq.txt'), 'FIRST\nSECOND\n');
-});
-
-await scenario('same-file multi-edit atomic failure', async (scope) => {
-    put('multi-fail.txt', 'first\nsecond\n');
-    await tool('read', { path: 'multi-fail.txt' }, scope);
-    const out = await tool('edit', {
-        path: 'multi-fail.txt',
-        edits: [
-            { old_string: 'first', new_string: 'FIRST' },
-            { old_string: 'missing', new_string: 'MISSING' },
-        ],
-    }, scope);
-    expectIncludes(out, 'Error [code 8]');
-    expectEquals(get('multi-fail.txt'), 'first\nsecond\n');
-});
-
-await scenario('code8 exposes compact current candidate', async (scope) => {
-    put('candidate.txt', 'root\n    value: 1\nend\n');
-    await tool('read', { path: 'candidate.txt' }, scope);
-    const out = await tool('edit', { path: 'candidate.txt', old_string: 'value: 1\nmissing-end', new_string: 'value: 2\nmissing-end' }, scope);
-    expectIncludes(out, 'Error [code 8]');
-    expectTrue(!String(out).includes('retry_call:'), out);
-    expectTrue(!String(out).includes('current old_string candidate'), out);
-});
-
-await scenario('parallel different-file edits', async (scope) => {
-    for (const name of ['a', 'b', 'c']) put(`parallel-diff/${name}.txt`, `${name}-old\n`);
-    await tool('read', { path: ['parallel-diff/a.txt', 'parallel-diff/b.txt', 'parallel-diff/c.txt'] }, scope);
-    const outs = await Promise.all(['a', 'b', 'c'].map((name) =>
-        tool('edit', { path: `parallel-diff/${name}.txt`, old_string: `${name}-old`, new_string: `${name}-new` }, scope)
-    ));
-    for (const out of outs) expectIncludes(out, 'Edited:');
-    for (const name of ['a', 'b', 'c']) expectEquals(get(`parallel-diff/${name}.txt`), `${name}-new\n`);
-});
-
-await scenario('parallel same-file different-target multi-edits serialize', async (scope) => {
-    put('parallel-same-diff.txt', 'left\nmiddle\nright\n');
-    await tool('read', { path: 'parallel-same-diff.txt' }, scope);
-    const outs = await Promise.all([
-        tool('edit', { edits: [{ path: 'parallel-same-diff.txt', old_string: 'left', new_string: 'LEFT' }] }, scope),
-        tool('edit', { edits: [{ path: 'parallel-same-diff.txt', old_string: 'right', new_string: 'RIGHT' }] }, scope),
-    ]);
-    for (const out of outs) expectIncludes(out, 'Edited:');
-    expectEquals(get('parallel-same-diff.txt'), 'LEFT\nmiddle\nRIGHT\n');
-});
-
-await scenario('parallel same-file same-target conflicts cleanly', async (scope) => {
-    put('parallel-same-target.txt', 'same\nother\n');
-    await tool('read', { path: 'parallel-same-target.txt' }, scope);
-    const outs = await Promise.all([
-        tool('edit', { edits: [{ path: 'parallel-same-target.txt', old_string: 'same', new_string: 'SAME_A' }] }, scope),
-        tool('edit', { edits: [{ path: 'parallel-same-target.txt', old_string: 'same', new_string: 'SAME_B' }] }, scope),
-    ]);
-    expectEquals(outs.filter((out) => String(out).includes('Edited:')).length, 1);
-    expectEquals(outs.filter((out) => String(out).includes('Error [code 8]')).length, 1);
-    const finalText = get('parallel-same-target.txt');
-    expectTrue(finalText === 'SAME_A\nother\n' || finalText === 'SAME_B\nother\n', finalText);
-});
-
-await scenario('concurrent cross-file batches avoid mixed partial state', async (scope) => {
-    put('batch-race/a.txt', 'a1\n');
-    put('batch-race/b.txt', 'b1\n');
-    await tool('read', { path: ['batch-race/a.txt', 'batch-race/b.txt'] }, scope);
-    const batchA = tool('edit', {
-        edits: [
-            { path: 'batch-race/a.txt', old_string: 'a1', new_string: 'a2' },
-            { path: 'batch-race/b.txt', old_string: 'b1', new_string: 'b2' },
-        ],
-    }, scope);
-    const batchB = tool('edit', {
-        edits: [
-            { path: 'batch-race/a.txt', old_string: 'a1', new_string: 'a3' },
-            { path: 'batch-race/b.txt', old_string: 'b1', new_string: 'b3' },
-        ],
-    }, scope);
-    const outs = await Promise.all([batchA, batchB]);
-    expectEquals(outs.filter((out) => !String(out).startsWith('Error:')).length, 1);
-    const a = get('batch-race/a.txt');
-    const b = get('batch-race/b.txt');
-    expectTrue((a === 'a2\n' && b === 'b2\n') || (a === 'a3\n' && b === 'b3\n'), `a=${JSON.stringify(a)} b=${JSON.stringify(b)}`);
-});
-
-// c14b3d0 friction fix: a stale snapshot whose old_string is also absent from
-// CURRENT disk bytes reports plain not-found against current content (code 8,
-// with recovery context) instead of forcing a re-read turn via code 7.
-await scenario('stale snapshot with vanished old_string returns code 8', async (scope) => {
-    put('stale.txt', 'original\n');
-    await tool('read', { path: 'stale.txt' }, scope);
-    await sleep(50);
-    put('stale.txt', 'changed\n');
-    await sleep(50);
-    const out = await tool('edit', { path: 'stale.txt', old_string: 'original', new_string: 'edited' }, scope);
-    expectIncludes(out, 'Error [code 8]');
-    expectIncludes(out, 'file changed since read');
-});
-
-await scenario('stale snapshot unique target auto-refreshes', async (scope) => {
-    put('stale-preview.txt', 'keep\nTARGET\n');
-    await tool('read', { path: 'stale-preview.txt' }, scope);
-    await sleep(50);
-    put('stale-preview.txt', 'keep\nTARGET\nexternal\n');
-    await sleep(50);
-    const out = await tool('edit', { path: 'stale-preview.txt', old_string: 'TARGET', new_string: 'DONE' }, scope);
-    expectIncludes(out, 'Edited:');
-    expectIncludes(get('stale-preview.txt'), 'DONE');
-});
-
-await scenario('CRLF-normalized edit preserves intent', async (scope) => {
-    put('crlf.txt', 'a\r\nb\r\n');
-    await tool('read', { path: 'crlf.txt' }, scope);
-    const out = await tool('edit', { path: 'crlf.txt', old_string: 'a\nb', new_string: 'x\ny' }, scope);
-    expectIncludes(out, 'Edited:');
-    expectEquals(get('crlf.txt'), 'x\r\ny\r\n');
-});
-
-await scenario('smart-truncated read middle edit now succeeds (read-window gate retired)', async (scope) => {
-    const rows = Array.from({ length: 700 }, (_, i) => i === 349 ? 'M' : `smart-line-${i + 1}`);
-    put('smart-large.txt', rows.join('\n') + '\n');
-    const readOut = await tool('read', { path: 'smart-large.txt' }, scope);
-    expectIncludes(readOut, 'TRUNCATED');
-    expectTrue(!String(readOut).includes('next_call:'), readOut);
-    const editOut = await tool('edit', { path: 'smart-large.txt', old_string: 'M', new_string: 'N' }, scope);
-    expectIncludes(editOut, 'Edited:');
-    expectIncludes(get('smart-large.txt'), '\nN\n');
-});
-
-await scenario('path offset is 0-based and file_path offset is 1-based', async (scope) => {
-    put('offset-path.txt', 'line-1\nline-2\nline-3\n');
-    put('offset-file-path.txt', 'line-1\nline-2\nline-3\n');
-    const pathOut = await tool('read', { path: 'offset-path.txt', offset: 1, limit: 1 }, scope);
-    const filePathOut = await tool('read', { file_path: 'offset-file-path.txt', offset: 2, limit: 1 }, scope);
-    expectIncludes(pathOut, 'line-2');
-    expectIncludes(filePathOut, 'line-2');
-});
-
-await scenario('read object-array supports file_path alias', async (scope) => {
-    put('object-file-path.txt', 'line-1\nline-2\nline-3\n');
-    const out = await tool('read', { path: [{ file_path: 'object-file-path.txt', offset: 1, limit: 1 }] }, scope);
-    expectIncludes(out, 'line-1');
-});
-
-await scenario('wide default read has no context advisory', async (scope) => {
-    const rows = Array.from({ length: 260 }, (_, i) => `wide-${i + 1}-${'x'.repeat(72)}`);
-    put('wide-read.txt', rows.join('\n') + '\n');
-    const fullOut = await tool('read', { path: 'wide-read.txt' }, scope);
-    expectTrue(!String(fullOut).includes('[context-advisory]'), fullOut);
-    expectTrue(!String(fullOut).includes('next_call:'), fullOut);
-    const compactOut = await tool('read', { path: 'wide-read.txt', budget: 'compact' }, scope);
-    expectIncludes(compactOut, 'lines\t260');
-    expectTrue(!String(compactOut).includes('wide-130'), compactOut);
-    const rangeOut = await tool('read', { path: 'wide-read.txt', offset: 10, limit: 5 }, scope);
-    expectTrue(!String(rangeOut).includes('[context-advisory]'), rangeOut);
-});
-
-await scenario('truncated range read stays compact', async (scope) => {
-    const rows = Array.from({ length: 2200 }, (_, i) => `huge-${i + 1}-${'z'.repeat(80)}`);
-    put('truncated-range.txt', rows.join('\n') + '\n');
-    const out = await tool('read', { path: 'truncated-range.txt', offset: 0, limit: 2000 }, scope);
-    expectIncludes(out, '[output truncated');
-    expectTrue(!String(out).includes('next_call:'), out);
-});
-
-await scenario('summary read emits outline, hidden-body edit now succeeds (read-window gate retired)', async (scope) => {
-    put('summary-read.mjs', [
-        'import x from "x";',
-        'export function alpha() {',
-        '  return 1;',
-        '}',
-        'const hiddenBody = "do not stream everything";',
-        'class Beta {}',
-        '',
-    ].join('\n'));
-    const out = await tool('read', { path: 'summary-read.mjs', mode: 'summary', n: 5 }, scope);
-    expectIncludes(out, 'summary summary-read.mjs');
-    expectIncludes(out, 'symbols\t');
-    expectIncludes(out, 'export function alpha');
-    expectIncludes(out, 'class Beta');
-    expectTrue(!String(out).includes('next_call:'), out);
-    const editOut = await tool('edit', { path: 'summary-read.mjs', old_string: 'hiddenBody', new_string: 'VISIBLE_BODY' }, scope);
-    expectIncludes(editOut, 'Edited:');
-    expectTrue(!String(editOut).includes('next_call:'), editOut);
-    expectIncludes(get('summary-read.mjs'), 'VISIBLE_BODY');
-});
-
-await scenario('summary recognizes common language symbols', async (scope) => {
-    put('summary-langs.txt', [
-        'pub fn rust_entry() {}',
-        'func GoEntry() {}',
-        'public class CsEntry {}',
-        'public void JavaStyle() {}',
-        '',
-    ].join('\n'));
-    const out = await tool('read', { path: 'summary-langs.txt', mode: 'summary', n: 10 }, scope);
-    expectIncludes(out, 'pub fn rust_entry');
-    expectIncludes(out, 'func GoEntry');
-    expectIncludes(out, 'public class CsEntry');
-    expectIncludes(out, 'public void JavaStyle');
-    expectTrue(!String(out).includes('next_call:'), out);
-});
-
-await scenario('missing grep and glob arguments stay concise', async (scope) => {
-    const grepOut = await tool('grep', {}, scope);
-    expectIncludes(grepOut, 'Error: grep requires pattern');
-    expectTrue(!String(grepOut).includes('next_call:'), grepOut);
-    const globOut = await tool('glob', {}, scope);
-    expectIncludes(globOut, 'Error: glob requires pattern');
-    expectTrue(!String(globOut).includes('next_call:'), globOut);
-});
-
-await scenario('grep regex error stays concise', async (scope) => {
-    const out = await tool('grep', { pattern: '(', path: '.' }, scope);
-    expectIncludes(out, 'Error:');
-    expectTrue(!String(out).includes('hint:'), out);
-    expectTrue(!String(out).includes('next_call:'), out);
-});
-
-await scenario('grep aliases land one-shot', async (scope) => {
-    put('grep-alias/a.mjs', 'const needleValue = 1;\n');
-    put('grep-alias/b.txt', 'needleValue in text\n');
-    const out = await tool('grep', {
-        query: 'needleValue',
-        root: 'grep-alias',
-        file_pattern: '*.mjs',
-        mode: 'content',
-    }, scope);
-    expectIncludes(out, 'a.mjs');
-    expectIncludes(out, 'needleValue');
-    expectTrue(!String(out).includes('next_call:'), out);
-    expectTrue(!String(out).includes('b.txt'), out);
-});
-
-await scenario('grep and glob typo tool names canonicalize', async (scope) => {
-    put('typo-tools/a.mjs', 'const typoNeedle = 1;\n');
-    put('typo-tools/b.txt', 'typoNeedle in text\n');
-    const grepOut = await tool('grop', {
-        pattern: 'typoNeedle',
-        path: 'typo-tools',
-        glob: '*.mjs',
-        output_mode: 'content',
-    }, scope);
-    expectIncludes(grepOut, 'typoNeedle');
-    expectTrue(!String(grepOut).includes('next_call:'), grepOut);
-    const globOut = await tool('glbo', { glob: '*.mjs', root: 'typo-tools' }, scope);
-    expectIncludes(globOut, 'typo-tools/a.mjs');
-    expectTrue(!String(globOut).includes('next_call:'), globOut);
-});
-
-await scenario('grep file and count modes stay concise', async (scope) => {
-    put('grep-follow/a.mjs', 'const followNeedle = 1;\nconst followNeedleAgain = 2;\n');
-    put('grep-follow/b.txt', 'no match\n');
-    const filesOut = await tool('grep', {
-        pattern: 'followNeedle',
-        path: 'grep-follow',
-        glob: '*.mjs',
-    }, scope);
-    expectIncludes(filesOut, 'grep-follow/a.mjs');
-    expectTrue(!String(filesOut).includes('next_call:'), filesOut);
-    const countOut = await tool('grep', {
-        pattern: 'followNeedle',
-        path: 'grep-follow',
-        glob: '*.mjs',
-        mode: 'count',
-    }, scope);
-    expectIncludes(countOut, 'grep-follow/a.mjs:2');
-    expectTrue(!String(countOut).includes('next_call:'), countOut);
-});
-
-await scenario('glob aliases land one-shot', async (scope) => {
-    put('glob-alias/a.mjs', 'a\n');
-    put('glob-alias/b.txt', 'b\n');
-    const out = await tool('glob', { glob: '*.mjs', root: 'glob-alias' }, scope);
-    expectIncludes(out, 'glob-alias/a.mjs');
-    expectTrue(!String(out).includes('next_call:'), out);
-    expectTrue(!String(out).includes('glob-alias/b.txt'), out);
-});
-
-await scenario('V4A patch touched paths extracted', async () => {
-    const touched = extractTouchedPathsFromPatch([
-        '*** Begin Patch',
-        '*** Update File: "src/a name.mjs"\t2026-05-21',
-        '@@ anchor',
-        '-old',
-        '+new',
-        '*** Add File: src/b.mjs',
-        '+new file',
-        '*** Delete File: src/c.mjs',
-        '*** End Patch',
-    ].join('\n'));
-    expectEquals(JSON.stringify(touched), JSON.stringify(['src/a name.mjs', 'src/b.mjs', 'src/c.mjs']));
-});
-
-await scenario('unified patch touched paths ignore tab metadata', async () => {
-    const touched = extractTouchedPathsFromPatch([
-        '--- a/src/a.mjs\t2026-05-21 10:00:00',
-        '+++ b/src/a.mjs\t2026-05-21 10:01:00',
-        '@@ -1 +1 @@',
-        '-old',
-        '+new',
-    ].join('\n'));
-    expectEquals(JSON.stringify(touched), JSON.stringify(['src/a.mjs']));
-});
-
-await scenario('apply_patch rejected hunk returns compact context guidance', async (scope) => {
-    put('patch-guidance.txt', 'alpha\nbeta\ngamma\n');
-    const out = await patchTool({
-        patch: [
-            '--- a/patch-guidance.txt',
-            '+++ b/patch-guidance.txt',
-            '@@ -1,3 +1,3 @@',
-            ' alpha',
-            '-missing',
-            '+BETA',
-            ' gamma',
-        ].join('\n') + '\n',
-        dry_run: true,
-        fuzzy: false,
-    }, scope);
-    expectIncludes(out, 'hunk rejected');
-    expectIncludes(out, 'expected first old/context line');
-    expectIncludes(out, 'nearest line');
-});
-
-await scenario('apply_patch count-mismatch unified falls back through V4A', async (scope) => {
-    put('patch-count-fallback.txt', 'a\nb\nc\nd\n');
-    const patch = [
-        '--- a/patch-count-fallback.txt',
-        '+++ b/patch-count-fallback.txt',
-        '@@ -1,1 +1,1 @@',
-        '-a',
-        '+A',
-        '+extra',
-        '@@ -4,1 +4,1 @@',
-        '-d',
-        '+D',
-    ].join('\n') + '\n';
-    const out = await patchTool({ patch }, scope);
-    expectIncludes(out, 'mutation_route: source=apply_patch engine=v4a-patch reason=unified-count-fallback');
-    expectIncludes(out, 'applied 1');
-    expectEquals(get('patch-count-fallback.txt'), 'A\nextra\nb\nc\nD\n');
-
-    put('patch-count-strict.txt', 'a\nb\n');
-    let strictError = '';
-    try {
-        await patchTool({
-            patch: [
-                '--- a/patch-count-strict.txt',
-                '+++ b/patch-count-strict.txt',
-                '@@ -1,1 +1,1 @@',
-                '-a',
-                '+A',
-                '+extra',
-            ].join('\n') + '\n',
-            format: 'unified',
-        }, scope);
-    } catch (err) {
-        strictError = String(err?.message || err);
-    }
-    expectIncludes(strictError, 'parse failed');
-});
-
-await scenario('apply_patch success reports shared mutation route', async (scope) => {
-    put('patch-route.txt', 'before\n');
-    const out = await patchTool({
-        patch: [
-            '--- a/patch-route.txt',
-            '+++ b/patch-route.txt',
-            '@@ -1,1 +1,1 @@',
-            '-before',
-            '+after',
-        ].join('\n') + '\n',
-    }, scope);
-    expectIncludes(out, 'mutation_route: source=apply_patch engine=unified-patch reason=direct');
-    expectIncludes(out, 'applied 1');
-    expectEquals(get('patch-route.txt'), 'after\n');
-});
-
-await scenario('apply_patch long failed hunk stays compact', async (scope) => {
-    put('patch-guidance-long.txt', Array.from({ length: 14 }, (_, i) => `line-${i + 1}`).join('\n') + '\n');
-    const patchLines = [
-        '--- a/patch-guidance-long.txt',
-        '+++ b/patch-guidance-long.txt',
-        '@@ -1,14 +1,14 @@',
-        ' line-1',
-        ' line-2',
-        ' line-3',
-        ' line-4',
-        ' line-5',
-        ' line-6',
-        ' line-7',
-        ' line-8',
-        ' line-9',
-        '-missing',
-        '+LINE-10',
-        ' line-11',
-        ' line-12',
-        ' line-13',
-        ' line-14',
-    ];
-    const out = await patchTool({ patch: patchLines.join('\n') + '\n', dry_run: true, fuzzy: false }, scope);
-    expectIncludes(out, 'hunk rejected');
-    expectIncludes(out, 'expected first old/context line');
-});
-
-await scenario('long foreground bash watch is rejected compactly', async (scope) => {
-    const out = await tool('bash', { command: 'gh run watch 123456 --exit-status', timeout: 600000 }, scope);
-    expectIncludes(out, 'long foreground command detected');
-    expectTrue(!String(out).includes('run_in_background:true'), out);
-});
-
-await scenario('long foreground PowerShell sleep is rejected compactly', async (scope) => {
-    const out = await tool('bash', { command: 'Start-Sleep -Seconds 75; "chrome now"', timeout: 90000 }, scope);
-    expectIncludes(out, 'long foreground command detected');
-});
-
-if (failed > 0) {
-    console.error(`[io-smoke] failed=${failed} passed=${passed}`);
-    console.error(`[io-smoke] fixtures preserved at ${WORKDIR}`);
-    await closeNativePatchServerForTests().catch(() => {});
-    process.exit(1);
-}
-
-console.log(`[io-smoke] all ${passed} scenarios passed`);
-await closeNativePatchServerForTests().catch(() => {});
-try { rmSync(WORKDIR, { recursive: true, force: true }); } catch {}
-try { rmSync(DATA_DIR, { recursive: true, force: true }); } catch {}
-
-async function scenario(name, fn) {
-    const scope = `${BASE_SCOPE}-${passed + failed + 1}`;
-    try {
-        await fn(scope);
-        passed += 1;
-        console.log(`[io-smoke] PASS ${passed + failed}: ${name}`);
-    } catch (err) {
-        failed += 1;
-        console.error(`[io-smoke] FAIL ${passed + failed}: ${name}`);
-        console.error(err?.stack || String(err));
-    }
-}
-
-async function tool(name, args, scope) {
-    return executeBuiltinTool(name, args, WORKDIR, { readStateScope: scope, sessionId: scope });
-}
-
-async function patchTool(args, scope) {
-    return executePatchTool('apply_patch', args, WORKDIR, { readStateScope: scope, sessionId: scope });
-}
-
-function abs(rel) {
-    return join(WORKDIR, rel);
-}
-
-function put(rel, content) {
-    const path = abs(rel);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, content);
-}
-
-function get(rel) {
-    return readFileSync(abs(rel), 'utf8');
-}
-
-function rangeLines(prefix, count) {
-    return Array.from({ length: count }, (_, i) => `${prefix}-${i + 1}`).join('\n') + '\n';
-}
-
-function linesWith(count, lineNumber, value) {
-    return Array.from({ length: count }, (_, i) => (i + 1 === lineNumber ? value : `line-${i + 1}`)).join('\n') + '\n';
-}
-
-function expectIncludes(actual, needle) {
-    if (!String(actual).includes(needle)) {
-        throw new Error(`expected output to include ${JSON.stringify(needle)}, got ${JSON.stringify(String(actual).slice(0, 500))}`);
-    }
-}
-
-function objectContains(actual, expected) {
-    for (const [key, value] of Object.entries(expected)) {
-        if (actual?.[key] !== value) return false;
-    }
-    return true;
-}
-
-function expectNextCall(actual, toolName, expectedArgs) {
-    const calls = parseJsonNextCalls(actual);
-    const found = calls.find((call) => call.tool === toolName && objectContains(call.args, expectedArgs));
-    if (!found) {
-        throw new Error(`expected next_call ${toolName}(${JSON.stringify(expectedArgs)}) in ${JSON.stringify(String(actual).slice(0, 800))}; parsed=${JSON.stringify(calls)}`);
-    }
-}
-
-function expectEquals(actual, expected) {
-    if (actual !== expected) {
-        throw new Error(`expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
-    }
-}
-
-function expectTrue(value, detail = '') {
-    if (!value) throw new Error(`expected truthy value${detail ? `: ${detail}` : ''}`);
-}
-
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}