mixdog 0.9.150 → 0.9.151

package/src/runtime/agent/orchestrator/tools/builtin/search-grep-tool.mjs

@@ -69,6 +69,10 @@ import { runGrepPathFanout } from './lib/grep-path-fanout.mjs';
 import { runGrepPatternFanout } from './lib/grep-pattern-fanout.mjs';
 import { runGrepChunkMerge } from './lib/grep-chunk-merge.mjs';
 import { runGrepFixedStringFallback } from './lib/grep-fixed-fallback.mjs';
+import {
+    MAX_RESCUE_BYTES as GREP_RESCUE_MAX_BYTES,
+    runGrepSingleFileRescue,
+} from './lib/grep-single-file-rescue.mjs';
 
 // A single glob string may pack multiple filters
 // separated by whitespace or commas, e.g. "*.ts,*.tsx" or "*.ts *.tsx". Split
@@ -95,6 +99,15 @@ function _grepDefaultHeadLimit() {
     return parsed > 0 ? parsed : 250;
 }
 
+// One explicit FILE is scanned directly by the native server — there is no tree
+// to walk — so a long deadline on a file scope can only ever be spent QUEUED
+// behind another request's walk. A scope rooted in a virtual filesystem
+// (/proc, /sys) is exactly that walk, and it starved the searches behind it:
+// a six-line /proc/self/status failed after 17.7s while a plain read of the
+// same file answered in 7ms. Bound the file case to a fraction of the turn and
+// let the JS rescue below answer it instead of spending the turn waiting.
+const SINGLE_FILE_SEARCH_DEADLINE_MS = 2_500;
+
 function _grepContextCharBudget(options = {}) {
     const explicit = Number(options?._grepContextCharBudget);
     if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
@@ -542,7 +555,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
                 fileType,
                 onlyMatching: false,
             });
-            const probeOut = await runRg(probeArgs, { cwd: rgSpawnCwd, signal: sharedSignal });
+            const probeOut = await runRg(probeArgs, searchExecOptions);
             if (String(probeOut).split('\n').some(Boolean)) {
                 return ' (case-insensitive would match — try -i)';
             }
@@ -560,6 +573,18 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         : null;
 
     const GREP_CONTENT_HARD_CAP = 300;
