mixdog 0.9.38 → 0.9.40

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

@@ -61,7 +61,6 @@ import {
     runResultCacheInFlight,
     statPathsForMtime,
 } from './cache-layers.mjs';
-import { recordReadSnapshot } from './read-snapshot-runtime.mjs';
 import { applyGrepContextLeadPolicy, GREP_CONTEXT_MAX, hasUnsupportedRipgrepRegex } from './arg-guard.mjs';
 
 // Default surrounding-lines window applied by output_mode:'content_with_context'
@@ -502,34 +501,62 @@ function formatGrepOutput({ windowed, totalWindowed, totalKnown, headLimit, offs
 export async function executeGrepTool(args, workDir, executeChildBuiltinTool, readStateScope = null, options = {}) {
     args = normalizeGrepArgs(args);
     args.path = coerceReadFamilyPathArg(args.path, workDir);
-    // Fan-out guard: batch multiple string paths sequentially, mirroring
-    // code_graph files[] batching. Recursive calls pass a single string
-    // path, so recursion bottoms out after one level.
+    // Fan-out guard: batch multiple string paths with bounded concurrency,
+    // mirroring code_graph files[] batching. Recursive calls pass a single
+    // string path, so recursion bottoms out after one level. Results are
+    // assembled below in input order, regardless of completion order.
     if (Array.isArray(args.path)) {
         const GREP_PATH_CAP = 10;
+        const GREP_PATH_CONCURRENCY = 4;
         const seen = new Set();
         const list = args.path
             .map(p => typeof p === 'string' ? p.trim() : '')
             .filter(p => p && !seen.has(p) && seen.add(p));
         if (list.length > 1) {
             const capped = list.slice(0, GREP_PATH_CAP);
-            const parts = [];
-            for (const p of capped) {
-                let body;
-                try {
-                    body = await executeGrepTool({ ...args, path: p }, workDir, executeChildBuiltinTool, readStateScope, options);
-                } catch (err) {
-                    body = `Error: ${err && err.message ? err.message : err}`;
+            const nestedOptions = { ...options, _grepPathFanout: true };
+            const configuredOutputCap = Number(options?.toolOutputMaxBytes) > 0
+                ? Math.trunc(Number(options.toolOutputMaxBytes))
+                : Math.trunc(Number(process.env.MIXDOG_TOOL_OUTPUT_MAX_BYTES));
+            const bodies = new Array(capped.length);
+            let next = 0;
+            const runWorker = async () => {
+                while (next < capped.length) {
+                    const index = next++;
+                    const p = capped[index];
+                    try {
+                        bodies[index] = await executeGrepTool(
+                            { ...args, path: p },
+                            workDir,
+                            executeChildBuiltinTool,
+                            readStateScope,
+                            nestedOptions,
+                        );
+                    } catch (err) {
+                        bodies[index] = `Error: ${err && err.message ? err.message : err}`;
+                    }
                 }
-                parts.push(`# grep ${p}\n${body}`);
-            }
+            };
+            await Promise.all(
+                Array.from(
+                    { length: Math.min(GREP_PATH_CONCURRENCY, capped.length) },
+                    () => runWorker(),
+                ),
+            );
+            const parts = capped.map((p, index) => `# grep ${p}\n${bodies[index]}`);
             if (list.length > GREP_PATH_CAP) {
                 parts.push(`[capped at ${GREP_PATH_CAP} of ${list.length} paths]`);
                 // Omitted paths mean the returned result cannot cover the whole
                 // requested path set — never let it be cached as complete.
                 if (options?.scopedCacheOutcome) markScopedCacheIncomplete(options.scopedCacheOutcome);
             }
-            return parts.join('\n\n');
+            const output = parts.join('\n\n');
+            if (configuredOutputCap > 0
+                && Buffer.byteLength(output, 'utf8') > configuredOutputCap
+                && options?.scopedCacheOutcome) {
+                markScopedCacheIncomplete(options.scopedCacheOutcome);
+            }
+            return output;
         }
         args.path = list[0];
     }
@@ -646,17 +673,11 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     if (rawOutputMode && !ALLOWED_OUTPUT_MODES.has(rawOutputMode)) {
         return `Error: invalid output_mode ${JSON.stringify(args.output_mode)}; expected one of ${[...ALLOWED_OUTPUT_MODES].join(', ')}`;
     }
-    // `content_with_context` is a convenience alias for `content` that auto-applies
-    // a generous surrounding-lines window, so the model can read a match in place
-    // without following up with `read`. It maps to content mode; the default
-    // context is applied below unless the caller passed an explicit -A/-B/-C/context.
-    const wantAutoContext = rawOutputMode === 'content_with_context';
-    // Default to `content` when output_mode is omitted. A pattern is always
-    // present here (the no-pattern case returned above), so this is a content
-    // search — it should return the matching lines WITH line numbers, not just
-    // filenames. Filename-only was forcing callers to re-grep for the actual
-    // coordinates (the explorer over-iteration root cause). `files_with_matches`
-    // is now opt-in; pure filename discovery belongs to `glob`.
+    // Omitted output_mode and `content_with_context` both return content with a
+    // generous surrounding-lines window. Explicit `content` remains bare.
+    const wantAutoContext = rawOutputMode === '' || rawOutputMode === 'content_with_context';
+    // Filename-only and count searches are explicit: callers must opt into
+    // `files_with_matches` or `count` when they only need existence/count data.
     const outputMode = (rawOutputMode === 'content_with_context') ? 'content' : (rawOutputMode || 'content');
     const headLimitRaw = args.head_limit;
     const headLimitCoerced = coerceNonNegInt(headLimitRaw);
@@ -740,13 +761,16 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         // apply dedup/section assembly in the original pattern order so the
         // shared `seen` set and output text stay byte-identical to the
         // sequential version.
-        const subs = await Promise.all(patterns.map(async (p) => {
+        const runPattern = async (p) => {
             try {
                 return await executeGrepTool({ ...args, pattern: p }, workDir, executeChildBuiltinTool, readStateScope, subOptions);
             } catch (err) {
                 return `Error: ${err && err.message ? err.message : err}`;
             }
-        }));
+        };
+        const subs = options._grepPathFanout
+            ? await patterns.reduce(async (all, p) => [...await all, await runPattern(p)], Promise.resolve([]))
+            : await Promise.all(patterns.map(runPattern));
         const parts = patterns.map((p, i) => `# grep pattern:${JSON.stringify(p)}\n${dedupeFanoutMatchLines(subs[i], seen)}`);
         return patternCapNote + parts.join('\n\n');
     }
@@ -866,17 +890,12 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         // (or a differently-capped one) in the internal result cache.
         patternCapTotal,
     });
-    // Single-file grep registers a whole-file read snapshot (parity with
-    // apply_patch), satisfying the read-before-edit guard while keeping drift
-    // detection intact via the auto-computed contentHash. Directory/glob greps
-    // do NOT record.
-    const recordGrepReadSnapshot = (st) => {
-        try {
-            if (st && st.isFile()) {
-                recordReadSnapshot(grepResolvedPath, st, readStateScope, { source: 'grep' });
-            }
-        } catch {}
-    };
+    // Read-only search: grep no longer records a whole-file read snapshot.
+    // That snapshot existed only to satisfy the apply_patch read-before-edit
+    // guard, and computing it turned a single-file grep into rg PLUS a full
+    // whole-file read+hash (recordReadSnapshot hashes the whole file when the
+    // range covers it). Edit-safety is unaffected: the read and apply_patch
+    // paths still record their own snapshots.
 
     const cached = cacheGet(cacheKey);
     // Cache-hit returns a PRIOR grep's output; the file may have changed since
@@ -889,12 +908,14 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     let grepStat;
     try { grepStat = statSync(grepResolvedPath); }
     catch (err) {
+        const enoentCache = {};
         const redirected = await tryReadFamilyEnoentRedirect({
             workDir,
             resolvedPath: grepResolvedPath,
             requestedPath: searchPath,
             errCode: err?.code,
             options,
+            cache: enoentCache,
             rerun: (target, opts) => executeGrepTool(
                 { ...args, path: target },
                 workDir,
@@ -905,7 +926,7 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         });
         if (redirected) return redirected;
         const msg = `Error: path does not exist: ${normalizeOutputPath(grepResolvedPath)} (${err?.code || 'ENOENT'})`;
-        let hint = buildNotFoundHint(workDir, grepResolvedPath, 'Search', err?.code);
+        let hint = buildNotFoundHint(workDir, grepResolvedPath, 'Search', err?.code, enoentCache);
         if (!hint) hint = await _suggestIndexedPaths(grepResolvedPath, executeChildBuiltinTool, workDir);
         return msg + finalizeReadFamilyEnoentTail(hint, searchPath, err?.code);
     }
@@ -995,7 +1016,6 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
             if (options?.scopedCacheOutcome && (!ctxTotalKnown || ctx.omitted > 0)) {
                 markScopedCacheIncomplete(options.scopedCacheOutcome);
             }
-            recordGrepReadSnapshot(grepStat);
             if (ctxTotalKnown && ctx.omitted === 0) {
                 cacheSet(cacheKey, ctxOut, { scopes: [grepResolvedPath] });
             }
@@ -1107,7 +1127,6 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         if (options?.scopedCacheOutcome && (!totalKnown || remaining > 0)) {
             markScopedCacheIncomplete(options.scopedCacheOutcome);
         }
-        recordGrepReadSnapshot(grepStat);
         if (totalKnown && remaining === 0) {
             cacheSet(cacheKey, out, { scopes: [grepResolvedPath] });
         }
@@ -1207,7 +1226,6 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
                         filenameOmitted,
                         prefix: patternCapNote + '[regex parse fallback: fixed-string terms]\n',
                     }) || `(no matches) fixed_terms=${JSON.stringify(fixedPatterns)} path=${searchPath}`;
