mixdog 0.9.87 → 0.9.89

package/src/runtime/agent/orchestrator/tools/code-graph/disk-cache.mjs

@@ -8,7 +8,7 @@ import {
   readdirSync, readFileSync, statSync, existsSync, mkdirSync, renameSync, unlinkSync, openSync, readSync, closeSync,
 } from 'node:fs';
 import { getPluginData } from '../../config.mjs';
-import { writeJsonAtomicSync } from '../../../../shared/atomic-file.mjs';
+import { writeJsonAtomicSync, withFileLockSync } from '../../../../shared/atomic-file.mjs';
 import {
   canonicalGraphCwd as _canonicalGraphCwd,
   registerCodeGraphDrain,
@@ -264,60 +264,63 @@ export function _persistDiskCodeGraphCacheNow({
   writeJson = writeJsonAtomicSync,
 } = {}) {
   try {
-    _loadDiskCodeGraphCache();
-    _pruneDiskCodeGraphEntries();
     const dir = _codeGraphDiskDir();
     mkdirSync(dir, { recursive: true });
+    // Graph BUILD work remains fully parallel. Only the short disk COMMIT is
+    // serialized across workers/processes so each writer re-reads and merges
+    // the latest manifest while holding one common lock. Per-file/manifest
+    // atomic writers run lock:false inside this outer critical section.
+    //
+    // Main/TUI debounced writes stay try-once (never Atomics.wait on the event
+    // loop). Worker strict drains may wait because they run off-thread and must
+    // not fail a successful graph build merely because a sibling root finished
+    // at the same instant.
+    withFileLockSync(join(dir, '.persist.lock'), () => {
+      _loadDiskCodeGraphCache();
+      _pruneDiskCodeGraphEntries();
+
+      // Read under the common lock so concurrently completed roots cannot
+      // overwrite one another with manifests based on the same stale snapshot.
+      let preserved = {};
+      try {
+        const raw = readFileSync(join(dir, 'manifest.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object') preserved = parsed;
+      } catch { /* no existing manifest yet */ }
+
+      let manifest = { ...preserved };
+      const validHashes = new Set();
+      for (const [cwd, entry] of _diskCodeGraphCache) {
+        const hash = _hashCwd(cwd);
+        const file = join(dir, `${hash}.json`);
+        writeJson(file, entry, { compact: true, lock: false });
+        let bytes = null;
+        try { bytes = statSync(file).size; } catch { /* written entry may be unavailable */ }
+        manifest[cwd] = {
+          hash,
+          builtAt: entry.builtAt || Date.now(),
+          bytes: Number.isFinite(bytes) ? bytes : undefined,
+          maxFiles: Number.isFinite(entry.maxFiles) ? entry.maxFiles : undefined,
+        };
+      }
+      const pruned = _pruneCodeGraphManifestForBudget(manifest, dir);
+      manifest = pruned.manifest;
+      for (const row of pruned.evicted) {
+        _diskCodeGraphCache.delete(row.cwd);
+      }
+      for (const meta of Object.values(manifest)) {
+        if (meta && typeof meta === 'object' && meta.hash) validHashes.add(meta.hash);
+      }
 
-    // Read the on-disk manifest BEFORE writing so cwd entries owned by
-    // other instances (MIXDOG_MULTI_INSTANCE=1) survive. Without this,
-    // our orphan sweep below would happily unlink another instance's
-    // per-cwd files just because we don't have them in our in-memory map.
-    let preserved = {};
-    try {
-      const raw = readFileSync(join(dir, 'manifest.json'), 'utf8');
-      const parsed = JSON.parse(raw);
-      if (parsed && typeof parsed === 'object') preserved = parsed;
-    } catch { /* no existing manifest yet */ }
-
-    let manifest = { ...preserved };
-    const validHashes = new Set();
-    for (const [cwd, entry] of _diskCodeGraphCache) {
-      const hash = _hashCwd(cwd);
-      const file = join(dir, `${hash}.json`);
-      // Try-once (timeoutMs:0): the debounced flush runs on the lead/TUI main
-      // process (codeGraph tool + prewarm). withFileLockSync's Atomics.wait
-      // would freeze the renderer on cross-process cache contention. Cache is
-      // rebuildable — a busy lock just skips this flush; _scheduleDiskCodeGraphCacheFlush
-      // re-schedules on the next build. Exit drain still runs (unref'd timer
-      // cancelled + direct call).
-      writeJson(file, entry, { compact: true, lock: true, timeoutMs: 0 });
-      let bytes = null;
-      try { bytes = statSync(file).size; } catch { /* written entry may be unavailable */ }
-      manifest[cwd] = {
-        hash,
-        builtAt: entry.builtAt || Date.now(),
-        bytes: Number.isFinite(bytes) ? bytes : undefined,
-        maxFiles: Number.isFinite(entry.maxFiles) ? entry.maxFiles : undefined,
-      };
-    }
-    const pruned = _pruneCodeGraphManifestForBudget(manifest, dir);
-    manifest = pruned.manifest;
-    for (const row of pruned.evicted) {
-      _diskCodeGraphCache.delete(row.cwd);
-    }
-    for (const meta of Object.values(manifest)) {
-      if (meta && typeof meta === 'object' && meta.hash) validHashes.add(meta.hash);
-    }
-
-    const manifestFile = join(dir, 'manifest.json');
-    writeJson(manifestFile, manifest, { compact: true, lock: true, timeoutMs: 0 });
-    _diskManifest = manifest;
+      const manifestFile = join(dir, 'manifest.json');
+      writeJson(manifestFile, manifest, { compact: true, lock: false });
+      _diskManifest = manifest;
 
-    // Sweep orphan per-cwd files. validHashes now includes every hash in
-    // the merged manifest (preserved + ours) so cross-instance cache files
-    // are never collateral damage.
-    _sweepCodeGraphCacheDir(dir, validHashes, { sweepJson: true });
+      // Sweep orphan per-cwd files. validHashes now includes every hash in
+      // the merged manifest (preserved + ours) so cross-instance cache files
+      // are never collateral damage.
+      _sweepCodeGraphCacheDir(dir, validHashes, { sweepJson: true });
+    }, { timeoutMs: strict ? 30_000 : 0 });
   } catch (err) {
     process.stderr.write(`[code-graph] disk cache persist failed (target: ${_codeGraphDiskDir()}): ${err?.message || err}\n`);
     if (strict) throw err;

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs

@@ -62,6 +62,15 @@ const ROOT_FEDERATED_MODES = new Set([
   'references', 'callers', 'callees', 'symbols', 'prewarm',
 ]);
 
+export async function _runCodeGraphFederation(roots, runOne, projectArgs) {
+  return Promise.all((roots || []).map(async (root) => {
+    let body;
+    try { body = await runOne(root, projectArgs); }
+    catch (err) { body = `Error: ${err?.message || String(err)}`; }
+    return `# project ${formatFederatedProjectLabel(root)}\n${body}`;
+  }));
+}
+
 // Absorb: file/files arriving as a JSON-stringified array
 // (file:"[\"a.mjs\",\"b.mjs\"]") — parse to a real array so the graph lookup
 // batches per file instead of treating the JSON text as one (missing) path.
@@ -649,8 +658,7 @@ export async function executeCodeGraphTool(name, args, cwd, signal = null, optio
       }
       const projectArgs = { ...args };
       delete projectArgs.cwd;
-      const sections = [];
-      for (const { file, abs, root } of routed) {
+      const sections = await Promise.all(routed.map(async ({ file, abs, root }) => {
         const excludedProjectRoots = trustedRoots.filter((candidate) => candidate !== root
           && owningTrustedCodeGraphRoot(candidate, [root]) === root);
         let body;
@@ -665,8 +673,8 @@ export async function executeCodeGraphTool(name, args, cwd, signal = null, optio
         } catch (err) {
           body = `Error: ${err?.message || String(err)}`;
         }
-        sections.push(`# ${rawMode} ${file}\n# project ${formatFederatedProjectLabel(root)}\n${body}`);
-      }
+        return `# ${rawMode} ${file}\n# project ${formatFederatedProjectLabel(root)}\n${body}`;
+      }));
       return sections.join('\n\n');
     }
     if (trustedRoots.length && canFederate) {
@@ -687,17 +695,8 @@ export async function executeCodeGraphTool(name, args, cwd, signal = null, optio
             && owningTrustedCodeGraphRoot(candidate, [root]) === root),
         },
       );
-      let federationWork;
-      federationWork = (async () => {
-        const sections = [];
-        for (const root of trustedRoots) {
-          let body;
-          try { body = await runOne(root, projectArgs); }
-          catch (err) { body = `Error: ${err?.message || String(err)}`; }
-          sections.push(`# project ${formatFederatedProjectLabel(root)}\n${body}`);
-        }
-        return sections.join('\n\n');
-      })();
+      const federationWork = _runCodeGraphFederation(trustedRoots, runOne, projectArgs)
+        .then((sections) => sections.join('\n\n'));
       if (federationWork) {
         if (!signal) return federationWork;
         let onAbort = null;

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

@@ -2,7 +2,7 @@
 // verbatim from patch.mjs; native protocol, cache/snapshot side effects, and
 // output formatting are unchanged.
 
-import { readFileSync, lstatSync, mkdirSync } from 'node:fs';
+import { readFileSync, lstatSync, mkdirSync, writeFileSync } from 'node:fs';
 import { unlink } from 'node:fs/promises';
 import { dirname as pathDirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
@@ -23,7 +23,6 @@ import {
   isResolvedPathOutsideBase,
   countHunkChanges,
 } from './paths.mjs';
-import { applyV4AHunksToLines } from './v4a-convert.mjs';
 import {
   getNativePatchServer,
   scheduleNativePatchIdleClose,
@@ -35,10 +34,14 @@ import {
   extractNativeFailurePath,
   nativeFailureMatchesEntry,
   findFirstFailingUnifiedHunk,
+  findUnifiedHunkMatch,
+  collectUnifiedNewLines,
+  assertSafeReplacementPlan,
   firstFailingUnifiedHunkLineDetail,
   firstMeaningfulUnifiedHunkLine,
   firstMeaningfulUnifiedEntryLine,
   compactPatchPreviewLine,
+  formatPatchSourceExcerpt,
   nearestPatchLineHint,
   normalizeTypographic,
   splitBufferLinesForPatch,
@@ -187,8 +190,110 @@ function entryPathKey(fullPath) {
 }
 
 function joinTextLinesForPatch(lines) {
-  const body = (lines || []).join('\n');
-  return lines?.hasFinalNewline !== false ? `${body}\n` : body;
+  const eol = lines?.eol || '\n';
+  const body = (lines || []).join(eol);
+  return lines?.hasFinalNewline !== false ? `${body}${eol}` : body;
+}
+
+// The file's dominant line terminator. splitTextLinesForPatch() folds CRLF into
+// LF, so without this an out-of-base CRLF file would be rewritten as LF.
+function detectDominantEol(text) {
+  const body = String(text ?? '');
+  let lf = 0;
+  let crlf = 0;
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] !== '\n') continue;
+    lf++;
+    if (i > 0 && body[i - 1] === '\r') crlf++;
+  }
+  return lf > 0 && crlf * 2 >= lf ? '\r\n' : '\n';
+}
+
+function cloneTextLinesForPatch(sourceLines, eol) {
+  const lines = [...(sourceLines || [])];
+  lines.hasFinalNewline = sourceLines?.hasFinalNewline !== false;
+  lines.eol = eol || sourceLines?.eol || '\n';
+  return lines;
+}
+
+// Which side of the hunk, if any, carries an explicit
+// `` marker. Both transitions must be honoured:
+// a marker on the NEW side drops the terminator, a marker on the OLD side
+// only (patch re-adds it) restores one.
+function unifiedHunkEofIntent(hunk) {
+  let lastSide = null;
+  let oldNoNewline = false;
+  let newNoNewline = false;
+  for (const raw of hunk?.lines || []) {
+    if (typeof raw !== 'string' || raw.length === 0) continue;
+    const tag = raw[0];
+    if (tag === '\\') {
+      if (lastSide === 'context') { oldNoNewline = true; newNoNewline = true; }
+      else if (lastSide === 'old') oldNoNewline = true;
+      else if (lastSide === 'new') newNoNewline = true;
+      continue;
+    }
+    if (tag === ' ') lastSide = 'context';
+    else if (tag === '-') lastSide = 'old';
+    else if (tag === '+') lastSide = 'new';
+    else lastSide = null;
+  }
+  return { oldNoNewline, newNoNewline };
+}
+
+// Same recovery shape the native failure path emits: expected line, nearest
+// candidate, and a bounded verbatim excerpt of the current file.
+function unifiedHunkMissMessage(displayPath, hunk, sourceLines) {
+  const detail = firstFailingUnifiedHunkLineDetail(sourceLines, hunk)
+    || firstMeaningfulUnifiedHunkLine(hunk);
+  const expected = detail?.line || '';
+  const preferred = Number.isFinite(detail?.preferredLine) ? detail.preferredLine : 0;
+  const nearest = expected ? nearestPatchLineHint(sourceLines, expected, preferred) : '';
+  const excerpt = formatPatchSourceExcerpt(sourceLines, preferred, (hunk?.lines || []).length);
+  return `apply_patch: hunk context not found in ${displayPath}`
+    + (expected ? `; expected first old/context line: ${JSON.stringify(compactPatchPreviewLine(expected))}` : '')
+    + (nearest ? `; ${nearest}` : '')
+    + '; use exact current lines, no stubs.'
+    + excerpt;
+}
+
+// Apply already-parsed UNIFIED hunks with their declared coordinates: each
+// hunk is first tried at its own `@@` position and only then fuzz-matched
+// forward, mirroring the native engine. Insert-only hunks (`-N,0`) land at
+// their declared index (end-of-file for a converted V4A addition) and never
+// advance the cursor, so a later hunk can still resolve before them. The plan
+// is validated for overlaps/equal starts BEFORE any mutation, then applied in
+// descending order so earlier positions stay valid.
+function applyUnifiedHunksToLines(sourceLines, hunks, { fuzz, displayPath, eol }) {
+  const lines = cloneTextLinesForPatch(sourceLines, eol);
+  const replacements = [];
+  let minStartIdx = 0;
+  for (const hunk of hunks || []) {
+    const match = findUnifiedHunkMatch(lines, hunk, minStartIdx, fuzz);
+    if (!match) throw new Error(unifiedHunkMissMessage(displayPath, hunk, lines));
+    const { newLines } = collectUnifiedNewLines(hunk);
+    const intent = unifiedHunkEofIntent(hunk);
+    replacements.push({
+      start: match.start,
+      oldLen: match.end - match.start,
+      newLines,
+      intent,
+      atEof: match.end >= lines.length,
+    });
+    minStartIdx = Math.max(minStartIdx, match.end);
+  }
+  replacements.sort((a, b) => a.start - b.start);
+  assertSafeReplacementPlan(replacements, `apply_patch: ${displayPath}`);
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const rep = replacements[i];
+    lines.splice(rep.start, rep.oldLen, ...rep.newLines);
+    // Explicit markers win in BOTH directions; a hunk that is silent about the
+    // terminator leaves the file's existing state untouched (native parity).
+    if (!rep.atEof) continue;
+    if (rep.intent.newNoNewline) lines.hasFinalNewline = false;
+    else if (rep.intent.oldNoNewline) lines.hasFinalNewline = true;
+  }
+  return lines;
 }
 
 function lstatRegularPatchFile(fullPath, displayPath) {
@@ -201,6 +306,18 @@ function lstatRegularPatchFile(fullPath, displayPath) {
   return st;
 }
 
+// Existence probe for an Add File target: every existing path shape is
+// refused, matching the native in-base guard (`create target already exists`).
+function assertCreateTargetAbsent(fullPath, displayPath) {
+  try {
+    lstatSync(fullPath);
+  } catch (err) {
+    if (err?.code === 'ENOENT') return;
+    throw new Error(`apply_patch: create target unreadable: ${normalizeOutputPath(displayPath)} (${err?.code || err?.message || String(err)})`);
+  }
+  throw new Error(`apply_patch: create target already exists: ${normalizeOutputPath(displayPath)}`);
+}
+
 function findParsedForRow(row, parsed, basePath) {
   const key = entryPathKey(row.fullPath);
   for (const entry of parsed || []) {
@@ -219,6 +336,9 @@ async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateSco
   }
 
   if (kind === 'create') {
+    // Refuse before any write, in dry runs too, so an Add File section can
+    // never clobber (or follow) an existing out-of-base path.
+    assertCreateTargetAbsent(fullPath, displayPath);
     const addedLines = [];
     for (const hunk of entry.hunks || []) {
       for (const line of hunk.lines || []) {
@@ -228,7 +348,7 @@ async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateSco
     const content = joinTextLinesForPatch(addedLines);
     if (!dryRun) {
       mkdirSync(pathDirname(fullPath), { recursive: true });
-      await atomicWrite(fullPath, content, { sessionId: readStateScope });
+      writeFileSync(fullPath, content);
       invalidateBuiltinResultCache([fullPath]);
       markCodeGraphDirtyPaths([fullPath]);
       recordReadSnapshotForPath(fullPath, readStateScope, { source: 'apply_patch_js', isPartialView: false });
@@ -251,9 +371,13 @@ async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateSco
 
   lstatRegularPatchFile(fullPath, displayPath);
   const raw = readFileSync(fullPath);
-  const sourceLines = splitTextLinesForPatch(raw.toString('utf8'));
-  const v4aHunks = (entry.hunks || []).map((h) => ({ lines: h.lines || [] }));
-  const updatedLines = applyV4AHunksToLines(sourceLines, v4aHunks, { fuzzy });
+  const rawText = raw.toString('utf8');
+  const sourceLines = splitTextLinesForPatch(rawText);
+  const updatedLines = applyUnifiedHunksToLines(sourceLines, entry.hunks || [], {
+    fuzz: fuzzy ? 2 : 0,
+    displayPath,
+    eol: detectDominantEol(rawText),
+  });
   const content = joinTextLinesForPatch(updatedLines);
   if (!dryRun) {
     await atomicWrite(fullPath, content, { sessionId: readStateScope });

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

@@ -39,6 +39,62 @@ export function collectUnifiedOps(hunk) {
   return ops;
 }
 
+// New-side lines of a unified hunk (context + additions), plus whether the
+// hunk marks the NEW content as lacking a terminating newline
+// (`` directly after a ' ' / '+' line).
+export function collectUnifiedNewLines(hunk) {
+  const newLines = [];
+  let lastWasNew = false;
+  let noFinalNewline = false;
+  for (const raw of hunk?.lines || []) {
+    if (typeof raw !== 'string' || raw.length === 0) continue;
+    const tag = raw[0];
+    if (tag === ' ' || tag === '+') {
+      newLines.push(raw.slice(1));
+      lastWasNew = true;
+      continue;
+    }
+    if (tag === '\\') {
+      if (lastWasNew) noFinalNewline = true;
+      lastWasNew = false;
+      continue;
+    }
+    lastWasNew = false;
+  }
+  return { newLines, noFinalNewline };
+}
+
+// Guard a replacement plan before it is applied in DESCENDING order (the
+// Codex `apply_replacements` shape). The plan must already be sorted
+// ascending by `start`. Descending application is only content-safe when the
+// replaced ranges are disjoint; the single well-defined exception is several
+// zero-length insertions at one index, which descending application emits in
+// their original source order. Everything else (an overlap, or an insertion
+// sharing an index with a replacement) would silently truncate or reorder
+// content, so it is rejected before any write.
+export function assertSafeReplacementPlan(replacements, label = 'apply_patch') {
+  const plan = Array.isArray(replacements) ? replacements : [];
+  for (let i = 1; i < plan.length; i++) {
+    const prev = plan[i - 1];
+    const cur = plan[i];
+    const prevEnd = prev.start + prev.oldLen;
+    if (cur.start === prev.start) {
+      if (prev.oldLen === 0 && cur.oldLen === 0) continue;
+      throw new Error(
+        `${label}: two hunks resolve to the same position (line ${cur.start + 1}) and at least one of them replaces existing lines; `
+        + 'widen their context or split them into separate patches.',
+      );
+    }
+    if (cur.start < prevEnd) {
+      throw new Error(
+        `${label}: hunks overlap — line ${cur.start + 1} falls inside lines ${prev.start + 1}-${prevEnd} already replaced by an earlier hunk; `
+        + 'widen their context or split them into separate patches.',
+      );
+    }
+  }
+  return plan;
+}
+
 export function computeUnifiedChangeBand(ops) {
   let first = null;
   let last = null;
@@ -143,7 +199,12 @@ export function unifiedOldLinesMatchAt(sourceLines, oldLines, startIdx, fuzz, ba
     const expectedBytes = toLineBytes(expected.line);
     const expectedNL = expected.hasNewline !== false;
     const actualNL = !(actualIdx === lastSrcIdx && !srcFinalNewline);
-    const newlineOk = expectedNL === actualNL;
+    // Mirrors the native `newline_flags_compatible`: a hunk that ends on the
+    // file's LAST line encodes it with the default "has newline" unless the
+    // patch carries a `` marker, so that single
+    // EOF mismatch is tolerated for the hunk's last old line only.
+    const newlineOk = expectedNL === actualNL
+      || (offset + 1 === oldLines.length && actualIdx === lastSrcIdx && expectedNL && !actualNL);
     if (newlineOk && actualBytes.equals(expectedBytes)) continue;
     if (newlineOk && fuzz > 0 && (expected.tag === ' ' || expected.tag === '-') && byteTrimPatchWhitespace(actualBytes).equals(byteTrimPatchWhitespace(expectedBytes))) continue;
     if (
@@ -176,12 +237,15 @@ export function unifiedOldLinesMatchAt(sourceLines, oldLines, startIdx, fuzz, ba
   return { fuzzUsed, normCount };
 }
 
-function findUnifiedHunkMatch(sourceLines, hunk, minStartIdx, fuzz) {
+export function findUnifiedHunkMatch(sourceLines, hunk, minStartIdx, fuzz) {
   const oldLines = collectUnifiedOldLines(hunk);
   const band = computeUnifiedChangeBand(collectUnifiedOps(hunk));
   const oldStart = Math.max(0, (Number(hunk?.oldStart) || 1) - 1);
   if (oldLines.length === 0) {
-    const insertIdx = Math.max(0, Number(hunk?.oldStart) || 0);
+    // jsdiff bumps `oldStart` by one for a zero-old-count hunk (the unified
+    // "insert after line N" quirk), so the 0-based insertion index is
+    // `oldStart - 1`.
+    const insertIdx = Math.max(0, (Number(hunk?.oldStart) || 0) - 1);
     return insertIdx >= minStartIdx && insertIdx <= sourceLines.length ? { start: insertIdx, end: insertIdx } : null;
   }
   if (oldStart >= minStartIdx && unifiedOldLinesMatchAt(sourceLines, oldLines, oldStart, 0, band) !== null) {
@@ -375,6 +439,25 @@ export function findLineSequence(lines, needle, fromLine, preferredLine = 0, opt
       return starts[0];
     }
   }
+  // Whole-file unique-verbatim fallback: an @@ anchor that matched a LATER
+  // occurrence, or a previous hunk that advanced the cursor, leaves the
+  // forward-only search blind to a block that exists verbatim EARLIER in the
+  // file (measured: the majority of real context-miss failures). Accept that
+  // block ONLY when it matches exactly once in the entire file — zero
+  // ambiguity about where it belongs — and never for `*** End of File` hunks.
+  // assertSafeReplacementPlan still rejects any overlap with another hunk's
+  // replacement, so a rewound match can not silently collide.
+  if (fuzzy && !eof && minStart > 0) {
+    const starts = [];
+    for (let i = 0; i + needle.length <= lines.length && starts.length < 2; i++) {
+      let ok = true;
+      for (let k = 0; k < needle.length; k++) {
+        if (lines[i + k] !== needle[k]) { ok = false; break; }
+      }
+      if (ok) starts.push(i);
+    }
+    if (starts.length === 1) return starts[0];
+  }
   if (fuzzy && needle.length === 1) {
     const want = String(needle[0] ?? '').replace(/\s+/g, ' ').trim();
     if (want.length >= 40) {

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

@@ -17,7 +17,12 @@ import { getPluginData } from '../../config.mjs';
 import { ensurePatchBinary, findCachedPatchBinary } from '../patch-binary-fetcher.mjs';
 
 const PLUGIN_ROOT = process.env.MIXDOG_ROOT
-  || pathResolve(pathDirname(fileURLToPath(import.meta.url)), '../../../../..');
+  // This module lives at src/runtime/agent/orchestrator/tools/patch/, so the
+  // repo root is SIX levels up. Five levels stopped at src/ and made the
+  // documented "local cargo build first" rule dead code: the local
+  // native/mixdog-patch/target/release build was never found and a stale
+  // cached prebuilt was used instead, so native fixes could not be exercised.
+  || pathResolve(pathDirname(fileURLToPath(import.meta.url)), '../../../../../..');
 const NATIVE_PATCH_DEFAULT_BIN = pathJoin(
   PLUGIN_ROOT,
   'native/mixdog-patch/target/release',