mixdog 0.9.95 → 0.9.97

package/src/runtime/agent/orchestrator/tools/lib/pwsh-standby-pool.mjs

@@ -26,18 +26,51 @@
 import { spawn } from 'node:child_process';
 import { basename } from 'node:path';
 import { createHash, randomBytes } from 'node:crypto';
+import { availableParallelism, freemem } from 'node:os';
 import { killProcessTree, windowsPidHasDescendants } from '../builtin/shell-job-process.mjs';
 
+const MB = 1024 * 1024;
+
+export function _resolvePwshPoolTarget({
+    env = process.env,
+    platform = process.platform,
+    parallelism = null,
+    freeMemoryBytes = null,
+} = {}) {
+    const configured = env?.MIXDOG_PWSH_STANDBY_POOL;
+    if (configured != null && configured !== '') {
+        const n = Math.floor(Number(configured));
+        if (Number.isFinite(n) && n >= 0) return Math.min(8, n);
+    }
+    if (platform !== 'win32') return 0;
+    // Tools now execute in the machine-global daemon. Keep client/test
+    // processes at zero by default, but let that ONE host maintain a short-lived
+    // warm burst sized to the machine instead of making every shell call pay the
+    // ~300ms pwsh startup cost.
+    if (env?.MIXDOG_DAEMON_HOST !== '1') return 0;
+    let cores = Number(parallelism);
+    if (!Number.isFinite(cores) || cores < 1) {
+        try { cores = availableParallelism(); } catch { cores = 1; }
+    }
+    let free = freeMemoryBytes == null ? Number.NaN : Number(freeMemoryBytes);
+    if (!Number.isFinite(free) || free < 0) {
+        try { free = freemem(); } catch { free = 0; }
+    }
+    const cpuTarget = Math.max(1, Math.min(4, Math.floor(cores) - 1 || 1));
+    if (free < 768 * MB) return 0;
+    if (free < 1536 * MB) return Math.min(1, cpuTarget);
+    if (free < 3072 * MB) return Math.min(2, cpuTarget);
+    return cpuTarget;
+}
+
 function _poolTarget() {
-    const n = Math.floor(Number(process.env.MIXDOG_PWSH_STANDBY_POOL));
-    if (Number.isFinite(n) && n >= 0) return Math.min(8, n);
-    return 2;
+    return _resolvePwshPoolTarget();
 }
 const POOL_TARGET = _poolTarget();
-// Only standbys older than this are handed out: a younger one is still paying
-// pwsh startup, so adopting it would just relocate the cold cost. Callers get
-// null (classic spawn) while the pool warms.
-const STANDBY_READY_AGE_MS = 400;
+const _envIdleMs = Math.floor(Number(process.env.MIXDOG_PWSH_STANDBY_IDLE_MS));
+const STANDBY_IDLE_MS = Number.isFinite(_envIdleMs) && _envIdleMs >= 0
+    ? _envIdleMs
+    : 60_000;
 const EXPECTED_ARGS = Object.freeze(['-NoLogo', '-NoProfile', '-NonInteractive', '-Command']);
 
 // Marker-loop bootstrap: the standby serves MANY commands over its lifetime.
@@ -132,6 +165,7 @@ function _standbyBootScript(nonce) {
 }
 
 const _idle = [];
+const _taken = new Set();
 let _envSig = null;
 let _exitHookInstalled = false;
 
@@ -144,6 +178,10 @@ function _envSignature(env) {
 }
 
 function _killEntry(entry) {
+    if (entry.idleTimer) {
+        clearTimeout(entry.idleTimer);
+        entry.idleTimer = null;
+    }
     try { entry.child.kill(); } catch { /* already down */ }
 }
 
@@ -152,6 +190,19 @@ function _discardIdle(entry) {
     if (i !== -1) _idle.splice(i, 1);
 }
 
+function _armIdleExpiry(entry) {
+    if (entry.idleTimer) clearTimeout(entry.idleTimer);
+    entry.idleTimer = null;
+    if (STANDBY_IDLE_MS <= 0) return;
+    entry.idleTimer = setTimeout(() => {
+        entry.idleTimer = null;
+        if (entry.taken) return;
+        _discardIdle(entry);
+        _killEntry(entry);
+    }, STANDBY_IDLE_MS);
+    entry.idleTimer.unref?.();
+}
+
 function _installExitHook() {
     if (_exitHookInstalled) return;
     _exitHookInstalled = true;
@@ -173,7 +224,7 @@ function _spawnStandby(shell, env, sig) {
             detached: false,
         });
     } catch { return; }
