mixdog 0.9.96 → 0.9.99

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

@@ -1,4 +1,3 @@
-import { lstatSync, realpathSync, readdirSync, statSync } from 'fs';
 import * as fsPromises from 'fs/promises';
 import { readFile } from 'fs/promises';
 import { extname } from 'path';
@@ -7,7 +6,11 @@ import { buildNotFoundHint, finalizeReadFamilyEnoentTail, tryReadFamilyEnoentRed
 import { getReadSnapshot } from './read-snapshot-runtime.mjs';
 import { recordReadPathRedirect } from './snapshot-store.mjs';
 import { snapshotCoversFullFile, statMatchesSnapshot } from './snapshot-helpers.mjs';
-import { formatBinaryReadPreview } from './binary-file.mjs';
+import {
+    formatBinaryReadPreviewFromBuffer,
+    inspectBinaryFile,
+    isBinaryBuffer,
+} from './binary-file.mjs';
 
 function snapshotBodyWasReturnedByRead(snapshot) {
     return String(snapshot?.source || '').startsWith('read');
@@ -27,22 +30,27 @@ function withSymbolReadNote(text, args) {
 // decoding. utf8-with-BOM (EF BB BF) keeps the utf-8 decoder; its leading
 // U+FEFF is stripped for display downstream, so bomLen is reported but not
 // applied for utf8.
+function detectReadEncodingFromBuffer(head) {
+    const n = head?.length || 0;
+    if (n >= 2 && head[0] === 0xff && head[1] === 0xfe) {
+        return { encoding: 'utf16le', bomLen: 2 };
+    }
+    if (n >= 2 && head[0] === 0xfe && head[1] === 0xff) {
+        return { encoding: 'utf16be', bomLen: 2 };
+    }
+    if (n >= 3 && head[0] === 0xef && head[1] === 0xbb && head[2] === 0xbf) {
+        return { encoding: 'utf8', bomLen: 3 };
+    }
+    return { encoding: 'utf8', bomLen: 0 };
+}
+
 async function detectReadEncoding(fullPath) {
     let fh;
     try {
         fh = await fsPromises.open(fullPath, 'r');
         const head = Buffer.alloc(3);
         const { bytesRead: n } = await fh.read(head, 0, 3, 0);
-        if (n >= 2 && head[0] === 0xff && head[1] === 0xfe) {
-            return { encoding: 'utf16le', bomLen: 2 };
-        }
-        if (n >= 2 && head[0] === 0xfe && head[1] === 0xff) {
-            return { encoding: 'utf16be', bomLen: 2 };
-        }
-        if (n >= 3 && head[0] === 0xef && head[1] === 0xbb && head[2] === 0xbf) {
-            return { encoding: 'utf8', bomLen: 3 };
-        }
-        return { encoding: 'utf8', bomLen: 0 };
+        return detectReadEncodingFromBuffer(head.subarray(0, n));
     } catch {
         return { encoding: 'utf8', bomLen: 0 };
     } finally {
@@ -164,7 +172,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
     let st;
     let _statErr;
     try {
-        st = statSync(fullPath);
+        st = options?._preflightStats?.get?.(fullPath) || await fsPromises.stat(fullPath);
     } catch (err) {
         // Fall through to the existing similar-file recovery path below.
         st = null;
@@ -174,7 +182,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         if (st.isDirectory()) {
             let entries = [];
             try {
-                entries = readdirSync(fullPath, { withFileTypes: true })
+                entries = (await fsPromises.readdir(fullPath, { withFileTypes: true }))
                     .slice(0, 20)
                     .map((entry) => `${entry.name}${entry.isDirectory() ? '/' : ''}`);
             } catch { /* best-effort preview */ }
@@ -191,14 +199,14 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
             return `Error: cannot read special file (FIFO / character / block device / socket): ${normalizeOutputPath(filePath)}`;
         // R1+R2: realpath the resolved path so a symlink → /dev/zero (or any
         // other blocked device, UNC, or Windows reserved name) is caught on
-        // the REAL target, not the symlink name. lstatSync detects whether
-        // the entry IS a symlink first so realpathSync is only called when
+        // the REAL target, not the symlink name. lstat detects whether
+        // the entry IS a symlink first so realpath is only called when
         // it would actually differ — saves a syscall on the common case.
         try {
-            const _lst = lstatSync(fullPath);
+            const _lst = await fsPromises.lstat(fullPath);
             if (_lst && typeof _lst.isSymbolicLink === 'function' && _lst.isSymbolicLink()) {
                 let _realTarget = null;
-                try { _realTarget = realpathSync(fullPath); } catch { _realTarget = null; }
+                try { _realTarget = await fsPromises.realpath(fullPath); } catch { _realTarget = null; }
                 if (_realTarget && _realTarget !== fullPath) {
                     if (isBlockedDevicePath(_realTarget))
                         return `Error: cannot read device file via symlink (would block or produce infinite output): ${normalizeOutputPath(filePath)} → ${normalizeOutputPath(_realTarget)}`;
@@ -211,7 +219,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
                     // the target stat could differ from the link stat in
                     // pathological cases (replaced under us).
                     try {
-                        const _rst = statSync(_realTarget);
+                        const _rst = await fsPromises.stat(_realTarget);
                         if (typeof isSpecialFileStat === 'function' && isSpecialFileStat(_rst))
                             return `Error: cannot read special file via symlink (FIFO / character / block device / socket): ${normalizeOutputPath(filePath)} → ${normalizeOutputPath(_realTarget)}`;
                     } catch { /* if the target is gone, let the normal path surface ENOENT */ }
@@ -430,11 +438,42 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
     // large UTF-16LE+BOM file is recognized as text up front and routed to
     // the bounded in-memory utf16le path below, never mis-decoded as utf-8
     // or rejected by the utf-8 streaming/binary branch (Bug 1).
-    const _readEnc = await detectReadEncoding(fullPath);
+    const _preferRangeStream = hasRangeArgs && !wantFull
+        && (options?.forceReadRangeStream === true || st.size > READ_STREAM_RANGE_MIN_BYTES);
+    const _preferSmartStream = !hasRangeArgs && !wantFull
+        && st.size >= READ_SMART_STREAM_MIN_BYTES;
+    const _preferBufferedRead = st.size <= READ_MAX_SIZE_BYTES
+        && !_preferRangeStream
+        && !_preferSmartStream;
+    let _prefetchedRawBuf = null;
+    let _prefetchedRawFromCache = false;
+    if (_preferBufferedRead) {
+        const _cachedRaw = _rawContentCacheGet ? _rawContentCacheGet(fullPath, st) : null;
+        if (_cachedRaw) {
+            _prefetchedRawBuf = _cachedRaw;
+            _prefetchedRawFromCache = true;
+        } else {
+            try { _prefetchedRawBuf = await readFile(fullPath); } catch { _prefetchedRawBuf = null; }
+        }
+    }
+    const _readEnc = _prefetchedRawBuf
+        ? detectReadEncodingFromBuffer(_prefetchedRawBuf.subarray(0, Math.min(3, _prefetchedRawBuf.length)))
+        : await detectReadEncoding(fullPath);
     // UTF-16 (LE or BE) reads share one constraint: the streaming/binary
     // paths decode chunks as utf-8, so a BOM-flagged UTF-16 file must route
     // to the bounded in-memory decode below regardless of byte order.
     const _isUtf16 = _readEnc.encoding === 'utf16le' || _readEnc.encoding === 'utf16be';
+    let _binaryInspection = null;
+    const _inspectBinary = async () => {
+        if (_binaryInspection) return _binaryInspection;
+        _binaryInspection = _prefetchedRawBuf
+            ? {
+                isBinary: isBinaryBuffer(_prefetchedRawBuf, st.size),
+                preview: _prefetchedRawBuf.subarray(0, Math.min(256, _prefetchedRawBuf.length)),
+            }
+            : await inspectBinaryFile(fullPath, st.size);
+        return _binaryInspection;
+    };
     if (st.size > READ_MAX_SIZE_BYTES) {
         // .pdf/.ipynb were already dispatched up front (MEDIA-WINS), so this
         // >10MiB branch only handles the non-media text path from here on.
@@ -450,8 +489,13 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         if (!hasRangeArgs) {
             return `Error: file size ${st.size} bytes exceeds ${READ_MAX_SIZE_BYTES}-byte cap.`;
         }
-        if (isBinaryFile(fullPath, st.size)) {
-            const { text, snapshotMeta } = formatBinaryReadPreview(fullPath, normalizeOutputPath(filePath), st.size);
+        const _binary = await _inspectBinary();
+        if (_binary.isBinary) {
+            const { text, snapshotMeta } = formatBinaryReadPreviewFromBuffer(
+                _binary.preview,
+                normalizeOutputPath(filePath),
+                st.size,
+            );
             _recordReadSnapshot(fullPath, st, readStateScope, snapshotMeta);
             _cacheSet(cacheKey, text, { paths: [fullPath], readSnapshotMeta: snapshotMeta });
             return withSymbolReadNote(text, args);
@@ -510,11 +554,18 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
     // unambiguous TEXT signal, so classify it as utf16le up front and skip
     // NUL rejection. (_readEnc was detected above, before the >10MiB size
     // branch, so the large-file path can classify utf16le.)
-    if (!_isUtf16 && isBinaryFile(fullPath, st.size)) {
-        const { text, snapshotMeta } = formatBinaryReadPreview(fullPath, normalizeOutputPath(filePath), st.size);
-        _recordReadSnapshot(fullPath, st, readStateScope, snapshotMeta);
-        _cacheSet(cacheKey, text, { paths: [fullPath], readSnapshotMeta: snapshotMeta });
-        return withSymbolReadNote(text, args);
+    if (!_isUtf16) {
+        const _binary = await _inspectBinary();
+        if (_binary.isBinary) {
+            const { text, snapshotMeta } = formatBinaryReadPreviewFromBuffer(
+                _binary.preview,
+                normalizeOutputPath(filePath),
+                st.size,
+            );
+            _recordReadSnapshot(fullPath, st, readStateScope, snapshotMeta);
+            _cacheSet(cacheKey, text, { paths: [fullPath], readSnapshotMeta: snapshotMeta });
+            return withSymbolReadNote(text, args);
+        }
     }
     // Whole-file reads above READ_WHOLE_FILE_MAX_BYTES use stream smart-elide
     // (then READ_MAX_OUTPUT_BYTES truncation) instead of refusing. Absolute
@@ -588,8 +639,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         }
     }
     try {
-        const cachedRawBuf = _rawContentCacheGet ? _rawContentCacheGet(fullPath, st) : null;
-        const rawBuf = cachedRawBuf || await readFile(fullPath);
+        const rawBuf = _prefetchedRawBuf || await readFile(fullPath);
         // Encoding-aware decode (fresh read AND raw-content cache hit both
         // flow through here). For a BOM-flagged UTF-16LE file, strip the
         // 2-byte FF FE BOM and decode as utf16le so it reverses the write
@@ -614,7 +664,7 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         // the cache + snapshot record stale bytes.
         let _stPostRead;
         let _readStableForRawCache = true;
-        if (cachedRawBuf) {
+        if (_prefetchedRawFromCache) {
             _stPostRead = st;
         } else {
             try { _stPostRead = await fsPromises.stat(fullPath); } catch { _stPostRead = st; }

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

@@ -1,16 +1,15 @@
 import { readFile, stat } from 'fs/promises';
 import { open } from 'fs/promises';
-import { createRequire } from 'module';
 import { READ_MAX_SIZE_BYTES } from './read-constants.mjs';
 import { imageBlocksFromBuffer } from './read-image-resize.mjs';
+import { inspectPdfBuffer } from '../../../../attachments/pdf-extract.mjs';
 
-const requireCjs = createRequire(import.meta.url);
 const DEFAULT_READ_MAX_OUTPUT_BYTES = 100 * 1024;
 
 // PDFs at or under this size are emitted as an Anthropic base64 document
 // block (the model reads the rendered PDF directly): 20MB raw → ~27MB
 // base64, which stays under the 32MB request cap.
-// Larger PDFs fall back to pdf-parse TEXT extraction.
+// Larger PDFs fall back to bounded PDF.js text extraction.
 const PDF_DOCUMENT_MAX_BYTES = 20 * 1024 * 1024;
 
 // %PDF- magic bytes (0x25 0x50 0x44 0x46 0x2D). A document block must only be
@@ -66,37 +65,18 @@ function parsePagesArg(pagesArg) {
     return { filter: { from, to } };
 }
 
-// pdf-parse TEXT extraction. Fallback path for PDFs over the document-block
+// PDF.js text extraction. Fallback path for PDFs over the document-block
 // size cap, and the always-path when a page range is requested (a base64
 // document block can't be page-filtered, so a narrowed read keeps using text).
 async function extractPdfTextBody(fullPath, pageFilter, maxOutputBytes) {
-    const pdfParse = requireCjs('pdf-parse');
     const buf = await readFile(fullPath);
-    const pageTexts = [];
-    const data = await pdfParse(buf, {
-        pagerender: (pageData) => {
-            // pdf-parse exposes either `pageNumber` (1-based, pdf.js) or
-            // `_pageIndex` (0-based, internal); preferring pageIndex+1 over
-            // pageNumber dropped/duplicated pages when pdf.js renumbered with
-            // annotations or oddball page trees. Use pageNumber first.
-            const pageNum = (typeof pageData.pageNumber === 'number')
-                ? pageData.pageNumber
-                : ((pageData._pageIndex ?? pageData.pageIndex ?? 0) + 1);
-            if (pageFilter && (pageNum < pageFilter.from || pageNum > pageFilter.to)) return Promise.resolve('');
-            return pageData.getTextContent().then((tc) => {
-                const text = tc.items.map((i) => i.str).join(' ');
-                pageTexts.push({ page: pageNum, text });
-                return text;
-            });
-        },
+    const result = await inspectPdfBuffer(buf, {
+        extractText: true,
+        maxPages: Infinity,
+        maxOutputBytes,
+        pageRange: pageFilter,
     });
-    let out = pageFilter
-        ? pageTexts.map((p) => `--- Page ${p.page} ---\n${p.text}`).join('\n\n')
-        : (data.text || '');
-    if (out.length > maxOutputBytes) {
-        out = out.slice(0, maxOutputBytes) + `\n\n... [PDF output truncated at ${Math.round(maxOutputBytes / 1024)} KB; use pages param to narrow]`;
-    }
-    return out || '(no text content extracted from PDF)';
+    return result.text || '(no text content extracted from PDF)';
 }
 
 export async function extractPdfText(fullPath, pagesArg, { maxOutputBytes = DEFAULT_READ_MAX_OUTPUT_BYTES, textOnly = false } = {}) {
@@ -136,7 +116,7 @@ export async function extractPdfText(fullPath, pagesArg, { maxOutputBytes = DEFA
         // TEXT fallback: >20MB PDFs, page-filtered reads, or non-magic files.
         return await extractPdfTextBody(fullPath, pages.filter, maxOutputBytes);
     } catch (err) {
-        return `Error: pdf-parse failed — ${err instanceof Error ? err.message : String(err)}`;
+        return `Error: PDF extraction failed — ${err instanceof Error ? err.message : String(err)}`;
     }
 }
 

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();