mixdog 0.9.134 → 0.9.136

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

@@ -476,6 +476,7 @@ export async function streamSmartReadSummary(fullPath, st, source = 'read_smart_
     };
 
     const deadline = Date.now() + READ_STREAM_TIMEOUT_MS;
+    let scanCompleted = false;
     try {
         while (position < st.size) {
             if (Date.now() > deadline) throw new Error(`read timed out after ${READ_STREAM_TIMEOUT_MS}ms`);
@@ -513,10 +514,12 @@ export async function streamSmartReadSummary(fullPath, st, source = 'read_smart_
                 : Buffer.concat(pendingParts, pendingBytes);
             finishLine(lineBuf, currentLineStartByte, st.size);
         }
+        scanCompleted = true;
     } finally {
-        await fh.close().catch(() => {});
+        if (!scanCompleted) await fh.close().catch(() => {});
     }
 
+    try {
     const tailLen = Math.min(tailCount, SMART_READ_TAIL_LINES);
     const tailOffsets = [];
     for (let i = tailCount - tailLen; i < tailCount; i++) {
@@ -530,14 +533,9 @@ export async function streamSmartReadSummary(fullPath, st, source = 'read_smart_
         const byteLen = Math.max(0, lastEnd - firstStart);
         let tailWindow = Buffer.alloc(0);
         if (byteLen > 0) {
-            const tailFh = await fsPromises.open(fullPath, 'r');
-            try {
-                tailWindow = Buffer.allocUnsafe(byteLen);
-                const { bytesRead } = await tailFh.read(tailWindow, 0, byteLen, firstStart);
-                if (bytesRead < byteLen) tailWindow = tailWindow.subarray(0, bytesRead);
-            } finally {
-                await tailFh.close().catch(() => {});
-            }
+            tailWindow = Buffer.allocUnsafe(byteLen);
+            const { bytesRead } = await fh.read(tailWindow, 0, byteLen, firstStart);
+            if (bytesRead < byteLen) tailWindow = tailWindow.subarray(0, bytesRead);
         }
         for (const entry of tailOffsets) {
             let rawBuf = tailWindow.subarray(entry.startByte - firstStart, entry.endByte - firstStart);
@@ -604,4 +602,7 @@ export async function streamSmartReadSummary(fullPath, st, source = 'read_smart_
             rangeHashes,
         },
     };
+    } finally {
+        await fh.close().catch(() => {});
+    }
 }

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

@@ -60,6 +60,7 @@ import {
     cacheSet,
     runResultCacheInFlight,
     statPathsForMtime,
+    visitPathsForMtime,
 } from './cache-layers.mjs';
 import { recordLocalSearchCacheHit } from './local-search-telemetry.mjs';
 import { applyGrepContextLeadPolicy, GREP_CONTEXT_MAX, hasUnsupportedRipgrepRegex } from './arg-guard.mjs';
@@ -121,6 +122,58 @@ function _globDefaultHeadLimit() {
     return parsed > 0 ? parsed : 100;
 }
 
+function compareGlobMtimeEntries(a, b) {
+    const dm = b.mtime - a.mtime;
+    if (dm !== 0) return dm;
+    return globMtimeTiePath(a).localeCompare(globMtimeTiePath(b));
+}
+
+function retainBestEntries(heap, candidate, limit, compare) {
+    if (heap.length < limit) {
+        heap.push(candidate);
+        for (let index = heap.length - 1; index > 0;) {
+            const parent = Math.floor((index - 1) / 2);
+            if (compare(heap[index], heap[parent]) <= 0) break;
+            [heap[index], heap[parent]] = [heap[parent], heap[index]];
+            index = parent;
+        }
+        return;
+    }
+    if (compare(candidate, heap[0]) >= 0) return;
+    heap[0] = candidate;
+    for (let index = 0;;) {
+        const left = index * 2 + 1;
+        const right = left + 1;
+        let worst = index;
+        if (left < heap.length && compare(heap[left], heap[worst]) > 0) worst = left;
+        if (right < heap.length && compare(heap[right], heap[worst]) > 0) worst = right;
+        if (worst === index) break;
+        [heap[index], heap[worst]] = [heap[worst], heap[index]];
+        index = worst;
+    }
+}
+
+export function _createGlobMtimeTopK(limit) {
+    const cap = Math.max(1, Math.floor(Number(limit) || 1));
+    const statted = [];
+    const unstatted = [];
+    return {
+        add(entry, index) {
+            if (entry?.stat != null) {
+                retainBestEntries(statted, entry, cap, compareGlobMtimeEntries);
+            } else {
+                retainBestEntries(unstatted, { ...entry, _walkIndex: index }, cap,
+                    (a, b) => a._walkIndex - b._walkIndex);
+            }
+        },
+        values() {
+            statted.sort(compareGlobMtimeEntries);
+            unstatted.sort((a, b) => a._walkIndex - b._walkIndex);
+            return [...statted, ...unstatted].slice(0, cap);
+        },
+    };
+}
+
 function _grepContextCharBudget(options = {}) {
     const explicit = Number(options?._grepContextCharBudget);
     if (Number.isFinite(explicit) && explicit > 0) return Math.floor(explicit);
@@ -338,11 +391,27 @@ export async function executeGlobTool(args, workDir, options = {}) {
     let rgStdoutPartial = false;
     let rgWindowIncomplete = false;
     let rgCacheUnsafe = false;
+    let nativeMtimeTotal = null;
     const accumCap = 50000;
     const canWindowNatural = sortMode === 'natural' && headLimit !== Infinity;
+    const canWindowMtime = sortMode === 'mtime'
+        && headLimit !== Infinity;
     const groupRuns = await Promise.all(globGroups.map(async ([root, rels]) => {
         const rgArgs = ['--files', '--hidden'];
-        for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
+        // Explicit literal basenames (no glob magic in the final segment)
+        // name a concrete file: honor rg's later-glob-wins contract and let
+        // the lookup descend dependency-noise dirs, which the native walker
+        // would otherwise prune before the pattern could ever match. Wildcard
+        // basenames keep the noise prunes; device-name globs (no trailing
+        // /**) always apply.
+        const explicitBasenames = rels.length > 0 && rels.every((rel) => {
+            const base = String(rel).split('/').filter(Boolean).pop() || '';
+            return base !== '' && !hasGlobMagic(base);
+        });
+        for (const ex of DEFAULT_IGNORE_GLOBS) {
+            if (explicitBasenames && /^!\*\*\/[^/]+\/\*\*$/.test(ex)) continue;
+            rgArgs.push('--glob', ex);
+        }
         for (const ex of extraIgnoreGlobs) rgArgs.push('--glob', ex);
         for (const rel of rels) rgArgs.push('--glob', rel);
         const rgCwd = resolvedForSearchRoot(root);
@@ -378,6 +447,24 @@ export async function executeGlobTool(args, workDir, options = {}) {
             };
         }
         try {
+            if (canWindowMtime) {
+                const served = await runRgWindowedLines(
+                    rgArgs,
+                    { cwd: rgCwd, signal: sharedSignal },
+                    { offset: 0, limit: offset + headLimit + 1, mtimeTopK: true },
+                );
+                return {
+                    error: null,
+                    paths: served.lines.map((line) =>
+                        isAbsolute(line) ? line : resolveAgainstCwd(line, rgCwd)),
+                    stdoutTruncated: false,
+                    stdoutPartial: served.partial === true,
+                    windowIncomplete: false,
+                    cacheSafe: served.cacheSafe !== false,
+                    nativeMtime: true,
+                    totalSeen: served.totalSeen,
+                };
+            }
             if (canWindowNatural) {
                 const served = await runRgWindowedLines(
                     rgArgs,
@@ -427,6 +514,9 @@ export async function executeGlobTool(args, workDir, options = {}) {
         if (run.stdoutPartial) rgStdoutPartial = true;
         if (run.windowIncomplete) rgWindowIncomplete = true;
         if (run.cacheSafe === false) rgCacheUnsafe = true;
+        if (run.nativeMtime) {
+            nativeMtimeTotal = (nativeMtimeTotal ?? 0) + Math.max(0, Number(run.totalSeen) || 0);
+        }
         for (const p of run.paths) {
             allFiles.push(p);
             if (allFiles.length >= accumCap) {
@@ -441,34 +531,59 @@ export async function executeGlobTool(args, workDir, options = {}) {
 
     const unique = Array.from(new Set(allFiles));
     let orderedPaths;
-    if (sortMode === 'mtime') {
-        // Default mtime sorting stats every match. Bound the post-rg stat
-        // phase so a hung mount cannot pin glob until the agent stall
-        // watchdog fires.
-        const withStatAll = await statPathsForMtime(unique, workDir, 64, { deadlineMs: 5000 });
+    if (nativeMtimeTotal !== null && globGroups.length === 1) {
+        orderedPaths = unique;
+    } else if (nativeMtimeTotal !== null) {
+        const withStat = await statPathsForMtime(unique, workDir, 64, { deadlineMs: 5000 });
         const statted = [];
         const unstatted = [];
-        for (const entry of withStatAll) {
+        for (const entry of withStat) {
             if (!entry) continue;
             if (entry.stat != null) statted.push(entry);
             else unstatted.push(entry);
         }
-        statted.sort((a, b) => {
-            const dm = b.mtime - a.mtime;
-            if (dm !== 0) return dm;
-            return globMtimeTiePath(a).localeCompare(globMtimeTiePath(b));
-        });
-        // A deadline-expired or failed stat degrades ORDERING only, never
-        // completeness: unsortable entries keep their walk order at the tail.
-        orderedPaths = [...statted, ...unstatted].map((entry) => entry.full || resolveAgainstCwd(entry.path, workDir));
+        statted.sort(compareGlobMtimeEntries);
+        orderedPaths = [...statted, ...unstatted]
+            .map((entry) => entry.full || resolveAgainstCwd(entry.path, workDir));
+    } else if (sortMode === 'mtime') {
+        // Default mtime sorting stats every match. Bound the post-rg stat
+        // phase so a hung mount cannot pin glob until the agent stall
+        // watchdog fires.
+        if (headLimit === Infinity) {
+            const withStatAll = await statPathsForMtime(unique, workDir, 64, { deadlineMs: 5000 });
+            const statted = [];
+            const unstatted = [];
+            for (const entry of withStatAll) {
+                if (!entry) continue;
+                if (entry.stat != null) statted.push(entry);
+                else unstatted.push(entry);
+            }
+            statted.sort(compareGlobMtimeEntries);
+            // A deadline-expired or failed stat degrades ORDERING only, never
+            // completeness: unsortable entries keep their walk order at the tail.
+            orderedPaths = [...statted, ...unstatted]
+                .map((entry) => entry.full || resolveAgainstCwd(entry.path, workDir));
+        } else {
+            // Scan and stat every match for exact global ordering, but retain
+            // only the requested page plus one lookahead row. This changes
+            // O(N log N) sorting and O(N) result retention to O(N log K) and
+            // O(K) without narrowing the searched candidate set.
+            const selector = _createGlobMtimeTopK(
+                Math.min(unique.length, offset + headLimit + 1),
+            );
+            await visitPathsForMtime(unique, workDir, 64, { deadlineMs: 5000 },
+                (entry, index) => selector.add(entry, index));
+            orderedPaths = selector.values()
+                .map((entry) => entry.full || resolveAgainstCwd(entry.path, workDir));
+        }
     } else {
         orderedPaths = unique.map((entry) => isAbsolute(entry) ? resolve(entry) : resolveAgainstCwd(entry, workDir));
     }
-    const totalBeforeOffset = orderedPaths.length;
+    const totalBeforeOffset = nativeMtimeTotal ?? unique.length;
     const windowed = offset > 0 ? orderedPaths.slice(offset) : orderedPaths;
     const capped = (headLimit === Infinity ? windowed : windowed.slice(0, headLimit))
         .map((abs) => relativeSearchResultPath(abs, workDir));
-    const remaining = windowed.length - capped.length;
+    const remaining = Math.max(0, totalBeforeOffset - offset - capped.length);
     const truncSuffix = accumTruncated
         ? '\n... [truncated at accumulation cap (50000)]'
         : (rgStdoutTruncated ? '\n... [truncated at rg stdout cap (20MB); results incomplete]' : '')
@@ -494,8 +609,12 @@ export async function executeGlobTool(args, workDir, options = {}) {
     if (options?.scopedCacheOutcome && (accumTruncated || rgStdoutTruncated || rgStdoutPartial || rgWindowIncomplete || remaining > 0)) {
         markScopedCacheIncomplete(options.scopedCacheOutcome);
     }
-    const globIncomplete = accumTruncated || rgStdoutTruncated || rgStdoutPartial || rgWindowIncomplete || remaining > 0;
-    if (!globIncomplete && !rgCacheUnsafe) {
+    // Pagination is not an incomplete computation: limit/offset are part of
+    // the cache key, and the native watcher invalidates the scoped page on any
+    // relevant namespace/mtime change. Cache exact pages even when more rows
+    // exist; only a genuinely partial scan must bypass reuse.
+    const globComputationIncomplete = accumTruncated || rgStdoutTruncated || rgStdoutPartial || rgErrors.length > 0;
+    if (!globComputationIncomplete && !rgCacheUnsafe) {
         cacheSet(cacheKey, out, { scopes: [...groups.keys()].map((root) => resolvedForSearchRoot(root)) });
     }
     // ② completion progress (claude "Found N" parity). Best-effort, no-op

package/src/runtime/agent/orchestrator/tools/builtin/search-glob-top-k.test.mjs

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { _createGlobMtimeTopK } from './search-glob-tool.mjs';
+
+function entry(path, mtime, stat = {}) {
+    return { path, full: path, mtime, mtimeMs: mtime, stat };
+}
+
+test('glob mtime top-K exactly matches full ordering and preserves failed-stat walk order', () => {
+    const entries = [
+        entry('z-old', 1),
+        entry('b-tie', 9),
+        entry('failed-first', 0, null),
+        entry('a-tie', 9),
+        entry('newest', 12),
+        entry('failed-second', 0, null),
+        entry('middle', 5),
+    ];
+    const selector = _createGlobMtimeTopK(6);
+    const completionOrder = [5, 1, 6, 2, 4, 0, 3];
+    for (const index of completionOrder) selector.add(entries[index], index);
+
+    assert.deepEqual(
+        selector.values().map((item) => item.path),
+        ['newest', 'a-tie', 'b-tie', 'middle', 'z-old', 'failed-first'],
+    );
+});
+
+test('glob mtime top-K retains only the requested bound', () => {
+    const selector = _createGlobMtimeTopK(3);
+    for (let index = 0; index < 100; index += 1) {
+        selector.add(entry(`file-${String(index).padStart(3, '0')}`, index), index);
+    }
+    assert.deepEqual(
+        selector.values().map((item) => item.path),
+        ['file-099', 'file-098', 'file-097'],
+    );
+});

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

@@ -520,7 +520,13 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     // Skipped for pattern arrays and when `-i` is already set.
     const caseHintSuffix = async () => {
         const caseInsensitive = args['-i'] === true;
-        if (caseInsensitive || patterns.length !== 1 || !/[A-Za-z]/.test(patterns[0])) return '';
+        // A broad no-match must not trigger a second whole-tree scan just to
+        // produce an advisory casing hint. The requested case-sensitive result
+        // is already complete; retain the hint only for explicit file scopes.
+        if (grepStat.isDirectory()
+            || caseInsensitive
+            || patterns.length !== 1
+            || !/[A-Za-z]/.test(patterns[0])) return '';
         try {
             const probeArgs = buildGrepRgArgs({
                 patterns,

package/src/runtime/agent/orchestrator/tools/builtin/shell-analysis.mjs

@@ -568,7 +568,10 @@ export function preflightPowerShellHygiene(command, { shellType, shellName } = {
     // regex/search args are never mistaken for real syntax.
     const masked = maskQuotedRegions(rewritten);
 
-    for (const segment of shellSplitSegments(rewritten)) {
+    // Only command heads matter here. Scan the quote-masked copy so PowerShell
+    // literals use PowerShell escaping rules (`\` is literal, backtick escapes)
+    // and nested bash snippets remain opaque.
+    for (const segment of shellSplitSegments(masked)) {
         for (const stage of shellSplitPipelineSegments(segment)) {
             const tokens = stripShellProbeWrappers(shellTokenize(stage) || []);
             if (tokens.length === 0) continue;

package/src/runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs

@@ -1,8 +1,16 @@
 import os from 'node:os';
 import {
+    modelVisibleToolCompletionMessage,
     normalizeToolNotifyContext,
     notifyToolCompletion,
 } from '../../../../shared/tool-execution-contract.mjs';
+// Runtime-only bindings (used inside completion delivery, never at module
+// eval), so the static cycle through session/manager.mjs is safe — same
+// pattern as loop/tool-exec.mjs.
+import {
+    enqueuePendingMessage,
+    markCompletionEntry,
+} from '../../session/manager.mjs';
 import {
     completeBackgroundTask,
 } from '../../../../shared/background-tasks.mjs';
@@ -22,6 +30,8 @@ import {
 } from './lib/shell-job-insights.mjs';
 import {
     completeShellJobRecord,
+    listShellJobRecords,
+    pidAlive,
     publishShellJobRecord,
 } from './lib/shell-job-records.mjs';
 import {
@@ -86,7 +96,7 @@ function shellJobTaskStatus(status) {
     return 'failed';
 }
 
-function buildShellCompletion(jobId, detail) {
+export function buildShellCompletion(jobId, detail) {
     const startedAtMs = Date.parse(detail?.startedAt || '');
     const finishedAtMs = Date.parse(detail?.finishedAt || '') || Date.now();
     const elapsedMs = Number.isFinite(startedAtMs)
@@ -247,7 +257,12 @@ export function watchBackgroundShellJob(jobId, notifyCtx) {
             instruction: completion.instruction,
             terminalReason: 'shell-native-event',
         });
-        if (!completedTask && ctx && typeof ctx.notifyFn === 'function') {
+        if (!completedTask) {
+            // Delivery order: owner notifyFn when present, else the owner
+            // session's pending queue. A ctx-less finish (daemon restarted
+            // between job start and completion, or a watcher armed without a
+            // notify context) previously dropped the completion silently.
+            const owner = String(ctx?.callerSessionId || detail.ownerSessionId || '');
             notifyToolCompletion({
                 surface: 'shell',
                 id: jobId,
@@ -255,7 +270,19 @@ export function watchBackgroundShellJob(jobId, notifyCtx) {
                 text: completion.body,
                 resultType: 'shell_task_result',
                 instruction: completion.instruction,
-                context: ctx,
+                context: ctx || { callerSessionId: owner },
+                enqueueFallback: (sessionId, message, meta) => {
+                    let visible = modelVisibleToolCompletionMessage(message, meta);
+                    // Bodyless envelopes (a finished command with no output)
+                    // fail the persistence gate's result-body requirement;
+                    // retry with an explicit "(no output)" section rather
+                    // than dropping the completion.
+                    if (!visible && !/\n\s*\n/.test(String(message || ''))) {
+                        visible = modelVisibleToolCompletionMessage(`${message}\n\n(no output)`, meta);
+                    }
+                    if (!visible) return false;
+                    return enqueuePendingMessage(sessionId, markCompletionEntry(visible)) > 0;
+                },
                 logPrefix: 'shell-jobs',
             });
         }
@@ -287,6 +314,56 @@ export async function adoptForegroundShellJob({
     return native;
 }
 
+// Daemon-restart recovery: records left 'running' by a dead daemon can never
+// finish through the live watcher path — their completion (and output) used to
+// vanish silently. Finalize each dead-pid record and push one completion
+// notice to the owner session's pending queue. Content-addressed completion
+// ids keep multi-shard reconciliation idempotent.
+let _recoveredCompletionsReconciled = false;
+export async function reconcileRecoveredShellJobCompletions() {
+    if (_recoveredCompletionsReconciled) return 0;
+    _recoveredCompletionsReconciled = true;
+    let records = [];
+    try { records = await listShellJobRecords(); } catch { return 0; }
+    let notified = 0;
+    for (const record of records) {
+        if (!record || record.terminal) continue;
+        if (getNativeTask(record.jobId)) continue; // live in this daemon
+        if (pidAlive(Number(record.pid) || 0)) continue; // survived the restart
+        const detail = {
+            ...record,
+            status: 'failed',
+            error: 'daemon restarted while this shell task was running; its outcome was lost. Re-run the command if the result is still needed.',
+        };
+        try { await completeShellJobRecord(record.jobId, detail); } catch { /* best-effort */ }
+        const owner = String(record.ownerSessionId || '');
+        if (!owner) continue;
+        try {
+            const completion = buildShellCompletion(record.jobId, detail);
+            const delivered = notifyToolCompletion({
+                surface: 'shell',
+                id: record.jobId,
+                status: completion.taskStatus,
+                // The pending-queue persistence gate requires a blank-line
+                // separated result body; a bodyless bracketed envelope would
+                // be dropped. The restart notice IS the result here.
+                text: `${completion.body}\n\n${detail.error}`,
+                resultType: 'shell_task_result',
+                instruction: completion.instruction,
+                context: { callerSessionId: owner },
+                enqueueFallback: (sessionId, message, meta) => {
+                    const visible = modelVisibleToolCompletionMessage(message, meta);
+                    if (!visible) return false;
+                    return enqueuePendingMessage(sessionId, markCompletionEntry(visible)) > 0;
+                },
+                logPrefix: 'shell-jobs-recovery',
+            });
+            if (delivered) notified += 1;
+        } catch { /* best-effort */ }
+    }
+    return notified;
+}
+
 export async function shutdownShellJobs(_reason = 'runtime-close', { scope = null } = {}) {
     const scoped = Boolean(scope);
     const ownerSessionId = scoped ? String(scope.ownerSessionId || '') : '';

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

@@ -3,6 +3,7 @@
 // race), isCodeGraphTool. Extracted verbatim from code-graph.mjs.
 import { resolve as pathResolve, isAbsolute, relative as pathRelative, basename as pathBasename, extname } from 'node:path';
 import { homedir as osHomedir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { existsSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { normalizeInputPath, toDisplayPath } from '../builtin.mjs';
@@ -29,6 +30,8 @@ import {
   _stripEmptyArgs,
 } from './project-root.mjs';
 import { buildCodeGraphAsync, prewarmCodeGraph, prewarmCodeGraphSymbols } from './build.mjs';
+import { _fileInfoFromRustRecord, _runGraphFiles } from './graph-binary.mjs';
+import { _attachGraphRuntimeCaches } from './graph-model.mjs';
 import {
   _isFilesystemRootPath,
   collectTrustedCodeGraphRoots,
@@ -87,6 +90,74 @@ function _outlineLanguageForPath(file) {
   return null;
 }
 
+const _exactFileGraphInflight = new Map();
+const _exactFileGraphCache = new Map();
+const EXACT_FILE_GRAPH_CACHE_MAX = 64;
+
+async function _buildExactFileGraph(cwd, abs, signal = null) {
+  const root = pathResolve(cwd);
+  const file = pathResolve(abs);
+  const rel = _graphRel(file, root);
+  const key = `${root}\0${rel}`;
+  const sourceText = await readFile(file, { encoding: 'utf8', signal: signal || undefined });
+  const sourceHash = createHash('sha256').update(sourceText).digest('hex');
+  const cached = _exactFileGraphCache.get(key);
+  if (cached?.sourceHash === sourceHash) {
+    _exactFileGraphCache.delete(key);
+    _exactFileGraphCache.set(key, cached);
+    return cached.graph;
+  }
+  const existing = _exactFileGraphInflight.get(key);
+  if (existing?.sourceHash === sourceHash) return existing.promise;
+  const pending = (async () => {
+    const records = await _runGraphFiles(root, [rel], [], signal);
+    const record = records.find((item) => _graphRel(pathResolve(root, item.rel), root) === rel);
+    if (!record) return null;
+    const info = _fileInfoFromRustRecord(record, root);
+    const node = {
+      abs: info.abs,
+      rel: info.rel,
+      lang: info.lang,
+      fingerprint: info.fingerprint,
+      rawImports: info.rawImports,
+      resolvedImportsRel: [],
+      resolvedImports: [],
+      importedBy: [],
+      packageName: info.packageName,
+      namespaceName: info.namespaceName,
+      goPackageName: info.goPackageName,
+      topLevelTypes: info.topLevelTypes,
+      tokenSymbols: info.tokenSymbols,
+      symbols: Array.isArray(info.symbols) ? info.symbols : [],
+    };
+    const graph = _attachGraphRuntimeCaches({
+      cwd: root,
+      nodes: new Map([[node.rel, node]]),
+      reverse: new Map(),
+      builtAt: Date.now(),
+      signature: info.fingerprint || '',
+      truncated: false,
+    });
+    graph._sourceTextCache.set(node.rel, {
+      fingerprint: node.fingerprint || '',
+      text: sourceText,
+    });
+    _exactFileGraphCache.delete(key);
+    _exactFileGraphCache.set(key, { sourceHash, graph });
+    while (_exactFileGraphCache.size > EXACT_FILE_GRAPH_CACHE_MAX) {
+      _exactFileGraphCache.delete(_exactFileGraphCache.keys().next().value);
+    }
+    return graph;
+  })();
+  const inflight = { sourceHash, promise: pending };
+  _exactFileGraphInflight.set(key, inflight);
+  try {
+    return await pending;
+  } finally {
+    if (_exactFileGraphInflight.get(key) === inflight) _exactFileGraphInflight.delete(key);
+  }
+}
+
 async function _mapWithConcurrency(values, mapper) {
   const out = new Array(values.length);
   let cursor = 0;
@@ -693,9 +764,17 @@ async function findSymbolTool(args, cwd, signal = null, options = {}) {
     else prewarmCodeGraph(cwd);
     return `prewarm scheduled: cwd=${cwd} symbols=${symbols.length}${symbols.length ? ` (${symbols.slice(0, 5).join(',')}${symbols.length > 5 ? `,+${symbols.length - 5}` : ''})` : ''}`;
   }
-  const graph = await buildCodeGraphAsync(cwd, signal, {
-    excludedProjectRoots: options?.excludedProjectRoots,
-  });
+  const normFile = normalizeInputPath(args?.file);
+  const abs = normFile ? (isAbsolute(normFile) ? pathResolve(normFile) : pathResolve(cwd, normFile)) : null;
+  let exactFile = false;
+  if (abs && _outlineLanguageForPath(abs)) {
+    try { exactFile = statSync(abs).isFile(); } catch { exactFile = false; }
+  }
+  const graph = exactFile
+    ? await _buildExactFileGraph(cwd, abs, signal)
+    : await buildCodeGraphAsync(cwd, signal, {
+        excludedProjectRoots: options?.excludedProjectRoots,
+      });
   if (!graph) throw new Error(`find_symbol: cwd '${cwd}' is not an indexed/known project root or contains zero eligible files`);
   if (options?.scopedCacheOutcome && graph.truncated) {
     markScopedCacheIncomplete(options.scopedCacheOutcome);
@@ -703,8 +782,6 @@ async function findSymbolTool(args, cwd, signal = null, options = {}) {
   const symbol = String(args?.symbol || '').trim();
   const language = String(args?.language || '').trim() || null;
   const limit = Math.max(1, Math.min(50, Number(args?.limit || 20)));
-  const normFile = normalizeInputPath(args?.file);
-  const abs = normFile ? (isAbsolute(normFile) ? pathResolve(normFile) : pathResolve(cwd, normFile)) : null;
   const fileRel = abs ? _graphRel(abs, cwd) : null;
   if (fileRel && !graph.nodes.get(fileRel)) {
     return _appendSameBasenameHint(`Error: find_symbol: file not found in graph: ${normFile}`, normFile, graph);

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

@@ -248,7 +248,7 @@ export function _runGraphWalk(absRoot) { return _runGraphBinaryJsonl(absRoot, []
 // topLevelTypes}. Rust builds the index + resolves over ALL nodes (fresh +
 // reused) and emits fresh rels as full records, reused rels as lightweight
 // {rel, resolvedImports, importedBy}.
-export function _runGraphFiles(absRoot, rels, reusedMetas) {
+export function _runGraphFiles(absRoot, rels, reusedMetas, signal = null) {
   const lines = Array.isArray(reusedMetas)
     ? reusedMetas.map((m) => JSON.stringify({
         rel: m.rel,
@@ -260,7 +260,7 @@ export function _runGraphFiles(absRoot, rels, reusedMetas) {
         topLevelTypes: Array.isArray(m.topLevelTypes) ? m.topLevelTypes : [],
       }))
     : [];
-  return _runGraphBinaryJsonl(absRoot, ['--files', ...rels], lines);
+  return _runGraphBinaryJsonl(absRoot, ['--files', ...rels], lines, signal);
 }
 
 // Map a Rust FileRecord (rel/lang/fp/tokens/rawImports/resolvedImports/

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

@@ -78,26 +78,10 @@ export function scrubLoaderVars(env) {
     return _continueScrubLoaderVars(env);
 }
 
-// Headless "web off" reaches shell children too: `mixdog exec` pins
-// MIXDOG_FEATURE_WEB_SEARCH=0 (default; --web-search opts back in) and every
-// model-spawned subprocess then receives the standard proxy variables pointed
-// at a dead loopback endpoint. curl/wget/git-http/pip/apt honor these and
-// fail fast on public hosts, while NO_PROXY keeps loopback traffic
-// (task-local servers) working. Raw-socket clients bypass proxy variables —
-// this is a uniform egress policy for the common tooling path, not a sandbox.
-// The runtime's own provider calls are unaffected: this mutates only the
-// child spawn env, never process.env.
-const SHELL_EGRESS_DEAD_PROXY = 'http://127.0.0.1:1';
-const SHELL_EGRESS_PROXY_VARS = ['HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'FTP_PROXY', 'RSYNC_PROXY'];
+// Web-search availability is independent from ordinary shell networking.
+// Keep this boundary explicit so disabling the search tool never blocks
+// package managers, source-control clients, or user-configured proxies.
 export function applyShellEgressPolicy(env) {
-    if (!env || typeof env !== 'object') return env;
-    if (String(process.env.MIXDOG_FEATURE_WEB_SEARCH ?? '') !== '0') return env;
-    for (const name of SHELL_EGRESS_PROXY_VARS) {
-        env[name] = SHELL_EGRESS_DEAD_PROXY;
-        env[name.toLowerCase()] = SHELL_EGRESS_DEAD_PROXY;
-    }
-    env.NO_PROXY = 'localhost,127.0.0.1,::1';
-    env.no_proxy = env.NO_PROXY;
     return env;
 }
 

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

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { applyShellEgressPolicy } from './env-scrub.mjs';
+
+test('web-search disabled preserves ordinary shell network environment', () => {
+    const previous = process.env.MIXDOG_FEATURE_WEB_SEARCH;
+    process.env.MIXDOG_FEATURE_WEB_SEARCH = '0';
+    try {
+        const env = {
+            HTTP_PROXY: 'http://proxy.example:8080',
+            HTTPS_PROXY: 'http://proxy.example:8080',
+            NO_PROXY: 'localhost',
+        };
+        assert.equal(applyShellEgressPolicy(env), env);
+        assert.deepEqual(env, {
+            HTTP_PROXY: 'http://proxy.example:8080',
+            HTTPS_PROXY: 'http://proxy.example:8080',
+            NO_PROXY: 'localhost',
+        });
+    } finally {
+        if (previous === undefined) delete process.env.MIXDOG_FEATURE_WEB_SEARCH;
+        else process.env.MIXDOG_FEATURE_WEB_SEARCH = previous;
+    }
+});