-    const entry = { child, sig, nonce, spawnedAt: Date.now(), taken: false, consumed: false };
+    const entry = { child, sig, nonce, taken: false, consumed: false, idleTimer: null };
     child.on('error', () => { if (!entry.taken) { _discardIdle(entry); _killEntry(entry); } });
     child.on('exit', () => { if (!entry.taken) _discardIdle(entry); });
     // A dead standby's pending stdin write must never crash the daemon.
@@ -187,10 +238,25 @@ function _spawnStandby(shell, env, sig) {
         child.stderr?.unref?.();
     } catch { /* best-effort */ }
     _idle.push(entry);
+    _armIdleExpiry(entry);
+}
+
+function _poolSizeForSignature(sig) {
+    let count = _idle.reduce((total, entry) => total + (entry.sig === sig ? 1 : 0), 0);
+    for (const entry of _taken) {
+        if (entry.sig === sig) count += 1;
+    }
+    return count;
 }
 
 function _topUp(shell, env, sig) {
-    while (_idle.length < POOL_TARGET) _spawnStandby(shell, env, sig);
+    while (_poolSizeForSignature(sig) < POOL_TARGET) _spawnStandby(shell, env, sig);
+}
+
+function _releaseTaken(entry) {
+    if (!_taken.delete(entry)) return false;
+    entry.taken = false;
+    return true;
 }
 
 /**
@@ -215,11 +281,9 @@ export function takePwshStandby({ shell, shellArgs, env }) {
         _envSig = sig;
     }
     _topUp(shell, env, sig);
-    const now = Date.now();
     let entry = null;
     for (let i = 0; i < _idle.length; i += 1) {
         const cand = _idle[i];
-        if (now - cand.spawnedAt < STANDBY_READY_AGE_MS) continue;
         if (cand.child.exitCode !== null || cand.child.signalCode !== null) continue;
         if (!cand.child.stdin || cand.child.stdin.destroyed) continue;
         _idle.splice(i, 1);
@@ -229,6 +293,11 @@ export function takePwshStandby({ shell, shellArgs, env }) {
     if (!entry) return null;
     entry.taken = true;
     entry.consumed = false;
+    _taken.add(entry);
+    if (entry.idleTimer) {
+        clearTimeout(entry.idleTimer);
+        entry.idleTimer = null;
+    }
     try {
         entry.child.ref();
         entry.child.stdin?.ref?.();
@@ -271,6 +340,7 @@ export function takePwshStandby({ shell, shellArgs, env }) {
         // job's close-wired exit file then records the REAL command exit.
         endStdin() {
             entry.consumed = true;
+            _releaseTaken(entry);
             try { entry.child.stdin.end(); } catch { /* already gone */ }
         },
         // Post-command recycle: return the standby to the pool ONLY when the
@@ -281,6 +351,7 @@ export function takePwshStandby({ shell, shellArgs, env }) {
         async recycle() {
             if (entry.consumed) return false;
             entry.consumed = true;
+            _releaseTaken(entry);
             const c = entry.child;
             const alive = () => c.exitCode === null && c.signalCode === null;
             let dirty = true;
@@ -309,9 +380,7 @@ export function takePwshStandby({ shell, shellArgs, env }) {
                     process.stderr.write(`[pwsh-standby] recycle drained ${_staleBytes}B stale output (pid=${c.pid}) — late flush escaped the previous command's capture\n`);
                 } catch { /* diagnostics only */ }
             }
-            entry.taken = false;
             entry.consumed = false;
-            entry.spawnedAt = Date.now() - STANDBY_READY_AGE_MS;
             try {
                 c.unref();
                 c.stdin?.unref?.();
@@ -319,6 +388,7 @@ export function takePwshStandby({ shell, shellArgs, env }) {
                 c.stderr?.unref?.();
             } catch { /* best-effort */ }
             _idle.push(entry);
+            _armIdleExpiry(entry);
             return true;
         },
     };

package/src/runtime/agent/orchestrator/tools/patch/matcher.mjs