+    const singleFileScope = grepStat.isFile();
+    // Bound ONLY the file sizes the JS rescue below can actually answer. A
+    // bigger file keeps the full budget, so the short deadline can never cost
+    // a caller an answer it would otherwise have received. (A procfs file
+    // reports size 0 and is therefore always bounded — exactly the case that
+    // motivated the bound.)
+    const boundSingleFile = singleFileScope && Number(grepStat.size) <= GREP_RESCUE_MAX_BYTES;
+    const searchExecOptions = {
+        cwd: rgSpawnCwd,
+        signal: sharedSignal,
+        ...(boundSingleFile ? { timeout: SINGLE_FILE_SEARCH_DEADLINE_MS } : {}),
+    };
     try {
         const callerExplicitUnlimited = headLimitCoerced === 0;
         const effectiveHeadLimit = headLimit === Infinity
@@ -620,7 +645,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
                 let ctxPartialSuffix = '';
                 const streamed = await runRgWindowedLines(
                     anchorArgs,
-                    { cwd: rgSpawnCwd, signal: sharedSignal },
+                    searchExecOptions,
                     { offset: 0, limit: anchorCap, summaryLimit: 0 },
                 );
                 let ctxTotalKnown = streamed.complete;
@@ -689,7 +714,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
                 ? GREP_CONTEXT_LINE_HARD_CAP
                 : Math.min(GREP_CONTEXT_LINE_HARD_CAP, Math.max(200, blockBudget * Math.max(1, perBlock) + 8));
             let ctxPartialSuffix = '';
-            const streamed = await runRgWindowedLines(rgArgs, { cwd: rgSpawnCwd, signal: sharedSignal }, { offset: 0, limit: lineCap, summaryLimit: 0 });
+            const streamed = await runRgWindowedLines(rgArgs, searchExecOptions, { offset: 0, limit: lineCap, summaryLimit: 0 });
             const allLines = streamed.lines;
             let ctxTotalKnown = streamed.complete;
             if (streamed.partial) {
@@ -739,7 +764,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         let rgPartialSuffix = '';
         if (effectiveHeadLimit !== Infinity) {
             const summaryLimit = outputMode === 'content' ? 120 : 0;
-            const streamed = await runRgWindowedLines(rgArgs, { cwd: rgSpawnCwd, signal: sharedSignal }, {
+            const streamed = await runRgWindowedLines(rgArgs, searchExecOptions, {
                 offset,
                 limit: effectiveHeadLimit,
                 summaryLimit,
@@ -757,7 +782,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
                     : '\n[warning] rg exit 2 (partial results)';
             }
         } else {
-            const stdout = await runRg(rgArgs, { cwd: rgSpawnCwd, signal: sharedSignal });
+            const stdout = await runRg(rgArgs, searchExecOptions);
             const allLines = String(stdout).split('\n').filter(Boolean);
             windowed = offset > 0 ? allLines.slice(offset) : allLines;
             totalWindowed = windowed.length;
@@ -857,6 +882,36 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     }
     catch (err) {
         if (sharedSignal?.aborted) throw err;
+        // A file scope the native server could not serve is answered by reading
+        // the file; only a scanner that cannot reproduce the request declines.
+        const nativeMissed = err?.code === 'NATIVE_SEARCH_TIMEOUT'
+            || err?.code === 'NATIVE_SEARCH_UNAVAILABLE'
+            || err?.code === 'NATIVE_SEARCH_UNSUPPORTED';
+        if (nativeMissed && singleFileScope) {
+            const rescued = await runGrepSingleFileRescue({
+                filePath: grepResolvedPath,
+                searchPath,
+                patterns,
+                caseInsensitive,
+                multilineMode,
+                onlyMatching: args['-o'] === true,
+                fileType,
+                outputMode,
+                showLineNumbers,
+                withFilename: forceGrepFilename,
+                filenameOmitted,
+                beforeN,
+                afterN,
+                contextN,
+                headLimit,
+                offset,
+                workDir,
+                grepResolvedPath,
+                patternCapNote,
+                globPatterns: normalizedGlobPatterns,
+            });
+            if (rescued !== null) return rescued;
+        }
         if (isRgRegexParseError(err) && !multilineMode) {
             // Fixed-string rescue lives in lib/grep-fixed-fallback.mjs;
             // null falls through to the original rg error below.

package/src/runtime/agent/orchestrator/tools/builtin/search-path-diagnostics.mjs

@@ -4,7 +4,7 @@
  * thin executor; search-tool.mjs re-exports these for unchanged importers.
  */
 import { statSync } from 'fs';
-import { basename, isAbsolute, join, resolve } from 'path';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'path';
 import { findBySuffixStrip, findDirectoryByBasename, findFileByBasename, listSiblings } from './path-diagnostics.mjs';
 import { normalizeOutputPath, resolveAgainstCwd } from './path-utils.mjs';
 
@@ -18,6 +18,9 @@ import { normalizeOutputPath, resolveAgainstCwd } from './path-utils.mjs';
 // indexed file exists or the glob child is unavailable.
 export async function _suggestIndexedPaths(missingPath, executeChildBuiltinTool, workDir) {
     if (typeof executeChildBuiltinTool !== 'function') return '';
+    // An outside path has no indexed twin worth proposing; the project-wide
+    // glob would only spend the turn.
+    if (missingPathIsOutsideProject(workDir, missingPath)) return '';
     const base = String(missingPath).replace(/\\/g, '/').split('/').pop();
     // Skip when there is no usable basename or it carries glob magic (the
     // pattern, not a literal filename, would not map to a real file).
@@ -90,6 +93,50 @@ function cachedFileByBasename(workDir, missingPath, cache) {
     return cache.fileHits;
 }
 
+// A missing ABSOLUTE path that resolves outside the project cannot be
+// corrected by anything inside it: `/sys/block/sd*/size` is not a misplaced
+// project file, and scanning the tree for a file named `size` only spends the
+// turn (measured: three such reads burned 17.5s each and left the shared
+// search server saturated for the calls behind them). The honest recovery for
+// an outside path is its own filesystem: name the nearest directory that does
+// exist and what it holds.
+function missingPathIsOutsideProject(workDir, missingPath) {
+    const raw = String(missingPath || '');
+    if (!raw || !isAbsolute(raw)) return false;
+    if (typeof workDir !== 'string' || !workDir) return false;
+    const rel = relative(resolve(workDir), resolve(raw));
+    return !rel || rel === '..' || rel.startsWith(`..${sep}`) || rel.startsWith('../') || isAbsolute(rel);
+}
+
+function nearestExistingRealParent(missingPath) {
+    try {
+        let dir = dirname(resolve(String(missingPath)));
+        for (let depth = 0; depth < 24; depth += 1) {
+            try {
+                if (statSync(dir).isDirectory()) return dir;
+            } catch { /* keep climbing */ }
+            const parent = dirname(dir);
+            if (!parent || parent === dir) break;
+            dir = parent;
+        }
+    } catch { /* fall through */ }
+    return null;
+}
+
+function outsideProjectNotFoundHint(missingPath, actionVerb) {
+    const parent = nearestExistingRealParent(missingPath);
+    if (!parent) return ' Not found, and no parent directory of it exists either.';
+    const entries = listSiblings(parent, 12).slice(0, 5);
+    const where = `"${normalizeOutputPath(parent)}"`;
+    if (entries.length === 0) {
+        return ` Not found; ${where} exists but is empty — nothing under it to ${actionVerb.toLowerCase()}.`;
+    }
+    const magic = /[*?[\]{}]/.test(String(missingPath))
+        ? ' The path carries a glob pattern; name one of those entries directly.'
+        : '';
+    return ` Not found; the nearest existing directory ${where} holds: ${entries.map((n) => `"${n}"`).join(', ')}.${magic}`;
+}
+
 function isDirectoryPathGuess(missingPath) {
     const base = basename(String(missingPath || '').replace(/\\/g, '/'));
     if (!base || /[*?[\]{}]/.test(base)) return false;
@@ -137,6 +184,9 @@ export function finalizeReadFamilyEnoentTail(hint, requestedPath, errCode = 'ENO
 
 function resolveUniqueEnoentRedirect(workDir, missingPath, errCode = 'ENOENT', cache = null) {
     if (!NOT_FOUND_CODES.has(String(errCode || 'ENOENT'))) return null;
+    // Redirecting an outside path INTO the project would answer a different
+    // question than the one asked.
+    if (missingPathIsOutsideProject(workDir, missingPath)) return null;
     const suffixHit = cachedSuffixStrip(workDir, missingPath, cache);
     if (suffixHit) return suffixHit;
     const elsewhere = cachedFileByBasename(workDir, missingPath, cache);
@@ -183,6 +233,9 @@ export function buildNotFoundHint(workDir, missingPath, actionVerb, errCode = 'E
     if (/^[A-Za-z]:(?![\\/])[^\\/]/.test(rawMissing.replace(/\\/g, '\\'))) {
         return ` The path has a drive letter but no separator after it — the backslashes were probably lost in escaping. Re-issue with forward slashes (e.g. "C:/tmp/smp").`;
     }
+    if (missingPathIsOutsideProject(workDir, missingPath)) {
+        return outsideProjectNotFoundHint(missingPath, actionVerb);
+    }
     if (resolveUniqueEnoentRedirect(workDir, missingPath, errCode, cache)) return '';
     const elsewhere = cachedFileByBasename(workDir, missingPath, cache);
     if (elsewhere.length) {

package/src/runtime/agent/orchestrator/tools/builtin/write-symlink.test.mjs

@@ -0,0 +1,153 @@
+// Writing through a symlink must land on the file the link points at and leave
+// the link in place. The atomic rename would otherwise replace the link with a
+// regular file and silently detach layouts like nginx's sites-enabled/default
+// from sites-available/default.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+    lstatSync,
+    mkdtempSync,
+    readFileSync,
+    realpathSync,
+    rmSync,
+    statSync,
+    symlinkSync,
+    writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { atomicWrite, symlinkWriteTarget } from './atomic-write.mjs';
+import { tryExecuteExternalToolAdapter } from './external-tool-adapters.mjs';
+
+function makeDir() {
+    return mkdtempSync(join(tmpdir(), 'mixdog-write-symlink-'));
+}
+
+// Windows without Developer Mode / admin rights refuses symlink creation
+// (EPERM), so the host capability decides whether these cases can run.
+function symlinkSupported(dir) {
+    try {
+        writeFileSync(join(dir, 'probe.txt'), 'x');
+        symlinkSync(join(dir, 'probe.txt'), join(dir, 'probe.link'));
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+test('symlinkWriteTarget resolves a live link and nothing else', (t) => {
+    const dir = makeDir();
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    if (!symlinkSupported(dir)) {
+        t.skip('symlink creation is not permitted on this host');
+        return;
+    }
+    const real = join(dir, 'real.txt');
+    const link = join(dir, 'link.txt');
+    writeFileSync(real, 'a\n');
+    symlinkSync(real, link);
+
+    assert.equal(symlinkWriteTarget(link), realpathSync(real));
+    assert.equal(symlinkWriteTarget(real), null);
+    assert.equal(symlinkWriteTarget(join(dir, 'missing.txt')), null);
+    // A dangling link has no target to resolve, so the caller keeps its path.
+    const dangling = join(dir, 'dangling.link');
+    symlinkSync(join(dir, 'gone.txt'), dangling);
+    assert.equal(symlinkWriteTarget(dangling), null);
+});
+
+test('atomicWrite writes through a symlink and keeps the link', async (t) => {
+    const dir = makeDir();
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    if (!symlinkSupported(dir)) {
+        t.skip('symlink creation is not permitted on this host');
+        return;
+    }
+    const real = join(dir, 'real.conf');
+    const link = join(dir, 'link.conf');
+    writeFileSync(real, 'old\n');
+    symlinkSync(real, link);
+
+    await atomicWrite(link, 'new\n');
+
+    assert.equal(readFileSync(real, 'utf8'), 'new\n');
+    assert.equal(lstatSync(link).isSymbolicLink(), true);
+});
+
+test('the expected-target guard still fires when the real file moved', async (t) => {
+    const dir = makeDir();
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    if (!symlinkSupported(dir)) {
+        t.skip('symlink creation is not permitted on this host');
+        return;
+    }
+    const real = join(dir, 'guard.conf');
+    const link = join(dir, 'guard.link');
+    writeFileSync(real, 'old\n');
+    symlinkSync(real, link);
+    const before = statSync(link);
+
+    // Somebody else rewrites the real file after the snapshot was taken.
+    writeFileSync(real, 'rewritten by another writer\n');
+
+    await assert.rejects(
+        () => atomicWrite(link, 'mine\n', {
+            expectedTargetSnapshot: {
+                exists: true,
+                size: before.size,
+                mtimeMs: before.mtimeMs,
+                ctimeMs: before.ctimeMs,
+                ino: before.ino,
+            },
+        }),
+        (err) => err?.code === 'ESTALE_TARGET',
+    );
+    assert.equal(readFileSync(real, 'utf8'), 'rewritten by another writer\n');
+    assert.equal(lstatSync(link).isSymbolicLink(), true);
+});
+
+test('edit updates through a symlink and keeps the link', async (t) => {
+    const dir = makeDir();
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    if (!symlinkSupported(dir)) {
+        t.skip('symlink creation is not permitted on this host');
+        return;
+    }
+    const real = join(dir, 'sites-available.conf');
+    const link = join(dir, 'sites-enabled.conf');
+    writeFileSync(real, 'root /var/www/html;\nindex index.html;\n');
+    symlinkSync(real, link);
+
+    const result = String(await tryExecuteExternalToolAdapter('edit', {
+        file_path: link,
+        old_string: 'root /var/www/html;',
+        new_string: 'root /usr/share/novnc;',
+    }, dir, {}));
+
+    assert.match(result, /^Updated /);
+    assert.equal(readFileSync(real, 'utf8'), 'root /usr/share/novnc;\nindex index.html;\n');
+    assert.equal(lstatSync(link).isSymbolicLink(), true);
+});
+
+test('write replaces content through a symlink and keeps the link', async (t) => {
+    const dir = makeDir();
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+    if (!symlinkSupported(dir)) {
+        t.skip('symlink creation is not permitted on this host');
+        return;
+    }
+    const real = join(dir, 'payload.txt');
+    const link = join(dir, 'payload.link');
+    writeFileSync(real, 'old\n');
+    symlinkSync(real, link);
+
+    const result = String(await tryExecuteExternalToolAdapter('write', {
+        file_path: link,
+        contents: 'fresh\n',
+    }, dir, {}));
+
+    assert.match(result, /^Updated /);
+    assert.equal(readFileSync(real, 'utf8'), 'fresh\n');
+    assert.equal(lstatSync(link).isSymbolicLink(), true);
+});

package/src/runtime/agent/orchestrator/tools/code-graph/aggregate-anchor-relocation.test.mjs

@@ -0,0 +1,55 @@
+// A sentinel-free cwd that HOLDS one project answers an anchored call by
+// adopting that project; a genuinely ambiguous tree still refuses, but names
+// where to anchor instead.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { executeCodeGraphTool } from './dispatch.mjs';
+
+const PY = 'class Mean:\n    def compute(self):\n        return 42\n';
+
+function makeRepo(root, name) {
+    const repo = join(root, name);
+    mkdirSync(join(repo, '.git'), { recursive: true });
+    mkdirSync(join(repo, 'tools'), { recursive: true });
+    writeFileSync(join(repo, 'tools', 'compute_mean.py'), PY);
+    return repo;
+}
+
+test('a relative anchor held by exactly one child project adopts that project', async (t) => {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-anchor-one-'));
+    t.after(() => rmSync(root, { recursive: true, force: true }));
+    makeRepo(root, 'caffe');
+
+    const out = String(await executeCodeGraphTool(
+        'code_graph',
+        { mode: 'symbols', files: 'tools/compute_mean.py' },
+        root,
+    ));
+    assert.doesNotMatch(out, /Refusing to index an arbitrary tree/);
+    assert.match(out, /compute/);
+});
+
+test('two child projects holding the same anchor stay refused, with the roots named', async (t) => {
+    const root = mkdtempSync(join(tmpdir(), 'mixdog-anchor-many-'));
+    t.after(() => rmSync(root, { recursive: true, force: true }));
+    makeRepo(root, 'caffe');
+    makeRepo(root, 'caffe-fork');
+
+    let message = '';
+    try {
+        await executeCodeGraphTool(
+            'code_graph',
+            { mode: 'symbols', files: 'tools/compute_mean.py' },
+            root,
+        );
+    } catch (error) {
+        message = String(error?.message || error);
+    }
+    assert.match(message, /Refusing to index an arbitrary tree/);
+    assert.match(message, /Project roots under this cwd/);
+    assert.match(message, /"caffe"/);
+});

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

@@ -365,6 +365,47 @@ function _boundedExactFileAggregateRoot(args, baseCwd) {
   return roots.size === 1 ? [...roots][0] : null;
 }
 
+// A sentinel-free working directory that HOLDS a project (a container's /app
+// with one cloned repo under it) answered every anchored call with a refusal:
+// the caller wrote the anchor the way the repo's own docs do
+// (`tools/compute_image_mean.cpp`), it does not exist under /app, and no root
+// could be derived from a path that resolves nowhere. The relative anchor is
+// still unambiguous whenever exactly ONE child project holds it — that project
+// is the answer, and adopting it is the same recovery read and grep already
+// perform for a misplaced path. Ambiguity (several holders, none, an absolute
+// anchor, a wildcard) keeps refusing.
+function _relocateAggregateAnchorsUnderChildProject(args, baseCwd) {
+  if (!_hasAggregateFileArgs(args)) return null;
+  const files = _collectGraphFileList(args);
+  if (files.length === 0) return null;
+  for (const file of files) {
+    if (_AGGREGATE_FILE_WILDCARD_RE.test(file) || isAbsolute(file)) return null;
+    if (existsSync(pathResolve(baseCwd, file))) return null;
+  }
+  const holders = _childProjectRoots(baseCwd, { cap: 8 })
+    .filter((root) => pathResolve(root) !== pathResolve(baseCwd))
+    .filter((root) => files.every((file) => {
+      try {
+        return statSync(pathResolve(root, file)).isFile();
+      } catch {
+        return false;
+      }
+    }));
+  if (holders.length !== 1) return null;
+  const root = pathResolve(holders[0]);
+  const remap = (file) => pathResolve(root, String(file || '').trim());
+  return {
+    root,
+    args: {
+      ...args,
+      file: typeof args?.file === 'string' && args.file.trim() ? remap(args.file) : args?.file,
+      files: Array.isArray(args?.files)
+        ? args.files.map(remap)
+        : (typeof args?.files === 'string' && args.files.trim() ? remap(args.files) : args?.files),
+    },
+  };
+}
+
 export function _resolveBoundedSentinelFreeAggregateRootForTest(args, baseCwd) {
   if (!_hasAggregateFileArgs(args)) return null;
   const base = pathResolve(baseCwd);
@@ -1045,13 +1086,23 @@ async function executeCodeGraphToolRaw(name, args, cwd, signal = null, options =
       stopAtUserBoundary: !explicitCwdArg,
     }) || _resolveBoundedSentinelFreeAggregateRootForTest(args, baseCwd)
       || _boundedExactFileAggregateRoot(args, baseCwd);
-    if (!aggregateRoot) {
+    const relocated = aggregateRoot ? null : _relocateAggregateAnchorsUnderChildProject(args, baseCwd);
+    if (!aggregateRoot && !relocated) {
+      // Name the projects that DO sit under this cwd: the refusal is only
+      // actionable if the caller learns where to anchor instead.
+      const candidates = _childProjectRoots(baseCwd, { cap: 5 })
+        .filter((root) => pathResolve(root) !== pathResolve(baseCwd))
+        .map((root) => `"${pathBasename(root)}"`);
       throw new Error(
         `${name}: cwd '${baseCwd}' is not inside a project and aggregate file anchors do not all `
-        + `exist under exactly one detectable project root. Refusing to index an arbitrary tree.`,
+        + `exist under exactly one detectable project root. Refusing to index an arbitrary tree.`
+        + (candidates.length
+          ? ` Project roots under this cwd: ${candidates.join(', ')} — anchor the call inside one of them.`
+          : ''),
       );
     }
-    effectiveCwd = aggregateRoot;
+    effectiveCwd = relocated ? relocated.root : aggregateRoot;
+    if (relocated) args = relocated.args;
     args = _absolutizeAggregateFileArgs(args, baseCwd);
   }
   if (fileArg && !hasAggregateFileArgs) {

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.19",
+  "version": "0.1.20",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.19/mixdog-graph-darwin-arm64",
-      "sha256": "7829ad6e428f090843907fd76c2e7b45b9c2314f706776614004fe6715a09313"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.20/mixdog-graph-darwin-arm64",
+      "sha256": "d059f2ab33cb7f97b7c96b4e21e3d16880cc44baf1400ce81374a1031a11ddd9"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.19/mixdog-graph-darwin-x64",
-      "sha256": "84d43ad67fda7399d633d93e51438a01ed817137153e9c6ecb8f911e255b235e"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.20/mixdog-graph-darwin-x64",
+      "sha256": "c91873322ce6390a7103daa4b872e31de1abbe7e922967727f41b5b7b2f21373"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.19/mixdog-graph-linux-arm64",
-      "sha256": "9a0590415b40e90723653205f9476210d031216edff6225b1391a7f350900a12"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.20/mixdog-graph-linux-arm64",
+      "sha256": "e8183e1a36aae1887245bd55b94fae6d3fa874bb350559de95ea6ca65a14c6a0"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.19/mixdog-graph-linux-x64",
-      "sha256": "5bd08eb666c9ad82b0b152ee6207b6c315182b861c60baf58f76d87025dcc2bc"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.20/mixdog-graph-linux-x64",
+      "sha256": "40142ad17359cc2eb490f639de7c358c4449ca36dc7bbb966bff9a21f81df40f"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.19/mixdog-graph-win32-x64.exe",
-      "sha256": "f1a0ed0058797655ca231078da0ceacd0d35a71289a8089c7ba637fcd8634a03"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.20/mixdog-graph-win32-x64.exe",
+      "sha256": "a727ca6ea385d715232ce246c2519037ccd74b509e57d97ad7c1b4a61c26aade"
     }
   }
 }

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, statSync, realpathSync, mkdirSync } from 'node:fs';
 import { unlink } from 'node:fs/promises';
 import { dirname as pathDirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
@@ -393,6 +393,38 @@ function lstatRegularPatchFile(fullPath, displayPath) {
   return st;
 }
 
+// A symlinked target is patched THROUGH the link. atomicWrite compares the
+// live target with statSync, which FOLLOWS a leaf symlink, so the expected
+// snapshot must be taken the same way: an lstat describes the LINK inode
+// (size = target path length, its own mtime/ino) and can never equal the
+// followed stat, which failed every patch aimed at a symlinked file with
+// "changed on disk during the patch". Writing to the resolved real path also
+// keeps the link intact — the atomic rename would otherwise replace the
+// symlink itself with a regular file.
+function resolvePatchWriteTarget(fullPath, displayPath, lst) {
+  if (!lst?.isSymbolicLink?.()) return { writePath: fullPath, snapshotStat: lst };
+  let writePath;
+  let snapshotStat;
+  try {
+    writePath = realpathSync(fullPath);
+    snapshotStat = statSync(fullPath);
+  } catch (err) {
+    throw new Error(
+      `apply_patch: symlink target missing or unreadable: ${normalizeOutputPath(displayPath)}`
+      + ` (${err?.code || err?.message || String(err)})`,
+    );
+  }
+  if (isSpecialFileStat(snapshotStat)) {
+    throw new Error(
+      `apply_patch: cannot patch special file (FIFO / character / block device / socket): ${normalizeOutputPath(displayPath)}`,
+    );
+  }
+  if (!snapshotStat.isFile()) {
+    throw new Error(`apply_patch: symlink target is not a regular file: ${normalizeOutputPath(displayPath)}`);
+  }
+  return { writePath, snapshotStat };
+}
+
 function assertAddTargetAbsent(fullPath, displayPath) {
   try {
     lstatSync(fullPath);
@@ -466,6 +498,7 @@ async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateSco
   }
 
   const preMutationStat = lstatRegularPatchFile(fullPath, displayPath);
+  const { writePath, snapshotStat } = resolvePatchWriteTarget(fullPath, displayPath, preMutationStat);
   // Rewrite path: decode by BOM, re-encode into the same codec, and keep every
   // untouched line's own terminator (spliceTextLinesForPatch).
   // `toString('utf8')` here transcoded non-UTF-8 files and mangled UTF-16.
@@ -482,14 +515,14 @@ async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateSco
     // rewrote this file after we read it, the write fails instead of silently
     // clobbering it (and instead of inheriting a stale "body delivered" claim).
     try {
-      await atomicWrite(fullPath, content, {
+      await atomicWrite(writePath, content, {
         sessionId: readStateScope,
-        expectedTargetSnapshot: preMutationStat ? {
+        expectedTargetSnapshot: snapshotStat ? {
           exists: true,
-          size: preMutationStat.size,
-          mtimeMs: preMutationStat.mtimeMs,
-          ctimeMs: preMutationStat.ctimeMs,
-          ino: preMutationStat.ino,
+          size: snapshotStat.size,
+          mtimeMs: snapshotStat.mtimeMs,
+          ctimeMs: snapshotStat.ctimeMs,
+          ino: snapshotStat.ino,
         } : undefined,
       });
     } catch (err) {
@@ -498,12 +531,13 @@ async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateSco
       }
       throw err;
     }
-    invalidateBuiltinResultCache([fullPath]);
-    markCodeGraphDirtyPaths([fullPath]);
+    const touchedPaths = writePath === fullPath ? [fullPath] : [fullPath, writePath];
+    invalidateBuiltinResultCache(touchedPaths);
+    markCodeGraphDirtyPaths(touchedPaths);
     recordReadSnapshotForPath(fullPath, readStateScope, {
       source: 'apply_patch_js',
       isPartialView: false,
-      preMutationStat,
+      preMutationStat: snapshotStat,
     });
   }
   const { added, removed } = countHunkChanges(entry.hunks);