mixdog 0.7.1

package/scripts/io-complex-smoke.mjs

@@ -0,0 +1,667 @@
+#!/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));
+}