@@ -334,7 +334,10 @@ function rustTrim(s) {
   return s.replace(RUST_TRIM_RE, '');
 }
 export function normalizeTypographic(s) {
-  return rustTrim(String(s ?? ''))
+  // NFC first: a decomposed sequence (Hangul jamo, or "e" + combining acute
+  // from a file authored on another platform) is visually identical to its
+  // composed form but byte-different, which failed an otherwise exact context.
+  return rustTrim(String(s ?? '').normalize('NFC'))
     .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, '-')
     .replace(/[\u2018\u2019\u201A\u201B]/g, "'")
     .replace(/[\u201C\u201D\u201E\u201F]/g, '"')
@@ -405,6 +408,41 @@ export function longestCommonSubstringLen(a, b, cap = 4000) {
   return best;
 }
 
+// Total character drift tolerated per context line by the edit-distance tier.
+// Deliberately tiny: 3 context lines buy exactly 1 character of slack, so the
+// tier rescues a typo, never a genuinely different block.
+export const EDIT_DISTANCE_ALLOWANCE_PER_LINE = 0.34;
+
+// Levenshtein distance with an early exit: returns the exact distance while it
+// stays within `max`, otherwise `max + 1` as soon as that is certain. The
+// length pre-check and the per-row minimum keep a whole-file scan cheap.
+export function boundedEditDistance(a, b, max) {
+  const s = String(a ?? '');
+  const t = String(b ?? '');
+  if (s === t) return 0;
+  if (!(max > 0)) return 1;
+  if (Math.abs(s.length - t.length) > max) return max + 1;
+  const n = s.length;
+  const m = t.length;
+  let prev = new Int32Array(m + 1);
+  let curr = new Int32Array(m + 1);
+  for (let j = 0; j <= m; j++) prev[j] = j;
+  for (let i = 1; i <= n; i++) {
+    curr[0] = i;
+    let rowMin = curr[0];
+    const ci = s.charCodeAt(i - 1);
+    for (let j = 1; j <= m; j++) {
+      const cost = ci === t.charCodeAt(j - 1) ? 0 : 1;
+      const value = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+      curr[j] = value;
+      if (value < rowMin) rowMin = value;
+    }
+    if (rowMin > max) return max + 1;
+    const tmp = prev; prev = curr; curr = tmp;
+  }
+  return prev[m] > max ? max + 1 : prev[m];
+}
+
 export function findLineSequence(lines, needle, fromLine, preferredLine = 0, options = {}) {
   if (!Array.isArray(needle) || needle.length === 0) return Math.max(0, preferredLine || fromLine || 0);
   const eof = options?.eof === true;

package/src/runtime/agent/orchestrator/tools/patch/native-server.mjs

@@ -2,7 +2,7 @@
 // mode gating, binary resolution, prewarm/idle lifecycle, and the char-indexed
 // EDIT client. Split out of patch.mjs; behavior is identical.
 //
-// Backend: NATIVE-ONLY. Every supported apply/edit case is dispatched to the
+// Executor: NATIVE-ONLY. Every supported apply/edit case is dispatched to the
 // mixdog-patch Rust engine via the persistent stdio server. There is NO JS
 // apply fallback: unsupported / unsafe input returns a clean Error string.
 

package/src/runtime/agent/orchestrator/tools/patch/orchestrator.mjs

@@ -144,8 +144,8 @@ function restorePatchRollbackState(snapshots, readStateScope) {
 }
 
 // Apply one "wave" (a set of unique-target parsed entries) via the native
-// (+ JS out-of-base) split. Returns { backend, text } on success or
-// { backend, error } so the caller decides whether earlier waves already
+// (+ JS out-of-base) split. Returns { executor, text } on success or
+// { executor, error } so the caller decides whether earlier waves already
 // committed to disk. Extracted verbatim from the inline applyWave closure so
 // both the default wave loop and sequence mode share identical apply
 // semantics.
@@ -156,7 +156,7 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
   const parsedInside = (wparsed || []).filter(
     (entry) => !isResolvedPathOutsideBase(parsedEntryResolvedPath(entry, basePath), basePath),
   );
-  const backend = outsideEntries.length > 0
+  const executor = outsideEntries.length > 0
     ? (insideEntries.length > 0 ? 'native+js-patch' : 'js-patch')
     : 'native-patch';
   const resultParts = [];
@@ -173,7 +173,7 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
       signal: abortSignal,
       parsed: parsedInside,
     });
-    if (isPatchErrorText(nativeResult)) return { backend, error: nativeResult };
+    if (isPatchErrorText(nativeResult)) return { executor, error: nativeResult };
     resultParts.push(nativeResult);
   }
   if (outsideEntries.length > 0) {
@@ -187,10 +187,10 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
       fuzzy,
       readStateScope,
     });
