mixdog 0.9.162 → 0.9.163

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.162",
+  "version": "0.9.163",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/search-rg-parity.mjs

@@ -0,0 +1,132 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { performance } from 'node:perf_hooks';
+
+const project = process.cwd();
+const deadlineMs = Number(process.env.MIXDOG_PARITY_DEADLINE_MS || 15000);
+assert.ok(Number.isSafeInteger(deadlineMs) && deadlineMs > 0);
+const scratch = await mkdtemp(join(tmpdir(), 'mixdog-rg-parity-'));
+const fixture = join(scratch, 'fixture');
+await mkdir(join(fixture, '.git'), { recursive: true });
+await mkdir(join(fixture, '.cache'), { recursive: true });
+await writeFile(join(fixture, '.gitignore'), '*.mjs\n');
+for (const name of ['keep.mjs', 'drop.mjs', '.cache/hit.mjs', 'other.RS']) {
+    await writeFile(join(fixture, name), 'before\nneedle\nafter\n');
+}
+const server = spawn(resolve('native/mixdog-graph/target/release/mixdog-graph.exe'),
+    [project, '--serve-search'], {
+        env: { ...process.env, MIXDOG_DATA_DIR: join(scratch, 'data') },
+        stdio: ['pipe', 'pipe', 'inherit'],
+    });
+let id = 0;
+const pending = new Map();
+const lines = createInterface({ input: server.stdout });
+lines.on('line', line => {
+    const response = JSON.parse(line);
+    pending.get(response.id)?.(response);
+});
+server.on('error', error => {
+    for (const settle of pending.values()) settle({ error: error.message });
+});
+server.on('exit', code => {
+    for (const settle of pending.values()) settle({ error: `native exit ${code}` });
+});
+async function native(cwd, args) {
+    const requestId = ++id;
+    const started = performance.now();
+    const response = await new Promise(resolve => {
+        pending.set(requestId, resolve);
+        server.stdin.write(`${JSON.stringify({
+            id: requestId, cwd, args, limit: 0, offset: 0, deadlineMs,
+        })}\n`);
+    });
+    pending.delete(requestId);
+    assert.ok(!response.error && !response.unsupported, JSON.stringify(response));
+    return { ...response, ms: performance.now() - started };
+}
+async function rg(cwd, args) {
+    const started = performance.now();
+    return await new Promise((resolve, reject) => {
+        const child = spawn('rg', args, { cwd });
+        let stdout = '', stderr = '';
+        let timeout = false;
+        child.stdout.on('data', chunk => { stdout += chunk; });
+        child.stderr.on('data', chunk => { stderr += chunk; });
+        const timer = setTimeout(() => { timeout = true; child.kill(); }, deadlineMs);
+        child.on('error', reject);
+        child.on('close', code => {
+            clearTimeout(timer);
+            resolve({ lines: stdout.trimEnd().split(/\r?\n/).filter(Boolean),
+                complete: !timeout && (code === 0 || code === 1), timeout,
+                code, stderr, ms: performance.now() - started });
+        });
+    });
+}
+const normalized = rows => rows.map(row => row.replaceAll('\\', '/').replace(/^\.\//, '')).sort();
+async function compare(name, cwd, args) {
+    // Run sequentially: concurrent drive walks compete for the same storage
+    // and distort the completion time we are trying to measure.
+    const actual = await native(cwd, args);
+    let repeat;
+    if (cwd === 'C:/' && process.argv.includes('--repeat-drive')) {
+        repeat = await native(cwd, args);
+        assert.deepEqual(normalized(repeat.lines), normalized(actual.lines), `${name}: repeated results`);
+        assert.equal(repeat.scanErrors, actual.scanErrors, `${name}: repeated errors`);
+        assert.equal(repeat.complete, actual.complete, `${name}: repeated completeness`);
+        assert.equal(repeat.timeout, actual.timeout, `${name}: repeated timeout`);
+    }
+    const expected = await rg(cwd, args);
+    const traversalFinished = !actual.timeout && !expected.timeout
+        && [0, 1, 2].includes(expected.code);
+    if (cwd !== 'C:/') {
+        assert.ok(actual.complete && expected.complete, `${name}: incomplete search`);
+    }
+    if (traversalFinished) {
+        assert.deepEqual(normalized(actual.lines), normalized(expected.lines), name);
+    } else if (cwd !== 'C:/') {
+        assert.fail(`${name}: incomplete: ${JSON.stringify({ actual, expected })}`);
+    }
+    console.log(JSON.stringify({ name, nativeMs: +actual.ms.toFixed(1),
+        rgMs: +expected.ms.toFixed(1), nativeCount: actual.lines.length,
+        rgCount: expected.lines.length, complete: actual.complete && expected.complete,
+        traversalFinished, deadlineMs,
+        repeatMs: repeat && +repeat.ms.toFixed(1),
+        filesScanned: actual.filesScanned, nativeTimeout: actual.timeout,
+        scanErrors: actual.scanErrors, rgTimeout: expected.timeout }));
+}
+try {
+    const rules = [
+        ['--glob', '*.mjs'],
+        ['--glob', '*.mjs', '--glob', '!drop.mjs'],
+        ['--glob', '!drop.mjs', '--glob', '*.mjs'],
+        ['--glob', '!**/.cache/**', '--glob', '*.mjs'],
+        ['--glob', '*.mjs', '--glob', '!**/.cache/**'],
+        ['--glob', 'keep.mjs', '--iglob', '*.rs'],
+    ];
+    for (let i = 0; !process.argv.includes('--drive-only') && i < rules.length; i++) {
+        for (const mode of [['--files'], ['-l', '-e', 'needle'], ['-n', '-H', '-e', 'needle']]) {
+            await compare(`fixture-${i}-${mode[0]}`, fixture, ['--hidden', ...mode, ...rules[i], '.']);
+        }
+    }
+    for (const noIgnore of process.argv.includes('--drive-only') ? [] : [false, true]) {
+        const filters = ['--hidden', ...(noIgnore ? ['--no-ignore'] : []),
+            '--glob', '*.mjs', '--glob', '!**/.git/**', '--glob', '!**/node_modules/**'];
+        await compare(`project-files-ignore-${!noIgnore}`, project, ['--files', ...filters, '.']);
+        await compare(`project-grep-ignore-${!noIgnore}`, project,
+            ['-l', '-F', '-e', 'prepareGrepContextSources', ...filters, '.']);
+    }
+    if (process.argv.includes('--drive') || process.argv.includes('--drive-only')) {
+        await compare('drive-grep', 'C:/', ['-l', '-F', '-e', 'prepareGrepContextSources',
+            '--hidden', '--glob', '**/grep-context-expander.mjs', '--glob', '!**/.git/**', '.']);
+    }
+} finally {
+    const exited = new Promise(resolve => server.once('exit', resolve));
+    server.stdin.end();
+    if (server.exitCode === null) await exited;
+    lines.close();
+    await rm(scratch, { recursive: true, force: true });
+}

package/src/runtime/agent/orchestrator/tools/builtin/binary-file.mjs

@@ -77,17 +77,17 @@ export function isBinaryBuffer(buf, fileSize = buf?.length || 0) {
  * Returns the head bytes even when the null marker is in the tail so callers
  * can render a hex preview without reopening the file.
  */
-export async function inspectBinaryFile(fullPath, fileSize = 0, { previewBytes = 256 } = {}) {
+export async function inspectBinaryFile(fullPath, fileSize = 0, { previewBytes = 256, handle = null } = {}) {
     const headBytes = fileSize > 0 ? Math.min(fileSize, HEAD_CAP) : HEAD_CAP;
     let fh;
     try {
-        fh = await open(fullPath, 'r');
+        fh = handle || await open(fullPath, 'r');
         const headBuf = Buffer.allocUnsafe(Math.max(0, headBytes));
         const { bytesRead: nHead } = await fh.read(headBuf, 0, headBytes, 0);
         const head = headBuf.subarray(0, nHead);
         const preview = head.subarray(0, Math.min(previewBytes, nHead));
-        if (nHead === 0 || hasUtf16Bom(head, nHead)) return { isBinary: false, preview };
-        if (containsNull(head, nHead)) return { isBinary: true, preview };
+        if (nHead === 0 || hasUtf16Bom(head, nHead)) return { isBinary: false, preview, head };
+        if (containsNull(head, nHead)) return { isBinary: true, preview, head };
         if (fileSize > headBytes && fileSize > TAIL_SIZE) {
             const tailBuf = Buffer.allocUnsafe(TAIL_SIZE);
             const { bytesRead: nTail } = await fh.read(
@@ -96,13 +96,13 @@ export async function inspectBinaryFile(fullPath, fileSize = 0, { previewBytes =
                 TAIL_SIZE,
                 fileSize - TAIL_SIZE,
             );
-            if (containsNull(tailBuf, nTail)) return { isBinary: true, preview };
+            if (containsNull(tailBuf, nTail)) return { isBinary: true, preview, head };
         }
-        return { isBinary: false, preview };
+        return { isBinary: false, preview, head };
     } catch {
-        return { isBinary: false, preview: Buffer.alloc(0) };
+        return { isBinary: false, preview: Buffer.alloc(0), head: Buffer.alloc(0) };
     } finally {
-        if (fh) { try { await fh.close(); } catch {} }
+        if (fh && !handle) { try { await fh.close(); } catch {} }
     }
 }
 

package/src/runtime/agent/orchestrator/tools/builtin/cache-layers.mjs

@@ -1,11 +1,13 @@
 import { statSync } from 'fs';
 import * as fsPromises from 'fs/promises';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { isAbsolute, resolve, sep } from 'path';
 import { canonicalCachePath, deleteReadRangeIndexForPath } from './read-range-index.mjs';
 import { resolveAgainstCwd } from './path-utils.mjs';
 
 const RESULT_CACHE = new Map(); // key → { ts, value, paths, scopes, readSnapshotMeta, contentPrefixHash, bytes }
 const RESULT_CACHE_INFLIGHT = new Map(); // key → { promise, controller, subscribers, settled }
+const RESULT_CACHE_COMPUTE = new AsyncLocalStorage();
 const RESULT_CACHE_TTL_MS = 30_000;
 const RESULT_CACHE_MAX_ENTRIES = 200;
 const RESULT_CACHE_MAX_BYTES = (() => {
@@ -119,6 +121,10 @@ export function cacheGet(key) {
 }
 
 export function cacheSet(key, value, meta = {}) {
+    // Invalidation affects future reuse, not the active reader's snapshot.
+    // A detached/aborted computation must never repopulate a newer cache.
+    const computation = RESULT_CACHE_COMPUTE.getStore();
+    if (computation?.invalidated || computation?.controller?.signal?.aborted) return;
     // Replace-in-place: clear old entry's byte accounting before write.
     if (RESULT_CACHE.has(key)) resultCacheDelete(key);
     const bytes = estimateResultBytes(value);
@@ -156,7 +162,11 @@ async function subscribeResultCacheInFlight(entry, signal) {
     entry.subscribers.add(subscriber);
     const release = () => {
         if (!entry.subscribers.delete(subscriber)) return;
-        if (!entry.settled && entry.subscribers.size === 0) entry.controller.abort();
+        if (!entry.settled && entry.subscribers.size === 0) {
+            // Abort listeners run in the abort caller's context, not where
+            // they were registered. Keep their cleanup/cache writes guarded.
+            RESULT_CACHE_COMPUTE.run(entry, () => entry.controller.abort());
+        }
     };
     if (!signal) {
         try { return await entry.promise; }
@@ -186,58 +196,39 @@ async function subscribeResultCacheInFlight(entry, signal) {
 
 export async function runResultCacheInFlight(key, compute, options = {}) {
     const subscriberSignal = options?.signal || options?.abortSignal || null;
-    let invalidationRetries = 0;
-    for (;;) {
-        const cached = cacheGet(key);
-        if (cached !== null) return cached;
-        let entry = RESULT_CACHE_INFLIGHT.get(key);
-        if (entry?.controller?.signal?.aborted) {
-            if (RESULT_CACHE_INFLIGHT.get(key) === entry) RESULT_CACHE_INFLIGHT.delete(key);
-            entry = null;
-        }
-        if (!entry) {
-            const controller = new AbortController();
-            entry = {
-                promise: null,
-                controller,
-                subscribers: new Set(),
-                settled: false,
-                invalidated: false,
-                scopes: normalizeCacheMetaPaths(options?.scopes),
-            };
-            const promise = Promise.resolve()
-                .then(() => compute({ signal: controller.signal }))
-                .finally(() => {
-                    entry.settled = true;
-                    if (RESULT_CACHE_INFLIGHT.get(key) === entry) {
-                        RESULT_CACHE_INFLIGHT.delete(key);
-                    }
-                });
-            entry.promise = promise;
-            // An already-aborted first subscriber can release and cancel the
-            // compute before it attaches the normal await handlers below.
-            // Keep the shared promise rejection observed without changing it.
-            promise.catch(() => {});
-            RESULT_CACHE_INFLIGHT.set(key, entry);
-        } else if (Array.isArray(options?.scopes)) {
-            entry.scopes = normalizeCacheMetaPaths([...(entry.scopes || []), ...options.scopes]);
-        }
-        try {
-            return await subscribeResultCacheInFlight(entry, subscriberSignal);
-        } catch (error) {
-            // Watcher/patch invalidation can race an active read. That is a
-            // freshness retry, not a user-visible abort: start a new generation
-            // unless this subscriber itself was cancelled.
-            if (!entry.invalidated || subscriberSignal?.aborted) throw error;
-            // Continuous invalidation (watcher churn, eviction broadcasts)
-            // must not spin forever: after a few generations run the compute
-            // directly — uncached and no longer abortable by invalidation —
-            // mirroring the server-side MAX_WALK_RESTARTS cap.
-            if (++invalidationRetries >= 3) {
-                return await compute({ signal: subscriberSignal });
-            }
-        }
+    subscriberSignal?.throwIfAborted();
+    const cached = cacheGet(key);
+    if (cached !== null) return cached;
+    let entry = RESULT_CACHE_INFLIGHT.get(key);
+    if (entry?.controller?.signal?.aborted) {
+        if (RESULT_CACHE_INFLIGHT.get(key) === entry) RESULT_CACHE_INFLIGHT.delete(key);
+        entry = null;
+    }
+    if (!entry) {
+        const controller = new AbortController();
+        entry = {
+            promise: null,
+            controller,
+            subscribers: new Set(),
+            settled: false,
+            invalidated: false,
+            scopes: normalizeCacheMetaPaths(options?.scopes),
+        };
+        const promise = Promise.resolve()
+            .then(() => RESULT_CACHE_COMPUTE.run(entry, () => compute({ signal: controller.signal })))
+            .finally(() => {
+                entry.settled = true;
+                if (RESULT_CACHE_INFLIGHT.get(key) === entry) {
+                    RESULT_CACHE_INFLIGHT.delete(key);
+                }
+            });
+        entry.promise = promise;
+        promise.catch(() => {});
+        RESULT_CACHE_INFLIGHT.set(key, entry);
+    } else if (Array.isArray(options?.scopes)) {
+        entry.scopes = normalizeCacheMetaPaths([...(entry.scopes || []), ...options.scopes]);
     }
+    return subscribeResultCacheInFlight(entry, subscriberSignal);
 }
 
 export async function runRawContentInFlight(fullPath, loader = fsPromises.readFile) {
@@ -503,7 +494,6 @@ function runExtraInvalidationListeners(affectedPaths = null) {
 function cacheInvalidateAll() {
     for (const entry of RESULT_CACHE_INFLIGHT.values()) {
         entry.invalidated = true;
-        entry.controller?.abort();
     }
     RESULT_CACHE.clear();
     RESULT_CACHE_INFLIGHT.clear();
@@ -527,7 +517,6 @@ function cacheInvalidatePaths(paths) {
         if (scopes.length === 0
             || scopes.some((scope) => affectedPaths.some((affected) => cachePathsOverlap(scope, affected)))) {
             entry.invalidated = true;
-            entry.controller?.abort();
             RESULT_CACHE_INFLIGHT.delete(key);
         }
     }

package/src/runtime/agent/orchestrator/tools/builtin/lib/grep-context-expander.mjs

@@ -1,6 +1,5 @@
-import { createReadStream } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
-import { createInterface } from 'node:readline';
+import { readSourceWindows } from '../read-source-windows.mjs';
 
 import {
     normalizeOutputPath,
@@ -266,34 +265,7 @@ async function readFileWindows(entry, radius, signal) {
         start: Math.max(1, anchor.lineNo - radius),
         end: anchor.lineNo + radius,
     })));
-    const lines = new Map();
-    if (intervals.length === 0) return lines;
-    const input = createReadStream(entry.absolutePath, { encoding: 'utf8' });
-    const reader = createInterface({ input, crlfDelay: Infinity });
-    let lineNo = 0;
-    let intervalIndex = 0;
-    const abort = () => input.destroy(Object.assign(new Error('grep context expansion aborted'), { code: 'ABORT_ERR' }));
-    if (signal) {
-        if (signal.aborted) abort();
-        else signal.addEventListener('abort', abort, { once: true });
-    }
-    try {
-        for await (const line of reader) {
-            lineNo++;
-            while (intervalIndex < intervals.length && lineNo > intervals[intervalIndex].end) intervalIndex++;
-            if (intervalIndex >= intervals.length) {
-                input.destroy();
-                break;
-            }
-            const interval = intervals[intervalIndex];
-            if (lineNo >= interval.start && lineNo <= interval.end) lines.set(lineNo, line);
-        }
-        return lines;
-    } finally {
-        if (signal) signal.removeEventListener('abort', abort);
-        reader.close();
-        input.destroy();
-    }
+    return readSourceWindows(entry.absolutePath, intervals, { signal });
 }
 
 async function readAnchorSources(anchors, radius, signal) {
@@ -310,16 +282,30 @@ async function readAnchorSources(anchors, radius, signal) {
         groups.get(anchor.absolutePath).anchors.push(anchor);
     }
     const entries = [...groups.values()];
-    await Promise.all(entries.map(async (entry) => {
-        try {
-            entry.lines = await readFileWindows(entry, radius, signal);
-        } catch (err) {
-            entry.error = err;
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(4, entries.length) }, async () => {
+        while (next < entries.length) {
+            signal?.throwIfAborted();
+            const entry = entries[next++];
+            try {
+                entry.lines = await readFileWindows(entry, radius, signal);
+            } catch (err) {
+                signal?.throwIfAborted();
+                entry.error = err;
+            }
         }
     }));
     return groups;
 }
 
+// Share exactly the selected windows across independent pattern sections.
+export async function prepareGrepContextSources(lineGroups, options) {
+    const selected = lineGroups.flatMap((lines) => selectAnchors(
+        parseAnchors(lines, options), options.headLimit, options.offset,
+    ).selected);
+    return readAnchorSources(selected, Math.max(options.requestedContext || 0, options.maxContext || 0), options.signal);
+}
+
 function sourceBlock(anchor, source, radius) {
     if (!source || source.error || !source.lines.has(anchor.lineNo)) {
         return {
@@ -493,6 +479,7 @@ export async function expandGrepAnchorContextOutput({
     caseInsensitive = false,
     charBudget = GREP_CONTEXT_CHAR_BUDGET_DEFAULT,
     signal,
+    sources: sharedSources,
 }) {
     const anchors = rankAnchors(parseAnchors(allLines, {
         workDir,
@@ -523,7 +510,8 @@ export async function expandGrepAnchorContextOutput({
     const requested = Math.max(0, Math.floor(Number(requestedContext) || 0));
     const target = Math.max(requested, Math.max(0, Math.floor(Number(maxContext) || 0)));
     const budget = Math.max(512, Math.floor(Number(charBudget) || GREP_CONTEXT_CHAR_BUDGET_DEFAULT));
-    const sources = await readAnchorSources(window.selected, target, signal);
+    signal?.throwIfAborted();
+    const sources = sharedSources || await readAnchorSources(window.selected, target, signal);
     let selected = window.selected;
     let shown = window.shown;
     let omitted = window.omitted;

package/src/runtime/agent/orchestrator/tools/builtin/lib/grep-pattern-fanout.mjs

@@ -10,7 +10,7 @@ import { buildGrepRgArgs } from '../search-builders.mjs';
 import { runRgWindowedLines } from '../native-search-runner.mjs';
 import { statReachable } from '../fs-reachability.mjs';
 import { dedupeFanoutMatchLines, formatGrepOutput } from './grep-output.mjs';
-import { expandGrepAnchorContextOutput } from './grep-context-expander.mjs';
+import { expandGrepAnchorContextOutput, prepareGrepContextSources } from './grep-context-expander.mjs';
 import { markScopedCacheIncomplete } from '../../../session/cache/scoped-cache-outcome.mjs';
 
 export async function runGrepPatternFanout({
@@ -38,6 +38,7 @@ export async function runGrepPatternFanout({
     fileType,
     executeGrepTool,
 }) {
+    options.signal?.throwIfAborted();
     // ONE rg --files-with-matches pass over ALL patterns can scope the fallback
     // fan-out to candidate files. Start it lazily only after the combined pass
     // declines: the old speculative overlap left a whole-tree bulk scan running
@@ -80,7 +81,10 @@ export async function runGrepPatternFanout({
                 { offset: 0, limit: GREP_FANOUT_PREFILTER_FILE_CAP, summaryLimit: 0, bulkHint: true },
             );
             return pre.complete && !pre.partial ? pre.lines : null;
-        } catch { return null; }
+        } catch (err) {
+            options.signal?.throwIfAborted();
+            return null;
+        }
     };
     // Combined single-spawn fan-out: ONE rg run carrying every pattern
     // (-e p1 -e p2 …), then JS-side attribution of each matched line back
@@ -95,11 +99,16 @@ export async function runGrepPatternFanout({
     combined: if (process.env.MIXDOG_GREP_FANOUT_COMBINED !== '0'
         && !multilineMode
         && args['-o'] !== true
+        && !(beforeN > 0)
+        && !(afterN > 0)
         && showLineNumbers) {
         let jsRegexps;
         try {
             jsRegexps = patterns.map((p) => new RegExp(p, caseInsensitive ? 'i' : ''));
-        } catch { break combined; }
+        } catch {
+            options.signal?.throwIfAborted();
+            break combined;
+        }
         let preStat;
         try { preStat = await statReachable(grepResolvedPath); } catch { break combined; }
         if (!preStat.isDirectory()) break combined;
@@ -137,7 +146,10 @@ export async function runGrepPatternFanout({
                 { cwd: rgCwd, signal: options.signal },
                 { offset: 0, limit: combinedCap, summaryLimit: 0, bulkHint: combinedBulkHint },
             );
-        } catch { break combined; }
+        } catch {
+            options.signal?.throwIfAborted();
+            break combined;
+        }
         // Cap overflow (complete:false without partial) still falls back: the
         // per-pattern rescan restores correct per-pattern windows. Timeout and
         // scan-error partials keep their collected lines instead — the legacy
@@ -199,6 +211,12 @@ export async function runGrepPatternFanout({
         const noMatchBody = (p) => `(no matches) pattern=${JSON.stringify(p)} path=${searchPath}${globStr}; path exists (dir)`;
         const sections = [];
         const noMatchPatterns = [];
+        const sources = adaptive ? await prepareGrepContextSources(byPattern, {
+            workDir, rgSpawnCwd: rgCwd, grepResolvedPath, searchPath, outputMode,
+            filenameOmitted: false, headLimit, offset,
+            requestedContext: contextN, maxContext: GREP_AUTO_CONTEXT_LINES,
+            signal: options.signal,
+        }) : null;
         for (let i = 0; i < patterns.length; i++) {
             const p = patterns[i];
             const linesFor = byPattern[i];
@@ -224,8 +242,12 @@ export async function runGrepPatternFanout({
                     caseInsensitive,
                     charBudget: perBudget,
                     signal: options.signal,
+                    sources,
                 });
                 body = ctx.text || noMatchBody(p);
+                if (options.scopedCacheOutcome && (ctx.omitted > 0 || !ctx.sourceComplete)) {
+                    markScopedCacheIncomplete(options.scopedCacheOutcome);
+                }
             } else {
                 const post = offset > 0 ? linesFor.slice(offset) : linesFor;
                 const windowedLines = headLimit === Infinity ? post : post.slice(0, headLimit);
@@ -267,6 +289,7 @@ export async function runGrepPatternFanout({
     // completes under the cap, K patterns cost one repo walk plus K file-list
     // scans instead of K full walks. Zero candidates short-circuits.
     let fanoutCandidateFiles = null;
+    options.signal?.throwIfAborted();
     const fanoutPrefilterPromise = process.env.MIXDOG_GREP_FANOUT_PREFILTER !== '0'
         ? startFanoutPrefilter()
         : null;
@@ -295,6 +318,7 @@ export async function runGrepPatternFanout({
         try {
             return await executeGrepTool({ ...args, pattern: p }, workDir, executeChildBuiltinTool, readStateScope, subOptions);
         } catch (err) {
+            options.signal?.throwIfAborted();
             return `Error: ${err && err.message ? err.message : err}`;
         }
     };

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

@@ -52,12 +52,9 @@ function positiveTimeoutEnv(name, fallback) {
     const value = Number(process.env[name]);
     return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
-// Fuzzy find is a locate-the-path probe, not an inventory: it must answer in
-// about a second even when the caller points it at `/`. The old 20s walk hit
-// the read-only deadline first and returned NOTHING (observed live: six
-// whole-filesystem probes across six benchmark tasks, each burning a turn for
-// an error). At this cap the native search returns its ranked partial instead.
-const FIND_FUZZY_TIMEOUT_MS = positiveTimeoutEnv('MIXDOG_FIND_FUZZY_TIMEOUT_MS', 1_500);
+// Prefer a complete answer within the normal search budget. Do not enforce a
+// short response slice that makes ordinary discovery depend on another call.
+const FIND_FUZZY_TIMEOUT_MS = positiveTimeoutEnv('MIXDOG_FIND_FUZZY_TIMEOUT_MS', 17_500);
 // Same contract for name/glob find: bound the walk and the metadata pass, then
 // SAY the result is partial. The old 20s walk plus a 5s stat deadline silently
 // dropped every path whose stat missed the deadline, so a slow scope reported
@@ -596,26 +593,11 @@ export async function executeTreeTool(args, workDir, options = {}) {
 // Partial or timed-out passes say "no fuzzy match YET" and already tell the
 // caller to narrow, so they never pay for the second walk.
 export async function executeFuzzyFindTool(args, workDir, options = {}) {
-    const startedAt = performance.now();
-    const result = await runFuzzyFindPass(args, workDir, options);
-    const text = String(result ?? '');
-    if (!/^\(no fuzzy match for /.test(text)) return result;
-    if (args?.include_noise === true || options?._findNoiseWidened === true) return result;
-    if (performance.now() - startedAt > FIND_NOISE_WIDEN_BUDGET_MS) return result;
-    const widened = String(await runFuzzyFindPass(
-        { ...args, include_noise: true },
-        workDir,
-        { ...options, _findNoiseWidened: true },
-    ) ?? '');
-    if (!widened || /^\(no fuzzy match|^Error/.test(widened)) return result;
-    const hits = widened.split('\n').filter((line) => line && !line.startsWith('... [') && !line.startsWith('[')).length;
-    return `${text}\n[notice] ${hits} match${hits === 1 ? '' : 'es'} exist inside dependency/cache trees the default scan skips`
-        + ' — pass include_noise:true to list them.';
+    // A complete miss answers the requested scope. Do not start a second,
+    // broader walk merely to offer an optional dependency-tree hint.
+    return runFuzzyFindPass(args, workDir, options);
 }
 
-/** A miss cheaper than this earns the one widening retry above. */
-const FIND_NOISE_WIDEN_BUDGET_MS = 2_000;
-
 async function runFuzzyFindPass(args, workDir, options = {}) {
     const query = String(args.query ?? '').trim();
     if (!query) return 'Error: find requires query.';
@@ -757,7 +739,7 @@ async function runFuzzyFindPass(args, workDir, options = {}) {
             : '';
         return capFindResult([
             `(no fuzzy match yet for "${query}")`,
-            `... [native inventory was incomplete${scanErrorNote}; retry immediately to reuse its short lease, or narrow path/query for a complete result]`,
+            `... [native inventory was incomplete${scanErrorNote}; narrow path/query for a complete result]`,
         ].join('\n'));
     }
     return capFindResult('Error: native fuzzy search did not return a result.');

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

@@ -31,6 +31,18 @@ export function recordLocalSearchBackend(backend, durationMs, outcome) {
     addNumber(target, `${name}_ms`, durationMs);
 }
 
+export function recordNativeSearchFailure(error) {
+    const target = current();
+    if (!target) return;
+    if (!Array.isArray(target.native_failures)) target.native_failures = [];
+    if (target.native_failures.length < 3) {
+        target.native_failures.push({
+            code: String(error?.code || ''),
+            message: String(error?.message || error).slice(0, 300),
+        });
+    }
+}
+
 export function recordNativeSearchTiming(served) {
     const target = current();
     if (!target || !served || typeof served !== 'object') return;

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

@@ -34,7 +34,7 @@ const SEARCH_TIMEOUT_RECYCLE_WINDOW_MS = 30_000;
 const SEARCH_TIMEOUT_BURST_MS = 1_000;
 const FUZZY_INVENTORY_LEASE_MS = (() => {
   const configured = Number(process.env.MIXDOG_FIND_INVENTORY_LEASE_MS);
-  if (!Number.isFinite(configured) || configured < 0) return 3_000;
+  if (!Number.isFinite(configured) || configured < 0) return 0;
   return Math.min(30_000, Math.floor(configured));
 })();
 
@@ -709,9 +709,8 @@ export async function tryServeFuzzySearch(args, execOptions = {}) {
       limit: Math.max(1, Math.min(1_000, Math.floor(Number(args?.limit) || 25))),
       hidden: args?.hidden !== false,
       includeNoise: args?.includeNoise === true,
-      // A fuzzy deadline returns a truthful partial window. Keep the shared
-      // query-independent inventory briefly for an immediate retry, then let
-      // the native worker stop an idle broad walk instead of crawling forever.
+      // Background inventory continuation is explicit opt-in, not a
+      // prerequisite for a normal find response.
       ...(FUZZY_INVENTORY_LEASE_MS > 0
         ? { keepInventoryMs: FUZZY_INVENTORY_LEASE_MS }
         : {}),

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

@@ -1,6 +1,6 @@
 import { performance } from 'node:perf_hooks';
 import { tryServeSearch } from './native-search-client.mjs';
-import { recordLocalSearchBackend, recordNativeSearchTiming } from './local-search-telemetry.mjs';
+import { recordLocalSearchBackend, recordNativeSearchTiming, recordNativeSearchFailure } from './local-search-telemetry.mjs';
 
 function unavailable(argsList) {
     const error = new Error(`native search unavailable or unsupported for args: ${JSON.stringify(argsList)}`);
@@ -17,6 +17,7 @@ async function serve(argsList, execOptions, opts) {
         recordLocalSearchBackend('native', performance.now() - startedAt, 'hit');
         return result;
     } catch (error) {
+        recordNativeSearchFailure(error);
         // Unsupported request shapes are classified separately in telemetry,
         // but still throw: there is no alternate local-search backend.
         const code = String(error?.code || '');