mixdog 0.9.96 → 0.9.97

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

@@ -1,4 +1,4 @@
-import { readFileSync } from 'fs';
+import { readFile } from 'fs/promises';
 import { executeSingleReadTool } from './read-single-tool.mjs';
 import { imageMimeForPath, readImageAsContent } from './read-image.mjs';
 import { readEntryCoalescedDiskWindow } from './read-batch.mjs';
@@ -6,6 +6,8 @@ import { readPathStringGuardError } from './read-open.mjs';
 import { parseReadLineNumberArg } from './read-args.mjs';
 import { assertPathsReachable } from './fs-reachability.mjs';
 import { coerceReadFamilyPathArg } from './path-utils.mjs';
+import { readIoAdmission } from '../../../../shared/tool-workload-gates.mjs';
+import { currentToolExecutionOwner } from '../../../../shared/tool-execution-owner.mjs';
 
 function hasLineCoordinate(path) {
     return typeof path === 'string' && /(?:#L\d+|:\d+(?:-\d+)?(?::|$))/i.test(path);
@@ -50,15 +52,14 @@ function _guardedReadError(p, helpers) {
 }
 
 // Reachability preflight for EVERY read shape (scalar / array / reads[]). MUST
-// run before any sync FS — including path normalization and the image
-// stat/read. A dead mount would otherwise freeze the event loop, defeating even
-// the 630s dispatch ceiling.
+// run before any filesystem access. Besides bounding a dead mount, its Stats
+// objects seed the real read so the common path does not immediately re-stat.
 async function _readReachPreflight(rawPath, workDir, helpers) {
     const {
         normalizeInputPath, resolveAgainstCwd,
     } = helpers;
     // A guarded path (UNC/SMB, Windows device, ADS, /dev/* block) must be
-    // REJECTED here, not skipped: skipping would let the later sync guard/open
+    // REJECTED here, not skipped: skipping would let the later guard/open
     // path touch it and trigger NTLM/raw-device access or hang. Reject up front
     // with the same message the inline guards emit.
     // normalizeInputPath FIRST (FS-pure) so we stat the same path the real read
@@ -71,7 +72,7 @@ async function _readReachPreflight(rawPath, workDir, helpers) {
         const stripped = _stripLineCoordForReach(normalizeInputPath(raw));
         const full = resolveAgainstCwd(stripped, workDir);
         const guardMsg = _guardedReadError(stripped, helpers) || _guardedReadError(full, helpers);
-        if (guardMsg) return guardMsg;
+        if (guardMsg) return { error: guardMsg, statsByPath: null };
         // Dedup by resolved path so a batch repeating the same file (or the
         // same union window) issues one stat probe, not one per entry —
         // bounding the preflight's FS work to the distinct target set.
@@ -79,9 +80,17 @@ async function _readReachPreflight(rawPath, workDir, helpers) {
         seenFull.add(full);
         candidates.push(full);
     }
-    if (candidates.length === 0) return null;
-    try { await assertPathsReachable(candidates); return null; }
-    catch (e) { return `Error: ${e?.message || e}`; }
+    if (candidates.length === 0) return { error: null, statsByPath: new Map() };
+    try {
+        const stats = await assertPathsReachable(candidates);
+        const statsByPath = new Map();
+        for (let i = 0; i < candidates.length; i++) {
+            if (stats[i]) statsByPath.set(candidates[i], stats[i]);
+        }
+        return { error: null, statsByPath };
+    } catch (e) {
+        return { error: `Error: ${e?.message || e}`, statsByPath: null };
+    }
 }
 
 export async function executeReadTool(args, workDir, readStateScope, executeChildBuiltinTool, options = {}, helpers = {}) {
@@ -118,8 +127,8 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         }
     }
     args.path = coerceReadFamilyPathArg(args.path, workDir);
-    // Reachability preflight up front (all shapes) — before readPathStringGuardError /
-    // image stat, all of which can touch sync FS.
+    // Reachability preflight up front (all shapes) — before
+    // readPathStringGuardError / image stat.
     // options._skipReachPreflight: set only by the batch dispatcher on its
     // child reads (below). The parent batch call already ran this exact
     // preflight over EVERY candidate path in the array (_collectReachCandidates
@@ -128,8 +137,9 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
     // child (readPathStringGuardError / image fast-path) — only the async
     // reachability stat is skipped, never the security guards.
     if (options?._skipReachPreflight !== true) {
-        const _reErr = await _readReachPreflight(args.path, workDir, helpers);
-        if (_reErr) return _reErr;
+        const _preflight = await _readReachPreflight(args.path, workDir, helpers);
+        if (_preflight.error) return _preflight.error;
+        options = { ...options, _preflightStats: _preflight.statsByPath };
     }
     // Image files (png/jpg/jpeg/gif/webp): return an MCP image block so the
     // model can actually SEE the image. native Read does this, but mixdog's
@@ -140,7 +150,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
     if (options?.mediaTextOnly !== true && typeof args.path === 'string' && imageMimeForPath(args.path)) {
         const _imgNorm = normalizeInputPath(args.path);
         // W1 H: device-file / UNC / Windows-device / ADS guards must run
-        // BEFORE the image fast-path so statSync/readFileSync of a
+        // BEFORE the image fast-path so stat/readFile of a
         // UNC/device path can't bypass the checks the normal read path
         // enforces (NTLM hash leak, raw-device access, ADS).
         if (typeof isUncPath === 'function' && isUncPath(_imgNorm))
@@ -158,7 +168,11 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             return `Error: cannot read Windows device path (reserved name or raw-device namespace): ${normalizeOutputPath(_imgFull)}`;
         if (typeof hasUnsafeWin32Component === 'function' && hasUnsafeWin32Component(_imgFull))
             return `Error: cannot read Windows path with trailing dot/space or NTFS ADS suffix (bypasses device guard): ${normalizeOutputPath(_imgFull)}`;
-        const _imgResult = await readImageAsContent(_imgFull, normalizeOutputPath(_imgNorm));
+        const _imgResult = await readImageAsContent(
+            _imgFull,
+            normalizeOutputPath(_imgNorm),
+            options?._preflightStats?.get?.(_imgFull) || null,
+        );
         if (_imgResult) return _imgResult;
     }
     // Unified-read dispatch (v0.6.283+):
@@ -399,7 +413,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
                 let rangeHashes = rangeHashesByPath.get(fullPath) || [];
                 if (rangeHashes.length === 0 && mergedRanges.length > 0) {
                     try {
-                        const rawLines = readFileSync(fullPath, 'utf-8').split('\n');
+                        const rawLines = (await readFile(fullPath, 'utf-8')).split('\n');
                         rangeHashes = mergedRanges.map((range) => {
                             const startIdx = Math.max(0, range.startLine - 1);
                             const endIdx = Math.min(rawLines.length, range.endLine);
@@ -608,11 +622,16 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
     // Mode routing. A window already dropped any conflicting head/tail/summary
     // glance above (so the window is served by executeSingleReadTool); what
     // remains here is a mode-only read, or count/hex which are not text windows.
-    if (args.mode === 'head') return executeChildBuiltinTool('head', { path: args.path, n: args.n }, workDir);
-    if (args.mode === 'tail') return executeChildBuiltinTool('tail', { path: args.path, n: args.n }, workDir);
-    if (args.mode === 'count') return executeChildBuiltinTool('wc', { path: args.path }, workDir);
-    if (args.mode === 'summary') return executeChildBuiltinTool('summary', { path: args.path, n: args.n, limit: args.limit }, workDir);
-    if (args.mode === 'hex') return executeChildBuiltinTool('hex', { path: args.path, n: args.n, offset: args.offset }, workDir);
-    return executeSingleReadTool(args, workDir, readStateScope, options, helpers);
+    const runReadIo = (task) => readIoAdmission.run(
+        options?.callerSessionId || options?.sessionId || currentToolExecutionOwner(),
+        task,
+        { signal: options?.signal || options?.abortSignal || null },
+    );
+    if (args.mode === 'head') return runReadIo(() => executeChildBuiltinTool('head', { path: args.path, n: args.n }, workDir));
+    if (args.mode === 'tail') return runReadIo(() => executeChildBuiltinTool('tail', { path: args.path, n: args.n }, workDir));
+    if (args.mode === 'count') return runReadIo(() => executeChildBuiltinTool('wc', { path: args.path }, workDir));
+    if (args.mode === 'summary') return runReadIo(() => executeChildBuiltinTool('summary', { path: args.path, n: args.n, limit: args.limit }, workDir));
+    if (args.mode === 'hex') return runReadIo(() => executeChildBuiltinTool('hex', { path: args.path, n: args.n, offset: args.offset }, workDir));
+    return runReadIo(() => executeSingleReadTool(args, workDir, readStateScope, options, helpers));
 
 }

package/src/runtime/agent/orchestrator/tools/builtin/rg-runner.mjs

@@ -423,7 +423,9 @@ function spawnRg(argsList, execOptions) {
     // spawn below, so queue-wait time is excluded from the 20s deadline. No
     // node guardian is started: rg owns its full SIGTERM→grace→force-kill +
     // force-settle teardown, so the 1:1 guardian process was pure overhead.
-    return acquireChildSpawnSlot(gateSignal, 'search').then((releaseSlot) => new Promise((resolve, reject) => {
+    return acquireChildSpawnSlot(gateSignal, 'search', {
+        ownerKey: execOptions?.ownerKey || execOptions?.callerSessionId || execOptions?.sessionId,
+    }).then((releaseSlot) => new Promise((resolve, reject) => {
         // Probe after acquisition: this spawn counts toward inflight. The
         // answer is best-effort and only selects the per-process rg cap.
         const proc = spawn(rgExecutable(), _withRgThreads(argsList, activeSearchSpawnCount()), {
@@ -605,7 +607,9 @@ function spawnRgWindowedLines(argsList, execOptions, opts = {}) {
     // Same gate + thread-cap + no-guardian treatment as spawnRg; queue-wait is
     // excluded from the rg timeout (armed after spawn). releaseSlot is fired
     // once via .finally on every settle path.
-    return acquireChildSpawnSlot(gateSignal, 'search').then((releaseSlot) => new Promise((resolve, reject) => {
+    return acquireChildSpawnSlot(gateSignal, 'search', {
+        ownerKey: execOptions?.ownerKey || execOptions?.callerSessionId || execOptions?.sessionId,
+    }).then((releaseSlot) => new Promise((resolve, reject) => {
         // As above, probe only after this spawn has acquired its gate slot.
         const proc = spawn(rgExecutable(), _withRgThreads(argsList, activeSearchSpawnCount()), {
             cwd: execOptions?.cwd,

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

@@ -4,7 +4,7 @@
 // code-graph.mjs.
 import { resolve as pathResolve, isAbsolute, relative as pathRelative, basename as pathBasename } from 'node:path';
 import { homedir as osHomedir } from 'node:os';
-import { readFileSync, existsSync, statSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { normalizeInputPath, toDisplayPath } from '../builtin.mjs';
 import { findFileByBasename } from '../builtin/path-diagnostics.mjs';
 import { markScopedCacheIncomplete } from '../../session/cache/scoped-cache-outcome.mjs';
@@ -40,7 +40,9 @@ import {
   _CALLEES_BRACE_LANGS,
   _formatRelated,
   _formatImpact,
+  _impactSourceNodes,
   _resolveReferenceLanguageNode,
+  _prewarmSourceTextNodes,
   _prewarmReferenceSourceText,
   _cheapReferenceSearch,
   _formatCallerReferences,
@@ -375,13 +377,19 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
     const depsAll = [...(graph.reverse.get(depRel) || [])].sort();
     if (!depsAll.length) return '(no dependents)';
     const deps = depsAll.slice(0, GRAPH_LIST_CAP);
+    await _prewarmSourceTextNodes(
+      graph,
+      deps.map((dep) => graph.nodes.get(dep)).filter(Boolean),
+      { signal },
+    );
     const basename = depRel.split('/').pop();
     const stem = basename.replace(/\.[^/.]+$/, '');
     const enriched = deps.map((dep) => {
       const depNode = graph.nodes.get(dep);
       if (!depNode) return dep;
-      let text;
-      try { text = readFileSync(depNode.abs, 'utf8'); } catch { return dep; }
+      const cached = graph._sourceTextCache?.get(depNode.rel);
+      if (!cached || cached.fingerprint !== (depNode.fingerprint || '')) return dep;
+      const text = cached.text;
       const linesArr = text.split(/\r?\n/);
       for (let i = 0; i < linesArr.length; i++) {
         const ln = linesArr[i];
@@ -407,6 +415,8 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
   if (mode === 'impact') {
     if (!node) return _appendSameBasenameHint(`Error: code_graph impact: file not found in graph: ${normFile || '(missing file)'}`, normFile, graph);
     const targetSymbol = String(args?.symbol || '').trim();
+    await _prewarmSourceTextNodes(graph, [node], { signal });
+    await _prewarmSourceTextNodes(graph, _impactSourceNodes(node, graph, targetSymbol), { signal });
     return _formatImpact(node, graph, cwd, targetSymbol);
   }
 
@@ -425,6 +435,7 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
     if (!_CALLEES_BRACE_LANGS.has(declHit.lang)) {
       return `(callees unsupported for ${declHit.lang})`;
     }
+    await _prewarmSourceTextNodes(graph, [graph.nodes.get(declHit.rel)].filter(Boolean), { signal });
     const rows = _extractCallees(graph, declHit, cwd, {
       cap: 200,
       callerSymbol: symbol,
@@ -438,9 +449,11 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
 
   if (mode === 'symbols') {
     if (!node) return _appendSameBasenameHint(`Error: code_graph symbols: file not found in graph: ${normFile || '(missing file)'}`, normFile, graph);
-    let text = '';
-    try { text = readFileSync(node.abs, 'utf8'); } catch { return '(no symbols)'; }
-    return _extractSymbolsCheap(text, node.lang);
+    await _prewarmSourceTextNodes(graph, [node], { signal });
+    const cached = graph._sourceTextCache?.get(node.rel);
+    return cached && cached.fingerprint === (node.fingerprint || '')
+      ? _extractSymbolsCheap(cached.text, node.lang)
+      : '(no symbols)';
   }
 
   if (mode === 'find_symbol') {
@@ -449,6 +462,15 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
     const language = String(args?.language || '').trim() || null;
     const limit = Math.max(1, Math.min(50, Number(args?.limit || 20)));
     if (rel && !node) return _appendSameBasenameHint(`Error: code_graph find_symbol: file not found in graph: ${normFile || '(missing file)'}`, normFile, graph);
+    if (args?.body !== false) {
+      const hits = _findSymbolHits(graph, symbol, { language });
+      const primary = hits.find((hit) => hit.declarationLike) || hits[0];
+      await _prewarmSourceTextNodes(
+        graph,
+        [primary?.rel ? graph.nodes.get(primary.rel) : null].filter(Boolean),
+        { signal },
+      );
+    }
     return _findSymbolAcrossGraph(graph, symbol, cwd, { language, limit, fileRel: rel, body: args?.body !== false });
   }
 
@@ -461,6 +483,14 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
     const keyword = String(args?.symbol || '').trim();
     const keywords = symbolsList.length ? symbolsList : (keyword ? [keyword] : []);
     if (!keywords.length) throw new Error('code_graph symbol_search: "symbol" (or "symbols[]") is required.');
+    // Native graph symbols answer without source text. Nodes lacking native
+    // symbols fall back to cheap text extraction, so warm exactly that subset
+    // asynchronously before the synchronous formatter scans it.
+    await _prewarmSourceTextNodes(
+      graph,
+      [...graph.nodes.values()].filter((candidate) => !Array.isArray(candidate?.symbols) || candidate.symbols.length === 0),
+      { signal },
+    );
     if (keywords.length === 1) {
       return _searchSymbolsByKeyword(graph, keywords[0], cwd, { language, limit });
     }
@@ -487,6 +517,7 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
       }
     }
     const narrowedByCaller = Boolean(rel || scopeRelPrefix || explicitLanguage);
+    if (node) await _prewarmSourceTextNodes(graph, [node], { signal });
     const resolved = _resolveReferenceLanguageNode(graph, symbol, rel, cwd, explicitLanguage);
     if (rel && resolved.kind === 'file-not-found') {
       return _appendSameBasenameHint(`Error: code_graph references: file not found in graph: ${normFile || '(missing file)'}`, normFile, graph);
@@ -501,7 +532,7 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
     const userLimit = Number.isFinite(rawLimit) && rawLimit > 0
       ? Math.min(500, Math.floor(rawLimit))
       : null;
-    const _refNodes = await _prewarmReferenceSourceText(graph, symbol, lang);
+    const _refNodes = await _prewarmReferenceSourceText(graph, symbol, lang, { signal });
     const refResult = _cheapReferenceSearch(graph, symbol, cwd, { language: lang, limit: userLimit, fileRel: rel, scopeRelPrefix, nodes: _refNodes });
     return narrowedByCaller ? refResult : _augmentNoHitDiagnostic(refResult, '(no references)', graph, cwd, symbol);
   }
@@ -517,6 +548,7 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
       }
     }
     const narrowedByCaller = Boolean(rel || scopeRelPrefix || explicitLanguage);
+    if (node) await _prewarmSourceTextNodes(graph, [node], { signal });
     const resolved = _resolveReferenceLanguageNode(graph, symbol, rel, cwd, explicitLanguage);
     if (rel && resolved.kind === 'file-not-found') {
       return _appendSameBasenameHint(`Error: code_graph callers: file not found in graph: ${normFile || '(missing file)'}`, normFile, graph);
@@ -531,7 +563,7 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
     const userLimit = Number.isFinite(rawLimit) && rawLimit > 0
       ? Math.min(500, Math.floor(rawLimit))
       : null;
-    const _callerNodes = await _prewarmReferenceSourceText(graph, symbol, lang);
+    const _callerNodes = await _prewarmReferenceSourceText(graph, symbol, lang, { signal });
     const depth = Math.max(1, Math.min(5, Math.floor(Number(args?.depth) || 1)));
     if (depth > 1) {
       return _formatTransitiveCallers(graph, symbol, cwd, { language: lang, depth, page: args?.page });
@@ -576,12 +608,23 @@ async function findSymbolTool(args, cwd, signal = null, options = {}) {
   if (!symbol) {
     if (fileRel) {
       const node = graph.nodes.get(fileRel);
-      let text = '';
-      try { text = readFileSync(node.abs, 'utf8'); } catch { return '(no symbols)'; }
-      return _extractSymbolsCheap(text, node.lang);
+      await _prewarmSourceTextNodes(graph, [node], { signal });
+      const cached = graph._sourceTextCache?.get(node.rel);
+      return cached && cached.fingerprint === (node.fingerprint || '')
+        ? _extractSymbolsCheap(cached.text, node.lang)
+        : '(no symbols)';
     }
     throw new Error('find_symbol: provide "symbol" (to locate) or "file" (to list its symbols).');
   }
+  if (args?.body !== false) {
+    const hits = _findSymbolHits(graph, symbol, { language });
+    const primary = hits.find((hit) => hit.declarationLike) || hits[0];
+    await _prewarmSourceTextNodes(
+      graph,
+      [primary?.rel ? graph.nodes.get(primary.rel) : null].filter(Boolean),
+      { signal },
+    );
+  }
   return _findSymbolAcrossGraph(graph, symbol, cwd, { language, limit, fileRel, body: args?.body !== false });
 }
 
@@ -632,6 +675,7 @@ export async function resolveSymbolReadSpan(cwd, { symbol, path = null, language
   }
   if (!Number.isFinite(endLine) || endLine < startLine) {
     const node = graph.nodes.get(primary.rel);
+    await _prewarmSourceTextNodes(graph, [node].filter(Boolean));
     const srcText = node ? _getSourceTextForNode(graph, node) : null;
     const inferred = srcText ? _inferSpanEndByIndent(srcText.split('\n'), startLine) : null;
     if (inferred) {

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

@@ -2,7 +2,6 @@
 // Symbol search / callers / callees / references / impact query layer over a
 // built graph. Pure over {graph,cwd,args}; owns no cache state. Extracted
 // verbatim from code-graph.mjs.
-import { readFileSync } from 'node:fs';
 import { _isJsLike } from './lang-predicates.mjs';
 import { _maskNonCodeText } from './text-mask.mjs';
 import {
@@ -61,6 +60,18 @@ function _collectImpactSymbols(node, graph) {
   return [...names];
 }
 
+export function _impactSourceNodes(node, graph, targetSymbol = '') {
+  const symbols = targetSymbol ? [targetSymbol] : _collectImpactSymbols(node, graph).slice(0, 8);
+  const out = [];
+  const seen = new Set();
+  for (const candidate of [node, ...symbols.flatMap((symbol) => _lookupCandidateNodes(graph, symbol, node?.lang || null))]) {
+    if (!candidate?.rel || seen.has(candidate.rel)) continue;
+    seen.add(candidate.rel);
+    out.push(candidate);
+  }
+  return out;
+}
+
 function _buildImpactSummary(node, graph, cwd, targetSymbol = '') {
   const imports = node.resolvedImports.map((p) => _graphRel(p, cwd));
   const dependents = [...(graph.reverse.get(node.rel) || [])].sort();

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

@@ -1,7 +1,8 @@
 // Symbol search / callers / callees / references / impact query layer over a
 // built graph. Pure over {graph,cwd,args}; owns no cache state. Extracted
 // verbatim from code-graph.mjs.
-import { readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { codeGraphSourceIoAdmission } from '../../../../shared/tool-workload-gates.mjs';
 import { _isJsLike } from './lang-predicates.mjs';
 import { _maskNonCodeText } from './text-mask.mjs';
 import {
@@ -30,7 +31,7 @@ import {
   _keywordMatchesSymbolName,
 } from './keyword-match.mjs';
 
-export { _formatRelated, _formatImpact, _findSymbolAcrossGraph, _resolveReferenceLanguageNode, _formatCallerReferences, _formatTransitiveCallers } from './search-references.mjs';
+export { _formatRelated, _formatImpact, _impactSourceNodes, _findSymbolAcrossGraph, _resolveReferenceLanguageNode, _formatCallerReferences, _formatTransitiveCallers } from './search-references.mjs';
 export function _extractCallees(graph, declHit, _cwd, { cap = 200, callerSymbol = null, language = null } = {}) {
   if (!declHit || !_CALLEES_BRACE_LANGS.has(declHit.lang)) return [];
   const declNode = graph.nodes.get(declHit.rel);
@@ -253,28 +254,64 @@ export function _formatCalleeRow(row) {
   const enclosing = row.enclosing ? `(in ${row.enclosing})` : '(in ?)';
   return `${row.name}\t${callsite}\t${decl}\t${enclosing}`;
 }
-export async function _prewarmReferenceSourceText(graph, symbol, language) {
-  const candidateNodes = _lookupCandidateNodes(graph, symbol, language);
-  // Return the resolved candidate set so the immediately-following
-  // _cheapReferenceSearch (references/callers dispatch) can reuse it instead
-  // of recomputing _lookupCandidateNodes for the same (symbol, language) —
-  // which on a token-index miss is a full-graph scan run twice per symbol.
-  if (!candidateNodes.length) return candidateNodes;
+const CODE_GRAPH_SOURCE_READ_CONCURRENCY = Math.max(
+  1,
+  Math.min(32, Math.floor(Number(process.env.MIXDOG_CODE_GRAPH_SOURCE_READ_CONCURRENCY) || 8)),
+);
+
+export async function _prewarmSourceTextNodes(graph, nodes, {
+  concurrency = CODE_GRAPH_SOURCE_READ_CONCURRENCY,
+  readFileImpl = readFile,
+  signal = null,
+  ownerKey = null,
+} = {}) {
+  const sourceNodes = [];
+  const seen = new Set();
+  for (const node of Array.isArray(nodes) ? nodes : []) {
+    if (!node?.rel || !node?.abs || seen.has(node.rel)) continue;
+    seen.add(node.rel);
+    sourceNodes.push(node);
+  }
   const uncached = [];
-  for (const node of candidateNodes) {
+  for (const node of sourceNodes) {
     const cached = graph._sourceTextCache?.get(node.rel);
     if (!cached || cached.fingerprint !== (node.fingerprint || '')) {
       uncached.push(node);
     }
   }
-  if (uncached.length === 0) return candidateNodes;
-  const { readFile } = await import('fs/promises');
-  await Promise.all(uncached.map(async (node) => {
-    try {
-      const text = await readFile(node.abs, 'utf8');
-      graph._sourceTextCache?.set(node.rel, { fingerprint: node.fingerprint || '', text });
-    } catch { /* skip unreadable file */ }
-  }));
+  let next = 0;
+  const worker = async () => {
+    while (!signal?.aborted) {
+      const index = next++;
+      if (index >= uncached.length) return;
+      const node = uncached[index];
+      try {
+        const text = await codeGraphSourceIoAdmission.run(
+          ownerKey,
+          () => readFileImpl(node.abs, 'utf8'),
+          { signal },
+        );
+        graph._sourceTextCache?.set(node.rel, { fingerprint: node.fingerprint || '', text });
+      } catch { /* skip unreadable/aborted file */ }
+    }
+  };
+  const workerCount = Math.min(
+    Math.max(1, Math.floor(Number(concurrency) || CODE_GRAPH_SOURCE_READ_CONCURRENCY)),
+    Math.max(1, uncached.length),
+  );
+  if (uncached.length > 0) {
+    await Promise.all(Array.from({ length: workerCount }, worker));
+  }
+  return sourceNodes;
+}
+
+export async function _prewarmReferenceSourceText(graph, symbol, language, options = {}) {
+  const candidateNodes = _lookupCandidateNodes(graph, symbol, language);
+  // Return the resolved candidate set so the immediately-following
+  // _cheapReferenceSearch (references/callers dispatch) can reuse it instead
+  // of recomputing _lookupCandidateNodes for the same (symbol, language) —
+  // which on a token-index miss is a full-graph scan run twice per symbol.
+  await _prewarmSourceTextNodes(graph, candidateNodes, options);
   return candidateNodes;
 }
 

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

@@ -14,6 +14,7 @@ export const CODE_GRAPH_TOOL_DEFS = [
         limit: { type: 'number', minimum: 1, description: 'Max results.' },
         depth: { type: 'number', minimum: 1, maximum: 5, description: 'Caller depth.' },
         page: { type: 'number', minimum: 1, description: 'Caller page.' },
+        cwd: { type: 'string', description: 'Explicit root.' },
       },
       required: ['mode'],
       additionalProperties: false,

package/src/runtime/agent/orchestrator/tools/env-scrub.mjs

@@ -120,8 +120,7 @@ export function scrubRuntimeRootVars(env) {
     // Daemon IDENTITY leak: user-facing children must not inherit host/worker
     // ownership or the daemon's terminal-lead PID. Internal daemon/worker
     // spawns set every identity value explicitly after this boundary.
-    delete env.MIXDOG_ENGINE_DAEMON_HOST;
-    delete env.MIXDOG_CHANNEL_DAEMON;
+    delete env.MIXDOG_DAEMON_HOST;
     delete env.MIXDOG_WORKER_MODE;
     delete env.MIXDOG_DAEMON_SPAWNED_FOR;
     delete env.MIXDOG_SUPERVISOR_PID;

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

@@ -43,11 +43,11 @@ export function _resolvePwshPoolTarget({
         if (Number.isFinite(n) && n >= 0) return Math.min(8, n);
     }
     if (platform !== 'win32') return 0;
-    // Tools now execute in the machine-global backend daemon. Keep client/test
+    // 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_ENGINE_DAEMON_HOST !== '1' && env?.MIXDOG_CHANNEL_DAEMON !== '1') return 0;
+    if (env?.MIXDOG_DAEMON_HOST !== '1') return 0;
     let cores = Number(parallelism);
     if (!Number.isFinite(cores) || cores < 1) {
         try { cores = availableParallelism(); } catch { cores = 1; }

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.