-    if (isPatchErrorText(jsResult)) return { backend, error: jsResult };
+    if (isPatchErrorText(jsResult)) return { executor, error: jsResult };
     resultParts.push(jsResult);
   }
-  return { backend, text: resultParts.join('\n') };
+  return { executor, text: resultParts.join('\n') };
 }
 
 // Default ordered section mode. Apply each file section in listed order,
@@ -384,7 +384,7 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
       const skipped = [];
       let failed = null;
       let failedIndex = -1;
-      let backend = 'native-patch';
+      let executor = 'native-patch';
       for (let i = 0; i < units.length; i++) {
         const unit = units[i];
         if (failed) { skipped.push(unit.displayPath); continue; }
@@ -421,7 +421,7 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
           }
         }
         const res = await applyParsedWave(wave, basePath, waveOpts);
-        backend = res.backend;
+        executor = res.executor;
         if (res.error) {
           failed = { displayPath: unit.displayPath, error: res.error };
           failedIndex = i;
@@ -459,7 +459,7 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
         }
         const head = `apply_patch: ${verb} ${units.length} section(s)`;
         const body = (appliedTexts ? `${head}\n${appliedTexts}` : head) + dryNote + rejectedTail;
-        return wrapPatchMutationOutput(body, mutationPlan, { backend });
+        return wrapPatchMutationOutput(body, mutationPlan, { executor });
       }
       const failMsg = failed.error.replace(/^Error:\s*/, '');
       const rollbackErrors = (!dryRun && rollbackOnFailure)
@@ -499,7 +499,7 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
       if (skipped.length > 0) {
         lines.push(`--- skipped (not attempted): ${skipped.join(', ')} ---`);
       }
-      return wrapPatchMutationOutput(lines.join('\n') + dryNote + rejectedTail, mutationPlan, { backend });
+      return wrapPatchMutationOutput(lines.join('\n') + dryNote + rejectedTail, mutationPlan, { executor });
     }));
 }
 
@@ -703,7 +703,7 @@ export function appendPostPatchExcerpts(outputText, patchStr, requestedFormat, b
   }
 }
 
