mixdog 0.7.1

package/scripts/native-patch-bridge-smoke.mjs

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+import { mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const MANIFEST = join(ROOT, 'native/mixdog-patch/Cargo.toml');
+
+process.env.CLAUDE_PLUGIN_ROOT ||= ROOT;
+// SAFETY: own an isolated temp data dir; never `||=` the LIVE CLAUDE_PLUGIN_DATA,
+// which the finally below would then rm.
+const SMOKE_PLUGIN_DATA = join(tmpdir(), `mixdog-native-patch-bridge-data-${process.pid}`);
+process.env.CLAUDE_PLUGIN_DATA = SMOKE_PLUGIN_DATA;
+process.env.MIXDOG_PATCH_NATIVE = 'server';
+process.env.MIXDOG_PATCH_NATIVE_STRICT = '1';
+
+function run(cmd, args, opts = {}) {
+  const result = spawnSync(cmd, args, { encoding: 'utf8', stdio: 'pipe', ...opts });
+  if (result.status !== 0) {
+    throw new Error(`${cmd} ${args.join(' ')} failed\n${result.stdout || ''}\n${result.stderr || ''}`);
+  }
+  return result;
+}
+
+function patchText(lines) {
+  return `${lines.join('\n')}\n`;
+}
+
+run('cargo', ['build', '--release', '--manifest-path', MANIFEST]);
+
+const { executePatchTool, closeNativePatchServerForTests } = await import(pathToFileURL(join(ROOT, 'src/agent/orchestrator/tools/patch.mjs')).href);
+
+const dir = await mkdtemp(join(tmpdir(), 'mixdog-native-patch-bridge-'));
+try {
+  await writeFile(join(dir, 'bridge.txt'), 'alpha\nbeta\ngamma\n', 'utf8');
+  const out = await executePatchTool('apply_patch', {
+    base_path: dir,
+    patch: patchText([
+      '--- a/bridge.txt',
+      '+++ b/bridge.txt',
+      '@@ -2,1 +2,1 @@',
+      '-beta',
+      '+BETA',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke' });
+  if (!String(out).includes('(native)')) throw new Error(`native bridge was not used: ${out}`);
+  const got = await readFile(join(dir, 'bridge.txt'), 'utf8');
+  if (got !== 'alpha\nBETA\ngamma\n') throw new Error(`unexpected bridge.txt: ${JSON.stringify(got)}`);
+  const tempResidue = (await readdir(dir)).filter((name) => name.includes('.mixdog-tmp-') || name.includes('.mixdog-new-'));
+  if (tempResidue.length > 0) throw new Error(`native atomic temp residue: ${tempResidue.join(', ')}`);
+
+  const aborted = new AbortController();
+  aborted.abort(new Error('native abort smoke'));
+  let abortOk = false;
+  try {
+    await executePatchTool('apply_patch', {
+      base_path: dir,
+      patch: patchText([
+        '--- a/bridge.txt',
+        '+++ b/bridge.txt',
+        '@@ -1,1 +1,1 @@',
+        '-alpha',
+        '+ABORTED',
+      ]),
+    }, dir, { readStateScope: 'native-bridge-smoke-abort', signal: aborted.signal });
+  } catch (err) {
+    abortOk = err?.name === 'AbortError' || /native abort smoke|aborted/i.test(String(err?.message || err));
+  }
+  if (!abortOk) throw new Error('pre-aborted native patch signal did not reject cleanly');
+
+  await writeFile(join(dir, 'v4a-bridge.txt'), 'class Foo\n  function bar\n    return x;\n', 'utf8');
+  const v4aOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    format: 'v4a',
+    patch: patchText([
+      '*** Begin Patch',
+      '*** Update File: v4a-bridge.txt',
+      '@@ class Foo',
+      '@@ function bar',
+      '-    return x;',
+      '+    return x + 1;',
+      '*** End Patch',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-v4a' });
+  if (!String(v4aOut).includes('(native)')) throw new Error(`native V4A bridge was not used: ${v4aOut}`);
+  const v4aGot = await readFile(join(dir, 'v4a-bridge.txt'), 'utf8');
+  if (v4aGot !== 'class Foo\n  function bar\n    return x + 1;\n') throw new Error(`unexpected v4a-bridge.txt: ${JSON.stringify(v4aGot)}`);
+
+  await writeFile(join(dir, 'v4a-anchor-line.txt'), 'before\nconst target = "old";\nafter\n', 'utf8');
+  const v4aAnchorLineOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    format: 'v4a',
+    patch: patchText([
+      '*** Begin Patch',
+      '*** Update File: v4a-anchor-line.txt',
+      '@@ const target',
+      '-const target = "old";',
+      '+const target = "new";',
+      '*** End Patch',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-v4a-anchor-line' });
+  if (!String(v4aAnchorLineOut).includes('(native)')) throw new Error(`native V4A anchor-line bridge was not used: ${v4aAnchorLineOut}`);
+  const v4aAnchorLineGot = await readFile(join(dir, 'v4a-anchor-line.txt'), 'utf8');
+  if (v4aAnchorLineGot !== 'before\nconst target = "new";\nafter\n') throw new Error(`unexpected v4a-anchor-line.txt: ${JSON.stringify(v4aAnchorLineGot)}`);
+
+  await writeFile(join(dir, 'strict-fuzzy.txt'), 'intro\nactual-before\nold\nactual-after\n', 'utf8');
+  const fuzzyNativeOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    patch: patchText([
+      '--- a/strict-fuzzy.txt',
+      '+++ b/strict-fuzzy.txt',
+      '@@ -1,4 +1,4 @@',
+      ' intro',
+      ' expected-before',
+      '-old',
+      '+NEW',
+      ' expected-after',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-fuzzy-default' });
+  if (!String(fuzzyNativeOut).includes('(native)')) throw new Error(`native fuzzy bridge was not used: ${fuzzyNativeOut}`);
+  const fuzzyGot = await readFile(join(dir, 'strict-fuzzy.txt'), 'utf8');
+  if (fuzzyGot !== 'intro\nactual-before\nNEW\nactual-after\n') throw new Error(`unexpected strict-fuzzy.txt: ${JSON.stringify(fuzzyGot)}`);
+
+  await writeFile(join(dir, 'strict-fuzzy.txt'), 'intro\nactual-before\nold\nactual-after\n', 'utf8');
+  const strictOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    fuzzy: false,
+    patch: patchText([
+      '--- a/strict-fuzzy.txt',
+      '+++ b/strict-fuzzy.txt',
+      '@@ -1,4 +1,4 @@',
+      ' intro',
+      ' expected-before',
+      '-old',
+      '+NEW',
+      ' expected-after',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-fuzzy-disabled' });
+  if (!String(strictOut).startsWith('Error:')) throw new Error(`fuzzy:false should reject context drift: ${strictOut}`);
+  const strictGot = await readFile(join(dir, 'strict-fuzzy.txt'), 'utf8');
+  if (strictGot !== 'intro\nactual-before\nold\nactual-after\n') throw new Error(`fuzzy:false changed file: ${JSON.stringify(strictGot)}`);
+
+  await writeFile(join(dir, 'fuzzy-trailing-ws.txt'), 'c1   \nold\nc2\t\nc3  \n', 'utf8');
+  const fuzzyWsOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    patch: patchText([
+      '--- a/fuzzy-trailing-ws.txt',
+      '+++ b/fuzzy-trailing-ws.txt',
+      '@@ -1,4 +1,4 @@',
+      ' c1',
+      '-old',
+      '+NEW',
+      ' c2',
+      ' c3',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-fuzzy-ws' });
+  if (!String(fuzzyWsOut).includes('(native)')) throw new Error(`native fuzzy whitespace bridge was not used: ${fuzzyWsOut}`);
+  const fuzzyWsGot = await readFile(join(dir, 'fuzzy-trailing-ws.txt'), 'utf8');
+  if (fuzzyWsGot !== 'c1   \nNEW\nc2\t\nc3  \n') throw new Error(`unexpected fuzzy-trailing-ws.txt: ${JSON.stringify(fuzzyWsGot)}`);
+
+  await writeFile(join(dir, 'fuzzy-trailing-ws.txt'), 'c1   \nold\nc2\t\nc3  \n', 'utf8');
+  const strictWsOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    fuzzy: false,
+    patch: patchText([
+      '--- a/fuzzy-trailing-ws.txt',
+      '+++ b/fuzzy-trailing-ws.txt',
+      '@@ -1,4 +1,4 @@',
+      ' c1',
+      '-old',
+      '+NEW',
+      ' c2',
+      ' c3',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-strict-ws' });
+  if (!String(strictWsOut).startsWith('Error:')) throw new Error(`fuzzy:false should reject trailing whitespace context drift: ${strictWsOut}`);
+  const strictWsGot = await readFile(join(dir, 'fuzzy-trailing-ws.txt'), 'utf8');
+  if (strictWsGot !== 'c1   \nold\nc2\t\nc3  \n') throw new Error(`fuzzy:false whitespace changed file: ${JSON.stringify(strictWsGot)}`);
+
+  const multiOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    patch: patchText([
+      '--- /dev/null',
+      '+++ b/new.txt',
+      '@@ -0,0 +1,1 @@',
+      '+created',
+      '--- a/bridge.txt',
+      '+++ b/bridge.txt',
+      '@@ -1,1 +1,1 @@',
+      '-alpha',
+      '+ALPHA',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-multi' });
+  if (!String(multiOut).includes('(native)')) throw new Error(`native multi bridge was not used: ${multiOut}`);
+  const newGot = await readFile(join(dir, 'new.txt'), 'utf8');
+  if (newGot !== 'created\n') throw new Error(`unexpected new.txt: ${JSON.stringify(newGot)}`);
+  const changedGot = await readFile(join(dir, 'bridge.txt'), 'utf8');
+  if (changedGot !== 'ALPHA\nBETA\ngamma\n') throw new Error(`unexpected bridge.txt after multi: ${JSON.stringify(changedGot)}`);
+
+  const dryOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    dry_run: true,
+    patch: patchText([
+      '--- a/new.txt',
+      '+++ /dev/null',
+      '@@ -1,1 +0,0 @@',
+      '-created',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-dry' });
+  if (!String(dryOut).includes('(native)')) throw new Error(`native dry-run bridge was not used: ${dryOut}`);
+  const dryGot = await readFile(join(dir, 'new.txt'), 'utf8');
+  if (dryGot !== 'created\n') throw new Error(`dry-run changed new.txt: ${JSON.stringify(dryGot)}`);
+
+  await writeFile(join(dir, 'no-newline.txt'), 'a\nb', 'utf8');
+  const noNewlineOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    patch: patchText([
+      '--- a/no-newline.txt',
+      '+++ b/no-newline.txt',
+      '@@ -1,2 +1,2 @@',
+      ' a',
+      '-b',
+      '\',
+      '+B',
+      '\',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-no-newline' });
+  if (!String(noNewlineOut).includes('(native)')) throw new Error(`native no-newline bridge was not used: ${noNewlineOut}`);
+  const noNewlineGot = await readFile(join(dir, 'no-newline.txt'), 'utf8');
+  if (noNewlineGot !== 'a\nB') throw new Error(`unexpected no-newline.txt: ${JSON.stringify(noNewlineGot)}`);
+
+  await writeFile(join(dir, 'native-fail.txt'), 'left\nright\n', 'utf8');
+  const failedOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    patch: patchText([
+      '--- a/native-fail.txt',
+      '+++ b/native-fail.txt',
+      '@@ -1,2 +1,2 @@',
+      ' left',
+      '-missing',
+      '+MISSING',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-fail' });
+  if (!String(failedOut).startsWith('Error: native patch failed')) {
+    throw new Error(`native failure did not stop at native engine: ${failedOut}`);
+  }
+  const failedGot = await readFile(join(dir, 'native-fail.txt'), 'utf8');
+  if (failedGot !== 'left\nright\n') throw new Error(`native failure changed file: ${JSON.stringify(failedGot)}`);
+
+  await writeFile(join(dir, 'misattr-b.txt'), 'beta line 1\nbeta line 2\n', 'utf8');
+  await writeFile(join(dir, 'misattr-a.txt'), 'alpha line 1\nalpha line 2\nalpha actual later\n', 'utf8');
+  const misattrOut = await executePatchTool('apply_patch', {
+    base_path: dir,
+    fuzzy: false,
+    patch: patchText([
+      '--- a/misattr-b.txt',
+      '+++ b/misattr-b.txt',
+      '@@ -1,1 +1,1 @@',
+      '-beta line 1',
+      '+BETA line 1',
+      '--- a/misattr-a.txt',
+      '+++ b/misattr-a.txt',
+      '@@ -1,1 +1,1 @@',
+      '-alpha line 1',
+      '+ALPHA line 1',
+      '@@ -3,1 +3,1 @@',
+      '-alpha expected later',
+      '+ALPHA expected later',
+    ]),
+  }, dir, { readStateScope: 'native-bridge-smoke-misattribution' });
+  if (!String(misattrOut).startsWith('Error: native patch failed')) throw new Error(`misattribution patch should fail natively: ${misattrOut}`);
+  if (String(misattrOut).includes('"beta line 1"')) throw new Error(`failure context quoted the first file: ${misattrOut}`);
+  if (!String(misattrOut).includes('misattr-a.txt') || !String(misattrOut).includes('"alpha expected later"') || !String(misattrOut).includes('nearest line 3: "alpha actual later"')) {
+    throw new Error(`failure context did not name the failing hunk: ${misattrOut}`);
+  }
+  const misattrAGot = await readFile(join(dir, 'misattr-a.txt'), 'utf8');
+  const misattrBGot = await readFile(join(dir, 'misattr-b.txt'), 'utf8');
+  if (misattrAGot !== 'alpha line 1\nalpha line 2\nalpha actual later\n' || misattrBGot !== 'beta line 1\nbeta line 2\n') {
+    throw new Error('misattribution failure mutated files despite reject_partial=true');
+  }
+  console.log('native-patch bridge smoke passed');
+} finally {
+  await closeNativePatchServerForTests();
+  await rm(dir, { recursive: true, force: true });
+  await rm(SMOKE_PLUGIN_DATA, { recursive: true, force: true });
+}

package/scripts/native-patch-smoke.mjs

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn, spawnSync } from 'node:child_process';
+import { createInterface } from 'node:readline';
+
+const ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const MANIFEST = join(ROOT, 'native/mixdog-patch/Cargo.toml');
+const BIN = join(ROOT, 'native/mixdog-patch/target/release', process.platform === 'win32' ? 'mixdog-patch.exe' : 'mixdog-patch');
+
+function run(cmd, args, opts = {}) {
+  const res = spawnSync(cmd, args, { encoding: 'utf8', ...opts });
+  if (res.status !== 0) {
+    throw new Error(`${cmd} ${args.join(' ')} failed\nstdout=${res.stdout}\nstderr=${res.stderr}`);
+  }
+  return res;
+}
+
+function patchText(lines) {
+  return `${lines.join('\n')}\n`;
+}
+
+async function expectFile(dir, path, expected) {
+  const got = await readFile(join(dir, path), 'utf8');
+  if (got !== expected) throw new Error(`${path}: got ${JSON.stringify(got)}, expected ${JSON.stringify(expected)}`);
+}
+
+async function expectMissing(dir, path) {
+  try {
+    await readFile(join(dir, path), 'utf8');
+    throw new Error(`${path}: expected missing, but file exists`);
+  } catch (err) {
+    if (err?.code !== 'ENOENT') throw err;
+  }
+}
+
+async function applyNative(dir, patch) {
+  run(BIN, ['--base', dir], { input: patch });
+}
+
+async function dryRunNative(dir, patch) {
+  run(BIN, ['--base', dir, '--dry-run'], { input: patch });
+}
+
+async function applyNativeError(dir, patch) {
+  const result = spawnSync(BIN, ['--base', dir], { input: patch, encoding: 'utf8', stdio: 'pipe' });
+  if (result.status === 0) {
+    throw new Error(`native patch unexpectedly succeeded\nstdout=${result.stdout || ''}\nstderr=${result.stderr || ''}`);
+  }
+  return `${result.stdout || ''}${result.stderr || ''}`;
+}
+
+class NativePatchServer {
+  constructor() {
+    this.child = spawn(BIN, ['--server'], { stdio: ['pipe', 'pipe', 'pipe'] });
+    this.stderr = '';
+    this.lines = [];
+    this.waiters = [];
+    this.child.stderr.setEncoding('utf8');
+    this.child.stderr.on('data', (chunk) => { this.stderr += chunk; });
+    this.rl = createInterface({ input: this.child.stdout });
+    this.rl.on('line', (line) => {
+      const waiter = this.waiters.shift();
+      if (waiter) waiter(line);
+      else this.lines.push(line);
+    });
+  }
+
+  nextLine() {
+    if (this.lines.length > 0) return Promise.resolve(this.lines.shift());
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+
+  async apply(dir, patch) {
+    const baseBuf = Buffer.from(dir, 'utf8');
+    const patchBuf = Buffer.from(patch, 'utf8');
+    const linePromise = this.nextLine();
+    this.child.stdin.write(`APPLY ${baseBuf.length} ${patchBuf.length} 1 0 2 1\n`);
+    this.child.stdin.write(baseBuf);
+    this.child.stdin.write(patchBuf);
+    const line = await linePromise;
+    if (!line.startsWith('OK\t')) {
+      throw new Error(`native server failed: ${line}\nstderr=${this.stderr}`);
+    }
+    const contentHash = line.split('\t')[7];
+    if (!/^[a-f0-9]{64}$/i.test(contentHash || '')) {
+      throw new Error(`native server missing content hash: ${line}`);
+    }
+  }
+
+  async close() {
+    this.child.stdin.end('QUIT\n');
+    await new Promise((resolve) => this.child.once('exit', resolve));
+    this.rl.close();
+  }
+}
+
+run('cargo', ['build', '--release', '--manifest-path', MANIFEST]);
+
+const dir = await mkdtemp(join(tmpdir(), 'mixdog-native-patch-smoke-'));
+try {
+  await writeFile(join(dir, 'replace.txt'), 'a\nb\nc\n', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/replace.txt',
+    '+++ b/replace.txt',
+    '@@ -2,1 +2,1 @@',
+    '-b',
+    '+B',
+  ]));
+  await expectFile(dir, 'replace.txt', 'a\nB\nc\n');
+
+  await writeFile(join(dir, 'insert.txt'), 'a\nc\n', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/insert.txt',
+    '+++ b/insert.txt',
+    '@@ -1,0 +2,1 @@',
+    '+b',
+  ]));
+  await expectFile(dir, 'insert.txt', 'a\nb\nc\n');
+
+  await writeFile(join(dir, 'crlf.txt'), 'a\r\nb\r\nc\r\n', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/crlf.txt',
+    '+++ b/crlf.txt',
+    '@@ -2,1 +2,1 @@',
+    '-b',
+    '+B',
+  ]));
+  await expectFile(dir, 'crlf.txt', 'a\r\nB\r\nc\r\n');
+
+  await writeFile(join(dir, 'multi.txt'), 'h\nm\nt\n', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/multi.txt',
+    '+++ b/multi.txt',
+    '@@ -1,1 +1,1 @@',
+    '-h',
+    '+H',
+    '@@ -3,1 +3,1 @@',
+    '-t',
+    '+T',
+  ]));
+  await expectFile(dir, 'multi.txt', 'H\nm\nT\n');
+
+  await writeFile(join(dir, 'fuzzy-offset.txt'), 'intro\nkeep\nold\ntrail\n', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/fuzzy-offset.txt',
+    '+++ b/fuzzy-offset.txt',
+    '@@ -20,3 +20,3 @@',
+    ' keep',
+    '-old',
+    '+NEW',
+    ' trail',
+  ]));
+  await expectFile(dir, 'fuzzy-offset.txt', 'intro\nkeep\nNEW\ntrail\n');
+
+  await writeFile(join(dir, 'fuzzy-context.txt'), 'intro\nactual-before\nold\nactual-after\n', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/fuzzy-context.txt',
+    '+++ b/fuzzy-context.txt',
+    '@@ -1,4 +1,4 @@',
+    ' intro',
+    ' expected-before',
+    '-old',
+    '+NEW',
+    ' expected-after',
+  ]));
+  await expectFile(dir, 'fuzzy-context.txt', 'intro\nactual-before\nNEW\nactual-after\n');
+
+  await writeFile(join(dir, 'fuzzy-trailing-ws.txt'), 'c1   \nold\nc2\t\nc3  \n', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/fuzzy-trailing-ws.txt',
+    '+++ b/fuzzy-trailing-ws.txt',
+    '@@ -1,4 +1,4 @@',
+    ' c1',
+    '-old',
+    '+NEW',
+    ' c2',
+    ' c3',
+  ]));
+  await expectFile(dir, 'fuzzy-trailing-ws.txt', 'c1   \nNEW\nc2\t\nc3  \n');
+
+  await writeFile(join(dir, 'no-newline.txt'), 'a\nb', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/no-newline.txt',
+    '+++ b/no-newline.txt',
+    '@@ -1,2 +1,2 @@',
+    ' a',
+    '-b',
+    '\',
+    '+B',
+    '\',
+  ]));
+  await expectFile(dir, 'no-newline.txt', 'a\nB');
+
+  await writeFile(join(dir, 'add-newline.txt'), 'a\nb', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/add-newline.txt',
+    '+++ b/add-newline.txt',
+    '@@ -1,2 +1,2 @@',
+    ' a',
+    '-b',
+    '\',
+    '+B',
+  ]));
+  await expectFile(dir, 'add-newline.txt', 'a\nB\n');
+
+  await applyNative(dir, patchText([
+    '--- /dev/null',
+    '+++ b/created.txt',
+    '@@ -0,0 +1,2 @@',
+    '+one',
+    '+two',
+  ]));
+  await expectFile(dir, 'created.txt', 'one\ntwo\n');
+
+  await writeFile(join(dir, 'deleted.txt'), 'gone\n', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/deleted.txt',
+    '+++ /dev/null',
+    '@@ -1,1 +0,0 @@',
+    '-gone',
+  ]));
+  await expectMissing(dir, 'deleted.txt');
+
+  await writeFile(join(dir, 'empty-delete.txt'), '', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/empty-delete.txt',
+    '+++ /dev/null',
+    '@@ -1,0 +0,0 @@',
+  ]));
+  await expectMissing(dir, 'empty-delete.txt');
+
+  await writeFile(join(dir, 'nonempty-zero-delete.txt'), 'still\n', 'utf8');
+  const nonemptyZeroDelete = await applyNativeError(dir, patchText([
+    '--- a/nonempty-zero-delete.txt',
+    '+++ /dev/null',
+    '@@ -1,0 +0,0 @@',
+  ]));
+  if (!nonemptyZeroDelete.includes('residual byte')) {
+    throw new Error(`native non-empty zero delete lacked residual hint: ${nonemptyZeroDelete}`);
+  }
+  await expectFile(dir, 'nonempty-zero-delete.txt', 'still\n');
+
+  await writeFile(join(dir, 'bad-range.txt'), 'x\n', 'utf8');
+  const badRange = await applyNativeError(dir, patchText([
+    '--- a/bad-range.txt',
+    '+++ b/bad-range.txt',
+    '@@ anchor',
+    '-x',
+    '+X',
+  ]));
+  if (!badRange.includes('@@ -A,B +C,D @@')) {
+    throw new Error(`native bad range lacked counted hunk hint: ${badRange}`);
+  }
+  await expectFile(dir, 'bad-range.txt', 'x\n');
+
+  await writeFile(join(dir, 'dry.txt'), 'stay\n', 'utf8');
+  await dryRunNative(dir, patchText([
+    '--- a/dry.txt',
+    '+++ b/dry.txt',
+    '@@ -1,1 +1,1 @@',
+    '-stay',
+    '+changed',
+  ]));
+  await expectFile(dir, 'dry.txt', 'stay\n');
+
+  await writeFile(join(dir, 'a.txt'), 'a\n', 'utf8');
+  await writeFile(join(dir, 'b.txt'), 'b\n', 'utf8');
+  await applyNative(dir, patchText([
+    '--- a/a.txt',
+    '+++ b/a.txt',
+    '@@ -1,1 +1,1 @@',
+    '-a',
+    '+A',
+    '--- a/b.txt',
+    '+++ b/b.txt',
+    '@@ -1,1 +1,1 @@',
+    '-b',
+    '+B',
+  ]));
+  await expectFile(dir, 'a.txt', 'A\n');
+  await expectFile(dir, 'b.txt', 'B\n');
+
+  const server = new NativePatchServer();
+  try {
+    await writeFile(join(dir, 'server.txt'), 'one\ntwo\n', 'utf8');
+    await server.apply(dir, patchText([
+      '--- a/server.txt',
+      '+++ b/server.txt',
+      '@@ -2,1 +2,1 @@',
+      '-two',
+      '+TWO',
+    ]));
+    await expectFile(dir, 'server.txt', 'one\nTWO\n');
+  } finally {
+    await server.close();
+  }
+
+  console.log('native-patch smoke passed');
+} finally {
+  await rm(dir, { recursive: true, force: true });
+}

package/scripts/patch-interior-context-smoke.mjs

@@ -0,0 +1,49 @@
+// Regression: the JS diagnostic matcher must mirror native
+// evaluate_fuzzy_candidate's change-band logic. Content drift on INTERIOR
+// context (strictly between the first and last change) must NOT be
+// fuzz-consumable -> findFirstFailingUnifiedHunk reports the hunk as failing.
+// Content drift on OUTER context (before first change / after last change),
+// within the fuzz budget, still matches -> no failing hunk.
+import { __patchTestHooks } from '../src/agent/orchestrator/tools/patch.mjs';
+
+const { findFirstFailingUnifiedHunk, computeUnifiedChangeBand, collectUnifiedOps } = __patchTestHooks;
+
+function assert(cond, msg) {
+  if (!cond) throw new Error(`assertion failed: ${msg}`);
+}
+
+// Hunk shape used by the diagnostic matcher: { oldStart, lines: ['<tag><text>'] }.
+// keep1 (outer ctx) / del1 / mid (interior ctx) / del2 / keep2 (outer ctx).
+function makeHunk() {
+  return {
+    oldStart: 1,
+    lines: [' keep1', '-del1', ' mid', '-del2', ' keep2'],
+  };
+}
+
+// 1) Band sanity: changes (deletes) bound an interior context line.
+{
+  const ops = collectUnifiedOps(makeHunk());
+  assert(JSON.stringify(ops) === JSON.stringify(['context', 'delete', 'context', 'delete', 'context']), 'ops sequence');
+  const band = computeUnifiedChangeBand(ops);
+  // del1 -> (1+1)*2=4, del2 -> (3+1)*2=8; mid offset 2 -> (2+1)*2=6 is interior.
+  assert(band.first === 4 && band.last === 8, `band ${JSON.stringify(band)}`);
+}
+
+// 2) INTERIOR context content drift must NOT match (hunk reported as failing).
+{
+  const entry = { oldFileName: 'a/x', hunks: [makeHunk()] };
+  const source = ['keep1', 'del1', 'midDRIFTED', 'del2', 'keep2'];
+  const failing = findFirstFailingUnifiedHunk(entry, source, 2);
+  assert(failing === entry.hunks[0], 'interior drift must produce a failing hunk');
+}
+
+// 3) OUTER context content drift within fuzz budget still matches (no failure).
+{
+  const entry = { oldFileName: 'a/x', hunks: [makeHunk()] };
+  const source = ['keep1DRIFTED', 'del1', 'mid', 'del2', 'keep2'];
+  const failing = findFirstFailingUnifiedHunk(entry, source, 1);
+  assert(failing === null, 'outer drift within budget must match (no failing hunk)');
+}
+
+console.log('patch-interior-context-smoke OK');