-                    recordGrepReadSnapshot(grepStat);
                     return body + rgPartialSuffix;
                 } catch { /* fall through to the original rg error */ }
             }
@@ -1294,16 +1312,28 @@ export async function executeGlobTool(args, workDir, options = {}) {
     const basePaths = (Array.isArray(args.path) && args.path.length > 0)
         ? args.path
         : [args.path || '.'];
+    // Call-scoped stat cache: the preflight below stats each root, the per-group
+    // rg runs re-stat the same resolved cwd, and the empty-result diagnostic
+    // stats it a third time. Memoize by resolved path so each root is stat'd once.
+    const statCache = new Map();
+    const statCached = (resolvedPath) => {
+        if (statCache.has(resolvedPath)) return statCache.get(resolvedPath);
+        let entry;
+        try { entry = { st: statSync(resolvedPath), err: null }; }
+        catch (err) { entry = { st: null, err }; }
+        statCache.set(resolvedPath, entry);
+        return entry;
+    };
     if (!options._enoentRedirectFrom) {
         for (const only of basePaths) {
             const resolvedOnly = resolveSearchScope(only, workDir);
-            try { statSync(resolvedOnly); }
-            catch (err) {
+            const pre = statCached(resolvedOnly);
+            if (pre.err) {
                 const redirected = await tryReadFamilyEnoentRedirect({
                     workDir,
                     resolvedPath: resolvedOnly,
                     requestedPath: only,
-                    errCode: err?.code,
+                    errCode: pre.err?.code,
                     options,
                     rerun: (target, opts) => executeGlobTool({ ...args, path: target }, workDir, opts),
                 });
@@ -1407,14 +1437,19 @@ export async function executeGlobTool(args, workDir, options = {}) {
         for (const rel of rels) rgArgs.push('--glob', rel);
         const rgCwd = resolvedForSearchRoot(root);
         rgArgs.push('.');
-        try { statSync(rgCwd); }
-        catch (err) {
+        const cwdStat = statCached(rgCwd);
+        if (cwdStat.err) {
+            const err = cwdStat.err;
+            // One shared ENOENT scan cache for the redirect probe + not-found
+            // hint (both resolve the same missing rgCwd).
+            const groupEnoentCache = {};
             const redirected = await tryReadFamilyEnoentRedirect({
                 workDir,
                 resolvedPath: rgCwd,
                 requestedPath: root,
                 errCode: err?.code,
                 options,
+                cache: groupEnoentCache,
                 rerun: (target, opts) => executeGlobTool({ ...args, path: target }, workDir, opts),
             });
             if (redirected) {
@@ -1425,7 +1460,7 @@ export async function executeGlobTool(args, workDir, options = {}) {
                     redirected,
                 };
             }
-            const hint = buildNotFoundHint(workDir, rgCwd, 'Search', err?.code);
+            const hint = buildNotFoundHint(workDir, rgCwd, 'Search', err?.code, groupEnoentCache);
             return {
                 error: `path does not exist: ${normalizeOutputPath(rgCwd)} (${err?.code || 'ENOENT'})${finalizeReadFamilyEnoentTail(hint, root, err?.code)}`,
                 paths: [],
@@ -1508,7 +1543,7 @@ export async function executeGlobTool(args, workDir, options = {}) {
         if (totalBeforeOffset > 0 && offset >= totalBeforeOffset) {
             emptyDiag = `(no entries after offset=${offset}; total=${totalBeforeOffset}) pattern=${patternStr} path=${baseLabel}`;
         } else {
-            emptyDiag = `(no files found) pattern=${patternStr} path=${baseLabel}; ${basePathDiagnostic(baseEntries.map((e) => e.root), workDir)}`;
+            emptyDiag = `(no files found) pattern=${patternStr} path=${baseLabel}; ${basePathDiagnostic(baseEntries.map((e) => e.root), workDir, statCache)}`;
         }
     }
     const body = capped.length > 0

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

@@ -23,6 +23,7 @@ import {
 import {
   CODE_GRAPH_TTL_MS,
   CODE_GRAPH_MAX_FILES,
+  CODE_GRAPH_FAST_PATH_MAX_BYTES,
   CODE_GRAPH_WORKER_TIMEOUT_MS,
   SYMBOL_SCHEMA_VERSION,
 } from './constants.mjs';
@@ -34,7 +35,10 @@ import {
 import { _touchCodeGraphCache, _setCodeGraphCache } from './memory-cache.mjs';
 import {
   ensureDiskCodeGraphLoaded,
+  drainCodeGraphCacheStrict,
   getDiskCodeGraphEntry,
+  hasLegacyDiskCodeGraphCache,
+  probeDiskCodeGraphEntry,
   _setDiskCodeGraphEntry,
 } from './disk-cache.mjs';
 import {
@@ -53,6 +57,104 @@ import { _findDirProjectRoot } from './project-root.mjs';
 // after a failure can retry.
 const _inflightAsyncBuilds = new Map();
 
+export function _isCompatibleDiskCodeGraphEntry(entry, maxFiles = CODE_GRAPH_MAX_FILES) {
+  return Number.isFinite(entry?.maxFiles) && entry.maxFiles === maxFiles;
+}
+
+function _throwIfAborted(signal) {
+  if (signal?.aborted) throw new Error('aborted');
+}
+
+// Validate an already-loaded disk entry before paying Worker startup. The
+// manifest process is async; its child-spawn slot is held by the caller until
+// either this returns a hit or the Worker takes over the same slot on a miss.
+// Exported for the focused deterministic cache-validation test.
+export async function _validateDiskCodeGraphHit({
+  graphCwd,
+  diskEntry,
+  genAtStart,
+  now = Date.now(),
+  runManifest = _runGraphManifest,
+  computeSignature = _computeGraphSignature,
+  deserializeGraph = _deserializeGraph,
+  getGeneration = _getCodeGraphGen,
+  setMemoryCache = _setCodeGraphCache,
+  signal = null,
+}) {
+  if (!_isCompatibleDiskCodeGraphEntry(diskEntry)) return { incompatible: true };
+  const manifest = await runManifest(graphCwd, signal);
+  const signature = computeSignature(manifest);
+  if (diskEntry.signature !== signature) return { graph: null, manifest, signature };
+  const graph = deserializeGraph(graphCwd, diskEntry);
+  if (!graph) return { graph: null, manifest, signature };
+  if (getGeneration(graphCwd) !== genAtStart) return { invalidated: true };
+  setMemoryCache(graphCwd, { ts: now, signature, graph });
+  return { graph, manifest, signature };
+}
+
+// Owns a pre-acquired slot until a validated miss hands it to spawnWorker.
+// Keeping this seam dependency-injectable makes slot/abort behavior testable
+// without spawning native processes or Worker threads.
+export async function _runDiskCodeGraphFastPath({
+  graphCwd,
+  diskProbe,
+  genAtStart,
+  signal = null,
+  loadDiskEntry,
+  consumeDirty = () => {},
+  acquireSlot = acquireChildSpawnSlot,
+  validateDiskHit = _validateDiskCodeGraphHit,
+  spawnWorker,
+  maxFiles = CODE_GRAPH_MAX_FILES,
+}) {
+  if (!diskProbe?.isFastPathEligible || diskProbe.maxFiles !== maxFiles) {
+    return spawnWorker(null, null, null);
+  }
+  const diskEntry = loadDiskEntry();
+  if (!_isCompatibleDiskCodeGraphEntry(diskEntry, maxFiles)) {
+    return spawnWorker(null, null, null);
+  }
+  consumeDirty();
+  const release = await acquireSlot(signal || null);
+  let handedToWorker = false;
+  try {
+    _throwIfAborted(signal);
+    const hit = await validateDiskHit({ graphCwd, diskEntry, genAtStart, signal });
+    _throwIfAborted(signal);
+    if (hit?.invalidated) throw new Error('code-graph build invalidated during prewarm');
+    if (hit?.graph) return hit.graph;
+    _throwIfAborted(signal);
+    const workerPromise = spawnWorker(release, hit?.manifest || null, hit?.signature || null);
+    handedToWorker = true;
+    return workerPromise;
+  } finally {
+    if (!handedToWorker) release();
+  }
+}
+
+// A legacy single-file cache can be very large. Its migration is deliberately
+// performed by _buildCodeGraph in the Worker; probing it here would poison the
+// parent disk-cache loaded state after a synchronous JSON.parse.
+export function _prepareDiskCodeGraphFastPath({
+  graphCwd,
+  hasLegacyCache = hasLegacyDiskCodeGraphCache,
+  ensureDiskLoaded = ensureDiskCodeGraphLoaded,
+  probeDiskEntry = probeDiskCodeGraphEntry,
+  runFastPath,
+}) {
+  if (hasLegacyCache()) return runFastPath(null);
+  ensureDiskLoaded();
+  return runFastPath(probeDiskEntry(graphCwd, CODE_GRAPH_FAST_PATH_MAX_BYTES));
+}
+
+// Worker disk writes are debounced with an unref'd timer. Drain before sending
+// success so legacy migration persists every loaded cwd before this Worker can
+// exit; a drain failure is intentionally thrown to the worker's failure path.
+export function _postCodeGraphWorkerSuccess(graph, postMessage, drainCache = drainCodeGraphCacheStrict) {
+  drainCache();
+  postMessage({ ok: true, signature: graph.signature, graph });
+}
+
 export function prewarmCodeGraph(cwd) {
   if (!cwd) return;
   // Reuse the buildCodeGraphAsync single-flight path. Fire-and-forget, and
@@ -109,16 +211,54 @@ export async function buildCodeGraphAsync(cwd, signal = null, { bestEffort = fal
       (e) => { cleanup(); throw e; },
     );
   }
-  // Non-competing prewarm: once past the cache/single-flight fast paths a
-  // fresh build must spawn the worker (a child-spawn slot). Best-effort warmers
-  // skip that spawn when the gate has no spare capacity, returning null so the
-  // caller no-ops — and skipping BEFORE registering the in-flight entry so a
-  // concurrent REAL caller is never attached to (and thus never starved by) a
-  // skipped warm.
+  // Non-competing prewarm: the signature-validation manifest also needs a
+  // child-spawn slot, so warmers skip before either it or a Worker can queue.
   if (bestEffort && !childSpawnHasSpareCapacity()) return null;
   const _genAtStart = _getCodeGraphGen(graphCwd);
+  const promise = (async () => {
+    // Loading the compact disk manifest/one candidate entry is synchronous but
+    // bounded I/O. Do not run a manifest at all when no disk candidate exists:
+    // cold/dirty misses remain entirely on the existing Worker path.
+    return _prepareDiskCodeGraphFastPath({
+      graphCwd,
+      runFastPath: (diskProbe) => _runDiskCodeGraphFastPath({
+        graphCwd,
+        diskProbe,
+        genAtStart: _genAtStart,
+        signal,
+        loadDiskEntry: () => getDiskCodeGraphEntry(graphCwd),
+        consumeDirty: () => _consumeCodeGraphDirtyPaths(graphCwd),
+        spawnWorker: (preAcquiredRelease, manifest, signature) => _spawnCodeGraphWorker(
+          cwd,
+          graphCwd,
+          _genAtStart,
+          signal,
+          preAcquiredRelease,
+          manifest,
+          signature,
+        ),
+      }),
+    });
+  })();
+  _inflightAsyncBuilds.set(graphCwd, promise);
+  try {
+    return await promise;
+  } finally {
+    _inflightAsyncBuilds.delete(graphCwd);
+  }
+}
+
+function _spawnCodeGraphWorker(
+  cwd,
+  graphCwd,
+  genAtStart,
+  signal,
+  preAcquiredRelease = null,
+  manifest = null,
+  signature = null,
+) {
   let _worker = null;
-  const promise = new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     let timeout = null;
     let _onSignalAbort = null;
@@ -132,18 +272,23 @@ export async function buildCodeGraphAsync(cwd, signal = null, { bestEffort = fal
         _onSignalAbort = null;
       }
       if (_releaseSlot) { try { _releaseSlot(); } catch {} _releaseSlot = null; }
-      _inflightAsyncBuilds.delete(graphCwd);
       if (val instanceof Error) reject(val);
       else resolve(val);
     };
-    acquireChildSpawnSlot(signal || null).then((release) => {
+    (preAcquiredRelease ? Promise.resolve(preAcquiredRelease) : acquireChildSpawnSlot(signal || null)).then((release) => {
       _releaseSlot = release;
       if (settled) { release(); _releaseSlot = null; return; }
+      if (signal?.aborted) { settle(new Error('aborted')); return; }
       const workerUrl = new URL('../code-graph-prewarm-worker.mjs', import.meta.url);
-      _worker = new Worker(workerUrl, {
-        workerData: { cwd },
-        execArgv: [],
-      });
+      try {
+        _worker = new Worker(workerUrl, {
+          workerData: { cwd, manifest, signature },
+          execArgv: [],
+        });
+      } catch (e) {
+        settle(e instanceof Error ? e : new Error(String(e)));
+        return;
+      }
       const w = _worker;
       timeout = setTimeout(() => {
         try { _worker?.terminate(); } catch {}
@@ -160,7 +305,7 @@ export async function buildCodeGraphAsync(cwd, signal = null, { bestEffort = fal
       w.once('message', (msg) => {
         try {
           if (msg && msg.ok && msg.graph && typeof msg.signature === 'string') {
-            const genStillCurrent = _getCodeGraphGen(graphCwd) === _genAtStart;
+            const genStillCurrent = _getCodeGraphGen(graphCwd) === genAtStart;
             if (genStillCurrent) {
               _setCodeGraphCache(graphCwd, { ts: Date.now(), signature: msg.signature, graph: msg.graph });
               _setDiskCodeGraphEntry(graphCwd, msg.graph);
@@ -174,8 +319,6 @@ export async function buildCodeGraphAsync(cwd, signal = null, { bestEffort = fal
       w.once('error', (e) => settle(e instanceof Error ? e : new Error(String(e))));
     }, (e) => settle(e instanceof Error ? e : new Error(String(e))));
   });
-  _inflightAsyncBuilds.set(graphCwd, promise);
-  return promise;
 }
 
 /**
@@ -184,7 +327,7 @@ export async function buildCodeGraphAsync(cwd, signal = null, { bestEffort = fal
  * buildCodeGraphAsync (worker-thread isolated) or the code_graph / find_symbol
  * tools, never this synchronous form on the main event loop.
  */
-export async function _buildCodeGraph(cwd) {
+export async function _buildCodeGraph(cwd, { manifest: suppliedManifest = null, signature: suppliedSignature = null } = {}) {
   const now = Date.now();
   let _tp = performance.now();
   const _trace = (label) => { if (process.env.MIXDOG_GRAPH_TRACE) { const n = performance.now(); process.stderr.write(`[cg-trace] ${label}=${(n - _tp).toFixed(0)}ms\n`); _tp = n; } };
@@ -195,10 +338,14 @@ export async function _buildCodeGraph(cwd) {
   let previousGraph = cached?.graph || null;
   _consumeCodeGraphDirtyPaths(graphCwd);
 
-  // 1. Change-detect via Rust --manifest (fp/rel/size only, no parse).
-  const manifest = await _runGraphManifest(absRoot);
-  const signature = _computeGraphSignature(manifest);
-  _trace('manifest+sig');
+  // 1. Change-detect via Rust --manifest (fp/rel/size only, no parse). A
+  // main-thread disk-cache validation may hand its just-computed manifest to
+  // this Worker after a miss, avoiding a duplicate native process.
+  const manifest = Array.isArray(suppliedManifest) ? suppliedManifest : await _runGraphManifest(absRoot);
+  const signature = typeof suppliedSignature === 'string'
+    ? suppliedSignature
+    : _computeGraphSignature(manifest);
+  if (!Array.isArray(suppliedManifest)) _trace('manifest+sig');
   const truncated = manifest.length > CODE_GRAPH_MAX_FILES;
   const indexed = truncated ? manifest.slice(0, CODE_GRAPH_MAX_FILES) : manifest;
 
@@ -211,7 +358,7 @@ export async function _buildCodeGraph(cwd) {
   // 3. Disk cache hit.
   ensureDiskCodeGraphLoaded(now);
   const diskEntry = getDiskCodeGraphEntry(graphCwd);
-  if (diskEntry?.signature === signature) {
+  if (_isCompatibleDiskCodeGraphEntry(diskEntry) && diskEntry.signature === signature) {
     const graph = _deserializeGraph(graphCwd, diskEntry);
     if (graph) {
       if (_getCodeGraphGen(graphCwd) === _genAtStart) {
@@ -220,7 +367,9 @@ export async function _buildCodeGraph(cwd) {
       return graph;
     }
   }
-  if (!previousGraph && diskEntry) previousGraph = _deserializeGraph(graphCwd, diskEntry);
+  if (!previousGraph && _isCompatibleDiskCodeGraphEntry(diskEntry)) {
+    previousGraph = _deserializeGraph(graphCwd, diskEntry);
+  }
   if (previousGraph && previousGraph.schemaVersion !== SYMBOL_SCHEMA_VERSION) {
     previousGraph = null;
   }

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

@@ -4,6 +4,9 @@
 
 export const CODE_GRAPH_TTL_MS = 30_000;
 export const CODE_GRAPH_MAX_FILES = 10_000;
+// A cold-process disk hit may deserialize only this much JSON on the main
+// thread. Larger entries still validate/rebuild inside the Worker.
+export const CODE_GRAPH_FAST_PATH_MAX_BYTES = 8 * 1024 * 1024;
 export const CODE_GRAPH_WORKER_TIMEOUT_MS = 120_000;
 // Timeout for the native mixdog-graph binary child process (spawned per graph build).
 export const CODE_GRAPH_BINARY_TIMEOUT_MS = Math.max(1000, Number(process.env.MIXDOG_CODE_GRAPH_BINARY_TIMEOUT_MS) || 20000);