-const APPLY_PATCH_SCHEMA_KEYS = new Set(['patch', 'format', 'base_path', 'dry_run', 'reject_partial', 'fuzzy', 'sequence', 'mode']);
+const APPLY_PATCH_SCHEMA_KEYS = new Set(['patch', 'format', 'base_path', 'root', 'dry_run', 'reject_partial', 'fuzzy', 'sequence', 'mode']);
 function salvageShatteredV4APatchArgs(args) {
   if (!args || typeof args !== 'object') return args;
   const rawPatch = typeof args.patch === 'string' ? args.patch : '';
@@ -723,9 +723,41 @@ function salvageShatteredV4APatchArgs(args) {
   return cleaned;
 }
 
+function extractInlinePatchRoot(patchText) {
+  const text = String(patchText || '');
+  const match = /^(\*\*\* Begin Patch\r?\n)\*\*\* Root:[ \t]*(.*?)\r?\n/.exec(text);
+  if (!match) return { patch: text, root: null };
+  const root = String(match[2] || '').trim();
+  if (!root) throw new Error('apply_patch: "*** Root:" requires a containing directory');
+  return {
+    patch: `${match[1]}${text.slice(match[0].length)}`,
+    root,
+  };
+}
+
+function isFilesystemRootSpecifier(value, cwd) {
+  const raw = String(value || '').trim();
+  if (!raw) return false;
+  // Keep Windows semantics testable on every host and reject the ambiguous
+  // drive-relative spelling (`C:`) alongside an actual drive root.
+  if (/^[A-Za-z]:(?:[\\/]?)$/.test(raw)) return true;
+  const resolved = resolveBasePath(cwd, raw);
+  return pathDirname(resolved) === resolved;
+}
+
 async function apply_patch(args, cwd, options = {}) {
   args = salvageShatteredV4APatchArgs(args);
-  const patchStr = salvageV4AOpening((typeof args?.patch === 'string' ? args.patch : '').replace(/^\uFEFF/, ''));
+  let patchStr = salvageV4AOpening((typeof args?.patch === 'string' ? args.patch : '').replace(/^\uFEFF/, ''));
+  const inlineRoot = extractInlinePatchRoot(patchStr);
+  patchStr = inlineRoot.patch;
+  if (inlineRoot.root) {
+    const argumentRoot = typeof args?.root === 'string' ? args.root.trim() : '';
+    if (argumentRoot
+        && pathResolve(resolveBasePath(cwd, argumentRoot)) !== pathResolve(resolveBasePath(cwd, inlineRoot.root))) {
+      throw new Error('apply_patch: root argument conflicts with the "*** Root:" directive');
+    }
+    args = { ...(args || {}), root: inlineRoot.root };
+  }
   if (!patchStr.trim()) {
     throw new Error('apply_patch: "patch" is required (unified diff or V4A patch string)');
   }
@@ -755,6 +787,41 @@ async function apply_patch(args, cwd, options = {}) {
   } catch (err) {
     return `Error: ${err?.message || String(err)}`;
   }
+  // Write-root gate: a patch may only touch paths inside a DECLARED root —
+  // the session directory by default, or `root`/`base_path` when the caller
+  // names one. Anything outside is refused before a single byte is written, so
+  // a mis-scoped working directory can never silently rewrite another tree.
+  // Editing outside stays possible, but only as a deliberate act: name the
+  // root that contains those targets in the same call.
+  const explicitRoot = typeof args?.root === 'string' && args.root.trim() ? args.root.trim() : null;
+  if (explicitRoot && isFilesystemRootSpecifier(explicitRoot, cwd)) {
+    throw new Error(`apply_patch: refusing filesystem root as write root: ${normalizeOutputPath(explicitRoot)}`);
+  }
+  const writeRoot = resolveBasePath(cwd, explicitRoot ?? args?.base_path ?? null);
+  if (explicitRoot) {
+    try {
+      await assertPathReachable(writeRoot);
+      if (!statSync(writeRoot).isDirectory()) {
+        throw new Error(`not a directory — ${normalizeOutputPath(writeRoot)}`);
+      }
+    } catch (err) {
+      throw new Error(`apply_patch: invalid write root ${normalizeOutputPath(writeRoot)}: ${err?.message || String(err)}`);
+    }
+  }
+  const outsideTargets = [];
+  for (const rel of patchTargetPaths(patchStr, basePath)) {
+    const abs = isAbsolute(rel) ? pathResolve(rel) : pathResolve(basePath, rel);
+    if (isResolvedPathOutsideBase(abs, writeRoot)) outsideTargets.push(normalizeOutputPath(abs));
+  }
+  if (outsideTargets.length > 0) {
+    const shown = [...new Set(outsideTargets)];
+    const head = shown.slice(0, 3).join(', ');
+    const more = shown.length > 3 ? ` (+${shown.length - 3} more)` : '';
+    throw new Error(
+      `apply_patch: ${shown.length} target(s) fall outside the write root ${normalizeOutputPath(writeRoot)}: ${head}${more}. `
+      + 'Check the paths first; if intended, set root (JSON) or add "*** Root: <containing directory>" after "*** Begin Patch" (freeform).',
+    );
+  }
   const rejectPartial = args?.reject_partial !== false;
   const dryRun = args?.dry_run === true;
   const fuzzy = args?.fuzzy !== false;
@@ -896,17 +963,17 @@ async function apply_patch(args, cwd, options = {}) {
     if (v4aRenameOnly) {
       const lines = formatV4ARenameSuccessLines(v4aRenameResults);
       if (lines.length === 0) return 'Error: patch contained no applicable file sections';
-      return wrapPatchMutationOutput(`${lines.join('\n')}\n`, mutationPlan, { backend: 'v4a-rename' });
+      return wrapPatchMutationOutput(`${lines.join('\n')}\n`, mutationPlan, { executor: 'v4a-rename' });
     }
     // Apply one wave (a set of unique targets) via applyParsedWave (native +
-    // JS split). Returns { backend, text } on success or { backend, error }.
+    // JS split). Returns { executor, text } on success or { executor, error }.
     const applyWave = (wave) => applyParsedWave(wave, basePath, { fuzz, rejectPartial, dryRun, fuzzy, readStateScope, abortSignal });
 
     // Duplicate-target blocks were split into contiguous sequential groups
     // (listed order preserved); apply them in order, each against the prior
     // group's on-disk result.
     const waveTexts = [];
-    let backend = 'native-patch';
+    let executor = 'native-patch';
     // dry_run never writes, so a later group would validate against unchanged
     // disk and false-fail on any block that depends on an earlier edit. Only
     // the first group is validated under dry_run; the rest are reported as
@@ -914,9 +981,9 @@ async function apply_patch(args, cwd, options = {}) {
     const groupCount = (dryRun && waveDispatch.length > 1) ? 1 : waveDispatch.length;
     for (let w = 0; w < groupCount; w++) {
       const res = await applyWave(waveDispatch[w]);
-      backend = res.backend;
+      executor = res.executor;
       if (res.error) {
-        if (w === 0) return wrapPatchMutationOutput(res.error, mutationPlan, { backend });
+        if (w === 0) return wrapPatchMutationOutput(res.error, mutationPlan, { executor });
         // A later group failed. rejectPartial makes each group all-or-nothing,
         // so every block in groups 1..w is fully committed to disk and left in
         // place. List them all so the caller knows the true on-disk state.
@@ -927,7 +994,7 @@ async function apply_patch(args, cwd, options = {}) {
           '--- failing block ---',
           failMsg,
         ].join('\n');
-        return wrapPatchMutationOutput(note, mutationPlan, { backend });
+        return wrapPatchMutationOutput(note, mutationPlan, { executor });
       }
       waveTexts.push(res.text);
     }
@@ -949,9 +1016,9 @@ async function apply_patch(args, cwd, options = {}) {
         `hunk-level rejected (rejectPartial=false, V4A): ${rejectedV4AHunks.length}`,
         ...rejectedV4AHunks.map((r) => `  REJECT ${r.file || '(unknown)'} — ${String(r.reason || '').split(';')[0].trim()}`),
       ];
-      return wrapPatchMutationOutput(`${combined}\n${tail.join('\n')}`, mutationPlan, { backend });
+      return wrapPatchMutationOutput(`${combined}\n${tail.join('\n')}`, mutationPlan, { executor });
     }
-    return wrapPatchMutationOutput(combined, mutationPlan, { backend });
+    return wrapPatchMutationOutput(combined, mutationPlan, { executor });
   };
 
   return withBuiltinPathLocks(_lockPaths, () =>
@@ -1051,6 +1118,13 @@ function patchTargetPaths(patchStr, basePath) {
     const rel = m[1].trim();
     if (rel) out.push(rel);
   }
+  // A rename WRITES its destination, so the destination is a target too — the
+  // write-root gate and the replay snapshot both need it.
+  const mre = /^\*\*\* Move to:\s*(.+)$/gm;
+  while ((m = mre.exec(String(patchStr || '')))) {
+    const rel = m[1].trim();
+    if (rel) out.push(rel);
+  }
   const ure = /^\+\+\+ (?:b\/)?(.+)$/gm;
   while ((m = ure.exec(String(patchStr || '')))) {
     const rel = m[1].trim();

package/src/runtime/agent/orchestrator/tools/patch/parsing.mjs

@@ -283,6 +283,15 @@ export function parseV4APatch(patchStr) {
     if (rawLine.startsWith('@@')) {
       const anchor = normaliseV4AAnchor(rawLine.slice(2));
       if (currentHunk && currentHunk.lines.length > 0) finishHunk();
+      // Consecutive `@@` lines narrow ONE hunk's position (`@@ class Foo`
+      // then `@@   def bar`): append to the open hunk's anchor chain instead
+      // of replacing the hunk, which dropped every anchor but the last and
+      // let the edit resolve against the wrong occurrence.
+      if (currentHunk && currentHunk.lines.length === 0) {
+        if (anchor) currentHunk.anchors.push(anchor);
+        pendingAnchors = [];
+        continue;
+      }
       pendingAnchors.push(anchor);
       currentHunk = { anchors: pendingAnchors.slice(), lines: [] };
       pendingAnchors = [];
@@ -374,6 +383,13 @@ function parseUnifiedAsV4APatch(patchStr, { label, resolveAnchor }) {
     if (rawLine.startsWith('@@')) {
       const anchor = resolveAnchor(rawLine);
       if (currentHunk && currentHunk.lines.length > 0) finishHunk();
+      // Anchor chain (see the V4A parser above): consecutive `@@` lines refine
+      // one hunk's position and must all be kept.
+      if (currentHunk && currentHunk.lines.length === 0) {
+        if (anchor) currentHunk.anchors.push(anchor);
+        pendingAnchors = [];
+        continue;
+      }
       pendingAnchors.push(anchor);
       currentHunk = { anchors: pendingAnchors.slice(), lines: [] };
       pendingAnchors = [];