mixdog 0.9.134 → 0.9.136

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

@@ -14,6 +14,13 @@ const _shellSyntaxCheat =
 const _shellToolRouting = process.platform === 'win32'
     ? 'Use read, NOT cat/Get-Content/head/tail; list, NOT ls/dir; find/glob, NOT find; grep, NOT grep/rg/Select-String; edit/apply_patch, NOT sed/awk/heredocs/echo/Set-Content.'
     : 'Use read, NOT cat/head/tail; list, NOT ls; find/glob, NOT find; grep, NOT grep/rg; edit/apply_patch, NOT sed/awk/heredocs/echo.';
+// CC parity: when background tasks are disabled for this process, drop the
+// run_in_background field from the schema entirely so the model cannot burn a
+// failure turn attempting it. Mirrors bash-tool's runtime guard, which stays
+// as defense in depth. Process-stable env, evaluated once at module load.
+const _shellBackgroundDisabled = /^(1|true|yes|on)$/i.test(
+    String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
+);
 
 export const BUILTIN_TOOLS = [
     {
@@ -77,16 +84,18 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Shell',
         annotations: { title: 'Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: `Run programs, runtime/state operations, calculations, transformations, file generation, and unsupported-format inspection. Avoid file operations covered by dedicated tools unless explicitly instructed or after verifying that a dedicated tool cannot do the job. ${_shellToolRouting} Commands start in the foreground; after 15s, a still-running command continues as a tracked task_id and completes by notification.`,
+        description: `Run programs, runtime/state operations, calculations, transformations, file generation, and unsupported-format inspection. Avoid file operations covered by dedicated tools unless explicitly instructed or after verifying that a dedicated tool cannot do the job. ${_shellToolRouting} Commands start in the foreground${_shellBackgroundDisabled ? '' : ' unless run_in_background is true'}; after 15s, a still-running foreground command continues as a tracked task_id and completes by notification.`,
         inputSchema: {
             type: 'object',
             properties: {
                 command: { type: 'string', description: `Command.${_shellSyntaxCheat}` },
-                timeout_ms: {
-                    type: 'integer',
-                    minimum: 0,
-                    description: 'Hard total deadline in milliseconds; omit or use 0 to allow unlimited runtime after task promotion.',
-                },
+                ...(_shellBackgroundDisabled ? {} : {
+                    run_in_background: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Start as a tracked background task immediately; use only when the result is not needed for the next step — completion arrives by notification. Default false.',
+                    },
+                }),
             },
             required: ['command'],
             additionalProperties: false,

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

@@ -191,6 +191,7 @@ 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;
@@ -233,6 +234,13 @@ export async function runResultCacheInFlight(key, compute, options = {}) {
             // 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 });
+            }
         }
     }
 }
@@ -351,9 +359,8 @@ export function getCachedReadOnlyStat(fullPath, loader = statSync, now = Date.no
     return stat;
 }
 
-export async function statPathsForMtime(paths, workDir, concurrency = Infinity, opts = {}) {
+async function visitPathStats(paths, workDir, concurrency, opts, visitor) {
     const items = Array.isArray(paths) ? paths : [];
-    const out = new Array(items.length);
     const now = Date.now();
     const inflight = new Map();
     let next = 0;
@@ -398,17 +405,31 @@ export async function statPathsForMtime(paths, workDir, concurrency = Infinity,
             if (index >= items.length) return;
             const p = items[index];
             const full = isAbsolute(p) ? p : resolveAgainstCwd(p, workDir);
+            let entry;
             try {
                 const stat = await resolveStat(full);
                 if (!stat) throw new Error('stat failed');
-                out[index] = { path: p, full, stat, size: stat.size, mtime: stat.mtimeMs, mtimeMs: stat.mtimeMs };
+                entry = { path: p, full, stat, size: stat.size, mtime: stat.mtimeMs, mtimeMs: stat.mtimeMs };
             } catch {
-                out[index] = { path: p, full, stat: null, size: 0, mtime: 0, mtimeMs: 0 };
+                entry = { path: p, full, stat: null, size: 0, mtime: 0, mtimeMs: 0 };
             }
+            visitor(entry, index);
         }
     }
     const workerCount = Math.min(Math.max(1, concurrency), Math.max(1, items.length));
     await Promise.all(Array.from({ length: workerCount }, worker));
+}
+
+export async function visitPathsForMtime(paths, workDir, concurrency = Infinity, opts = {}, visitor = () => {}) {
+    await visitPathStats(paths, workDir, concurrency, opts, visitor);
+}
+
+export async function statPathsForMtime(paths, workDir, concurrency = Infinity, opts = {}) {
+    const items = Array.isArray(paths) ? paths : [];
+    const out = new Array(items.length);
+    await visitPathStats(items, workDir, concurrency, opts, (entry, index) => {
+        out[index] = entry;
+    });
     return out;
 }
 

package/src/runtime/agent/orchestrator/tools/builtin/edit-sequential-occupation.test.mjs

@@ -8,7 +8,9 @@ import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { tryExecuteExternalToolAdapter } from './external-tool-adapters.mjs';
+import { executeBuiltinTool } from '../builtin.mjs';
 import { recordReadSnapshot } from './read-snapshot-runtime.mjs';
+import { executePatchTool } from '../patch.mjs';
 import { closeNativePatchServerForTests } from '../patch/native-server.mjs';
 
 const ANCHOR = '#if 0\n"""\n#endif';
@@ -57,6 +59,44 @@ test('count drift falls through to the strict ambiguity reject', async (t) => {
     assert.match(String(result), /current file excerpt lines/);
 });
 
+test('successful edit snapshot makes a follow-up read return unchanged', async (t) => {
+    const { dir, file } = makeTempFile('alpha\nkeep\n');
+    const sessionId = `edit-known-current-${process.pid}`;
+    t.after(() => { rmSync(dir, { recursive: true, force: true }); void closeNativePatchServerForTests?.(); });
+
+    const result = await tryExecuteExternalToolAdapter('edit', {
+        file_path: file,
+        old_string: 'alpha',
+        new_string: 'omega',
+    }, dir, { sessionId });
+    assert.match(String(result), /^Updated /);
+
+    const reread = await executeBuiltinTool('read', { path: file }, dir, { sessionId });
+    assert.equal(reread, `[file unchanged: ${file.replaceAll('\\', '/')}]`);
+});
+
+test('successful apply_patch snapshot makes a follow-up read return unchanged', async (t) => {
+    const { dir, file } = makeTempFile('alpha\nkeep\n');
+    const sessionId = `patch-known-current-${process.pid}`;
+    t.after(() => { rmSync(dir, { recursive: true, force: true }); void closeNativePatchServerForTests?.(); });
+
+    const result = await executePatchTool('apply_patch', {
+        base_path: dir,
+        patch: `*** Begin Patch
+*** Update File: poly.c
+@@
+-alpha
++omega
+ keep
+*** End Patch
+`,
+    }, dir, { sessionId });
+    assert.match(String(result), /^Applied 1 File \(Native\)/);
+
+    const reread = await executeBuiltinTool('read', { path: file }, dir, { sessionId });
+    assert.equal(reread, `[file unchanged: ${file.replaceAll('\\', '/')}]`);
+});
+
 test('stale read snapshot does not block a still-unique current old_string', async (t) => {
     const { dir, file } = makeTempFile('alpha\nkeep\n');
     const sessionId = `edit-stale-safe-${process.pid}`;

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

@@ -11,6 +11,7 @@ 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 { markScopedCacheIncomplete } from '../../../session/cache/scoped-cache-outcome.mjs';
 
 export async function runGrepPatternFanout({
     args,
@@ -77,7 +78,9 @@ export async function runGrepPatternFanout({
             const pre = await runRgWindowedLines(
                 prefilterArgs,
                 { cwd: preSpawnCwd, signal: options.signal },
-                { offset: 0, limit: GREP_FANOUT_PREFILTER_FILE_CAP, summaryLimit: 0 },
+                // Speculative whole-scope pass: bulk lane keeps it from
+                // competing with interactive searches for disk bandwidth.
+                { offset: 0, limit: GREP_FANOUT_PREFILTER_FILE_CAP, summaryLimit: 0, bulkHint: true },
             );
             return pre.complete && !pre.partial ? pre.lines : null;
         } catch { return null; }
@@ -130,15 +133,34 @@ export async function runGrepPatternFanout({
         });
         const perPatternWindow = headLimit === Infinity ? 300 : (offset + headLimit + 4);
         const combinedCap = Math.min(4000, Math.max(400, perPatternWindow * patterns.length));
+        // Unfiltered multi-pattern directory scans are the broad-scope shape
+        // that saturated the interactive pool; route them to the bulk lane.
+        const combinedBulkHint = normalizedGlobPatterns.length === 0 && !fileType;
         let streamed;
         try {
             streamed = await runRgWindowedLines(
                 combinedArgs,
                 { cwd: rgCwd, signal: options.signal },
-                { offset: 0, limit: combinedCap, summaryLimit: 0 },
+                { offset: 0, limit: combinedCap, summaryLimit: 0, bulkHint: combinedBulkHint },
             );
         } catch { break combined; }
-        if (!streamed.complete || streamed.partial) 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
+        // fallback would rescan the same scope from scratch and usually time
+        // out again, discarding everything the first pass already found.
+        if (streamed.partial ? streamed.lines.length === 0 : !streamed.complete) break combined;
+        const combinedPartial = streamed.partial === true;
+        const combinedPartialSuffix = !combinedPartial
+            ? ''
+            : streamed.timeout
+                ? '\n[warning] rg timed out; partial results shown. Narrow path/glob/pattern for a complete result.'
+                : streamed.rgStderr
+                    ? `\n[warning] rg exit 2 (partial results): ${String(streamed.rgStderr).trim().slice(0, 300)}`
+                    : '\n[warning] rg exit 2 (partial results)';
+        if (combinedPartial && options?.scopedCacheOutcome) {
+            markScopedCacheIncomplete(options.scopedCacheOutcome);
+        }
         const adaptive = contextN > 0 && !(beforeN > 0) && !(afterN > 0);
         const byPattern = patterns.map(() => []);
         const residual = [];
@@ -175,7 +197,7 @@ export async function runGrepPatternFanout({
                     filenameOmitted: false,
                     headLimit,
                     offset,
-                    totalKnown: true,
+                    totalKnown: !combinedPartial,
                     requestedContext: contextN,
                     maxContext: GREP_AUTO_CONTEXT_LINES,
                     patterns: [p],
@@ -190,7 +212,7 @@ export async function runGrepPatternFanout({
                 body = formatGrepOutput({
                     windowed: windowedLines,
                     totalWindowed: post.length,
-                    totalKnown: true,
+                    totalKnown: !combinedPartial,
                     headLimit,
                     offset,
                     outputMode,
@@ -211,14 +233,15 @@ export async function runGrepPatternFanout({
             sections.push(`# grep pattern:${JSON.stringify(p)}\n${dedupeFanoutMatchLines(body, seenCombined)}`);
         }
         if (noMatchPatterns.length > 0) {
-            sections.push(`(no matches) pattern=${JSON.stringify(noMatchPatterns)} path=${searchPath}${globStr}; path exists`);
+            // Under a partial scan a zero-hit pattern is NOT a proven no-match.
+            sections.push(`(no matches${combinedPartial ? ' in partial results' : ''}) pattern=${JSON.stringify(noMatchPatterns)} path=${searchPath}${globStr}; path exists`);
         }
         if (residual.length > 0) {
             // Rust/JS regex divergence or --max-columns truncation left
             // matches no pattern claimed; surface them rather than drop.
             sections.push(`# grep (unattributed matches)\n${residual.slice(0, 40).join('\n')}`);
         }
-        return patternCapNote + sections.join('\n\n');
+        return patternCapNote + sections.join('\n\n') + combinedPartialSuffix;
     }
     // Prefilter result (started above, overlapped with the combined
     // attempt): when it completed under the cap, each per-pattern grep

package/src/runtime/agent/orchestrator/tools/builtin/lib/shell-job-records.mjs

@@ -33,7 +33,7 @@ function dataDir() {
         || join(process.env.MIXDOG_HOME || join(homedir(), '.mixdog'), 'data');
 }
 
-function pidAlive(pid) {
+export function pidAlive(pid) {
     if (!Number.isInteger(pid) || pid <= 0) return false;
     try { process.kill(pid, 0); return true; }
     catch (error) { return error?.code === 'EPERM'; } // EPERM = alive, not ours

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

@@ -37,7 +37,7 @@ import {
     TOOL_OUTPUT_MAX_BYTES,
 } from './tool-output-limit.mjs';
 import { runRg, runRgWindowedLines } from './native-search-runner.mjs';
-import { tryServeFuzzySearch } from './native-search-client.mjs';
+import { tryServeFuzzySearch, tryServeListMetadata } from './native-search-client.mjs';
 import { fuzzyRankMulti, prepareFuzzyItems, splitFuzzyQueryTokens } from './fuzzy-match.mjs';
 import {
     recordLocalSearchBackend,
@@ -129,6 +129,95 @@ function _metaModeOctal(mode) {
     return (mode & 0o7777).toString(8).padStart(3, '0');
 }
 
+async function listMetadataForPaths(paths, workDir, options = {}) {
+    if (!Array.isArray(paths) || paths.length === 0) return [];
+    const nativeImpl = typeof options?.__tryServeListMetadata === 'function'
+        ? options.__tryServeListMetadata
+        : tryServeListMetadata;
+    try {
+        const entries = await nativeImpl(paths, {
+            cwd: workDir,
+            signal: options?.signal || options?.abortSignal || null,
+            timeout: 5_000,
+        });
+        if (Array.isArray(entries) && entries.length === paths.length) {
+            return entries.map((entry, index) => ({
+                fullPath: paths[index],
+                type: entry && !entry.error ? String(entry.type || '') : '',
+                stat: entry && !entry.error ? { mode: Number(entry.mode) || 0 } : null,
+                size: entry && !entry.error ? Math.max(0, Number(entry.size) || 0) : 0,
+                mtimeMs: entry && !entry.error ? Math.max(0, Number(entry.mtimeMs) || 0) : 0,
+            }));
+        }
+    } catch {
+        // Older/unavailable native helpers preserve the existing JS fallback.
+    }
+    return lstatPathsForMtime(paths, workDir, 64, { deadlineMs: 5000 });
+}
+
+async function tryNativeDeepListRows({
+    fullPath,
+    workDir,
+    depth,
+    hidden,
+    includeNoise,
+    signal,
+    options,
+}) {
+    if (depth <= 1 || typeof options?.readdirImpl === 'function') return null;
+    const rgArgs = ['--files', '--directories', '--no-ignore', '--no-require-git'];
+    if (hidden) rgArgs.push('--hidden');
+    rgArgs.push('--max-depth', String(depth));
+    if (!includeNoise) {
+        for (const glob of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', glob);
+    }
+    rgArgs.push('--', fullPath);
+    try {
+        const served = await runRgWindowedLines(
+            rgArgs,
+            { cwd: workDir, timeout: LIST_WALK_TIMEOUT_MS, signal },
+            { offset: 0, limit: LIST_ABSOLUTE_CAP, nativeInventory: true },
+        );
+        if (served?.complete !== true || served?.partial === true || !Array.isArray(served?.lines)) {
+            return null;
+        }
+        const paths = Array.from(new Set(served.lines.map((line) => (
+            isAbsolute(line) ? line : resolveAgainstCwd(line, workDir)
+        )))).filter((path) => path !== fullPath);
+        const metadata = await listMetadataForPaths(paths, workDir, options);
+        if (!Array.isArray(metadata) || metadata.length !== paths.length) return null;
+        const rows = paths.map((path, index) => {
+            const item = metadata[index] || {};
+            const type = ['file', 'dir', 'symlink', 'other'].includes(item.type)
+                ? item.type
+                : (item.stat?.isDirectory?.()
+                    ? 'dir'
+                    : (item.stat?.isFile?.()
+                        ? 'file'
+                        : (item.stat?.isSymbolicLink?.() ? 'symlink' : 'other')));
+            return {
+                path,
+                type,
+                size: Number(item.size) || 0,
+                mtimeMs: Number(item.mtimeMs) || 0,
+                mode: Number(item.mode) || 0,
+                fullPath: path,
+            };
+        });
+        return {
+            rows,
+            walkResult: {
+                entriesVisited: rows.length,
+                directoriesVisited: rows.filter((row) => row.type === 'dir').length,
+                aborted: false,
+                nativeInventory: true,
+            },
+        };
+    } catch {
+        return null;
+    }
+}
+
 export async function executeListTool(args, workDir, options = {}) {
     if (typeof args.fuzzy === 'string' && args.fuzzy.length > 0) {
         return executeFuzzyFindTool({ ...args, query: args.fuzzy }, workDir, options);
@@ -216,37 +305,56 @@ export async function executeListTool(args, workDir, options = {}) {
     let truncatedByCap = false;
     const walkWarnings = [];
     const walkDeadline = Date.now() + LIST_WALK_TIMEOUT_MS;
-    const walkResult = await walkDir(fullPath, {
+    const nativeDeep = await tryNativeDeepListRows({
+        fullPath,
+        workDir,
+        depth,
         hidden,
-        maxDepth: depth,
-        excludeDirNames: includeNoise ? null : NOISE_DIR_NAMES,
+        includeNoise,
         signal: options.signal,
-        readdirImpl: options.readdirImpl,
-        onWarn: (dir, error, context) => walkWarnings.push({ dir, error, root: Boolean(context?.root) }),
-        visit: (ent, entPath) => {
-            if (Date.now() > walkDeadline) { truncatedByCap = true; return false; }
-            const isDir = ent.isDirectory();
-            const isFile = ent.isFile();
-            if (typeFilter === 'file' && !isFile) return;
-            if (typeFilter === 'dir' && !isDir) return;
-            const entType = isDir ? 'dir' : (isFile ? 'file' : (ent.isSymbolicLink() ? 'symlink' : 'other'));
-            rows.push({
-                path: entPath,
-                type: entType,
-                size: 0,
-                mtimeMs: 0,
-                mode: 0,
-                fullPath: entPath,
-            });
-            if (rows.length >= LIST_ABSOLUTE_CAP) {
-                truncatedByCap = true;
-                return false;
-            }
-            // Pre-sort truncation removed: a global name sort needs all
-            // candidates collected before slicing, otherwise the visible
-            // window depends on traversal order rather than sort order.
-        },
+        options,
     });
+    let walkResult;
+    if (nativeDeep) {
+        for (const row of nativeDeep.rows) {
+            if (typeFilter === 'file' && row.type !== 'file') continue;
+            if (typeFilter === 'dir' && row.type !== 'dir') continue;
+            rows.push(row);
+        }
+        walkResult = nativeDeep.walkResult;
+    } else {
+        walkResult = await walkDir(fullPath, {
+            hidden,
+            maxDepth: depth,
+            excludeDirNames: includeNoise ? null : NOISE_DIR_NAMES,
+            signal: options.signal,
+            readdirImpl: options.readdirImpl,
+            onWarn: (dir, error, context) => walkWarnings.push({ dir, error, root: Boolean(context?.root) }),
+            visit: (ent, entPath) => {
+                if (Date.now() > walkDeadline) { truncatedByCap = true; return false; }
+                const isDir = ent.isDirectory();
+                const isFile = ent.isFile();
+                if (typeFilter === 'file' && !isFile) return;
+                if (typeFilter === 'dir' && !isDir) return;
+                const entType = isDir ? 'dir' : (isFile ? 'file' : (ent.isSymbolicLink() ? 'symlink' : 'other'));
+                rows.push({
+                    path: entPath,
+                    type: entType,
+                    size: 0,
+                    mtimeMs: 0,
+                    mode: 0,
+                    fullPath: entPath,
+                });
+                if (rows.length >= LIST_ABSOLUTE_CAP) {
+                    truncatedByCap = true;
+                    return false;
+                }
+                // Pre-sort truncation removed: a global name sort needs all
+                // candidates collected before slicing, otherwise the visible
+                // window depends on traversal order rather than sort order.
+            },
+        });
+    }
     throwIfDirectoryWalkAborted(options.signal, walkResult, 'list walk');
     const rootFailure = walkWarnings.find((warning) => warning.root);
     if (rootFailure) {
@@ -257,9 +365,9 @@ export async function executeListTool(args, workDir, options = {}) {
     }
     recordShardDirectoryReadSuccess();
 
-    if (needsGlobalStat && rows.length > 0) {
+    if (!nativeDeep && needsGlobalStat && rows.length > 0) {
         // lstat: symlinks should report own metadata, not the target's.
-        const stats = await lstatPathsForMtime(rows.map((row) => row.fullPath), workDir, 64, { deadlineMs: 5000 });
+        const stats = await listMetadataForPaths(rows.map((row) => row.fullPath), workDir, options);
         for (let i = 0; i < rows.length; i++) {
             const item = stats[i];
             if (!item?.stat) continue;
@@ -281,8 +389,8 @@ export async function executeListTool(args, workDir, options = {}) {
     // stat just the visible window (a global stat already ran for
     // mtime/size sorts); `sliced` shares row objects with `rows`, so the
     // assignments land on the rendered entries.
-    if (meta && !needsGlobalStat && sliced.length > 0) {
-        const stats = await lstatPathsForMtime(sliced.map((row) => row.fullPath), workDir, 64, { deadlineMs: 5000 });
+    if (!nativeDeep && meta && !needsGlobalStat && sliced.length > 0) {
+        const stats = await listMetadataForPaths(sliced.map((row) => row.fullPath), workDir, options);
         for (let i = 0; i < sliced.length; i++) {
             const item = stats[i];
             if (!item?.stat) continue;
@@ -940,15 +1048,11 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     const nativeFuzzyImpl = typeof options?.__tryServeFuzzySearch === 'function'
         ? options.__tryServeFuzzySearch
         : tryServeFuzzySearch;
-    // Space-separated fragments AND-match one path. The native fuzzy matcher
-    // scores the query as ONE string (paths contain no spaces, so it would
-    // always miss); multi-fragment queries go straight to the broad
-    // enumeration + fuzzyRankMulti path below.
+    // Space-separated fragments AND-match one path. The native matcher handles
+    // every token independently and sums exact per-token scores.
     const queryTokens = splitFuzzyQueryTokens(query);
-    const multiToken = queryTokens.length > 1;
     if (
         headLimit > 0
-        && !multiToken
         && (
             typeof options?.__runRg !== 'function'
             || typeof options?.__tryServeFuzzySearch === 'function'
@@ -978,6 +1082,9 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
                     ? [`(no fuzzy match for "${query}")`]
                     : [...matches, ...(hasMore ? [`... (top ${headLimit}; raise limit for more)`] : [])];
                 const result = lines.join('\n');
+                if (served.cacheSafe !== false) {
+                    cacheSet(cacheKey, result, { scopes: [fullPath] });
+                }
                 if (typeof options?.onProgress === 'function') {
                     try { options.onProgress(`${matches.length} candidates`); } catch {}
                 }
@@ -1333,8 +1440,10 @@ export async function executeFindFilesTool(args, workDir, options = {}) {
     if (options?.scopedCacheOutcome && (truncatedByCap || windowed.length > sliced.length)) {
         markScopedCacheIncomplete(options.scopedCacheOutcome);
     }
-    const findIncomplete = truncatedByCap || windowed.length > sliced.length;
-    if (!findIncomplete) {
+    // A bounded page is still an exact result because offset/limit are keyed
+    // and watcher invalidation covers the scope. Only the absolute safety cap
+    // makes the computation incomplete.
+    if (!truncatedByCap) {
         cacheSet(cacheKey, out, { scopes: [fullPath] });
     }
     return out;

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

@@ -37,6 +37,10 @@ export function recordNativeSearchTiming(served) {
     target[`native_${requestClass}_requests`] = (Number(target[`native_${requestClass}_requests`]) || 0) + 1;
     addNumber(target, `native_${requestClass}_queue_ms`, served.queueMs);
     addNumber(target, `native_${requestClass}_handler_ms`, served.handlerMs);
+    if (requestClass === 'fuzzy') {
+        addNumber(target, 'native_fuzzy_inventory_ms', served.inventoryMs);
+        addNumber(target, 'native_fuzzy_rank_ms', served.rankMs);
+    }
 }
 
 export function recordLocalSearchCacheHit(layer) {

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

@@ -42,6 +42,7 @@ function codedError(code, message, cause = null) {
 
 function requestKind(request) {
   if (request?.processSnapshot) return 'process snapshot';
+  if (request?.listMetadata) return 'list metadata';
   if (request?.fuzzy != null) return 'fuzzy';
   return request?.args?.includes?.('--files') ? 'file inventory' : 'content';
 }
@@ -194,6 +195,31 @@ function _teardown(error, { countFailure = true, detail = '' } = {}) {
   try { server.child.kill(); } catch {}
 }
 
+export async function shutdownNativeSearchServer(reason = 'process-exit', timeoutMs = 1_000) {
+  const server = _server;
+  if (!server) return true;
+  const child = server.child;
+  const exited = new Promise((resolve) => {
+    child.once('exit', () => resolve(true));
+    child.once('error', () => resolve(true));
+  });
+  try { child.stdin?.end?.(); } catch {}
+  _teardown(new Error(`native search server shutdown (${reason})`), { countFailure: false });
+  _warmPromise = null;
+  let timer;
+  const stopped = await Promise.race([
+    exited,
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve(false), Math.max(10, Number(timeoutMs) || 1_000));
+    }),
+  ]);
+  if (timer) clearTimeout(timer);
+  if (!stopped) {
+    try { child.kill('SIGKILL'); } catch {}
+  }
+  return stopped;
+}
+
 export function _bindNativeSearchServerLifecycle(child, { onError, onExit } = {}) {
   if (!child?.on) return;
   child.on('error', onError);
@@ -541,6 +567,8 @@ export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
       : 0,
     deadlineMs: softDeadlineMs(remaining),
     keepWarm: opts.keepWarm === true,
+    ...(opts.bulkHint === true ? { bulkHint: true } : {}),
+    ...(opts.mtimeTopK === true ? { mtimeTopK: true } : {}),
   });
   let response = await requestNativeWithRestart(buildRequest, execOptions, deadlineMs);
   // Deadline-swallow defense (binaries before the serve_search response-level
@@ -612,6 +640,7 @@ export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
     totalSeen: Math.max(0, Math.floor(Number(response.totalSeen) || 0)),
     partial: response.partial === true,
     timeout: response.timeout === true,
+    filesScanned: Math.max(0, Math.floor(Number(response.filesScanned) || 0)),
     // Unreadable/half-read files the native scanner skipped: route the count
     // through the existing rg-exit-2 partial phrasing in search-tool.mjs so
     // the model sees WHY the result may be missing matches.
@@ -687,11 +716,42 @@ export async function tryServeFuzzySearch(args, execOptions = {}) {
     cacheSafe: response.cacheSafe !== false,
     queueMs: Math.max(0, Number(response.queueMs) || 0),
     handlerMs: Math.max(0, Number(response.handlerMs) || 0),
+    inventoryMs: Math.max(0, Number(response.inventoryMs) || 0),
+    rankMs: Math.max(0, Number(response.rankMs) || 0),
     requestClass: response.class === 'fuzzy' ? 'fuzzy' : 'bulk',
     served: true,
   };
 }
 
+export async function tryServeListMetadata(paths, execOptions = {}) {
+  if (process.env.MIXDOG_SEARCH_SERVER === '0') return null;
+  const list = Array.isArray(paths) ? paths.map(String) : [];
+  if (list.length === 0) return [];
+  if (list.length > 50_000) {
+    throw codedError('NATIVE_SEARCH_UNSUPPORTED', 'list metadata request exceeds 50000 paths');
+  }
+  const callerTimeoutMs = Number(execOptions.timeout);
+  const deadlineMs = Number.isFinite(callerTimeoutMs) && callerTimeoutMs > 0
+    ? Math.min(callerTimeoutMs, REQUEST_TIMEOUT_MS)
+    : Math.min(5_000, REQUEST_TIMEOUT_MS);
+  const response = await requestNativeWithRestart(
+    (server) => ({
+      id: ++server.sequence,
+      cwd: String(execOptions.cwd || process.cwd()),
+      listMetadata: list,
+    }),
+    execOptions,
+    deadlineMs,
+  );
+  if (response?.error) {
+    throw codedError('NATIVE_SEARCH_ERROR', String(response.error));
+  }
+  if (!Array.isArray(response?.entries) || response.entries.length !== list.length) {
+    throw unavailableError();
+  }
+  return response.entries;
+}
+
 export function _resetNativeSearchClientForTest() {
   _teardown(new Error('test reset'), { countFailure: false });
   _binaryPath = undefined;

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

@@ -14,7 +14,10 @@ import {
 import { extractOoxmlText } from './read-office-files.mjs';
 
 function snapshotBodyWasReturnedByRead(snapshot) {
-    return String(snapshot?.source || '').startsWith('read');
+    const source = String(snapshot?.source || '');
+    return source.startsWith('read')
+        || source === 'edit'
+        || source.startsWith('apply_patch_');
 }
 
 // BOM-only read-encoding detection. Mirrors CC fileRead.ts:34
@@ -272,6 +275,20 @@ export async function executeSingleReadTool(args, workDir, readStateScope, optio
         const _safeMsg = normalizeErrorMessage(_rawMsg, workDir);
         return `Error: ${_safeMsg}${hint}`;
     }
+    // A successful edit/apply_patch leaves a session-scoped full-file snapshot.
+    // The model already knows the resulting body from the prior body plus its
+    // mutation, so a follow-up Read needs only the stat tuple to prove that no
+    // external write landed afterward. Do not reopen/hash the file body merely
+    // to return the unchanged stub.
+    const _mutationSnapshot = readStateScope ? getReadSnapshot(fullPath, readStateScope) : null;
+    const _mutationSource = String(_mutationSnapshot?.source || '');
+    if (
+        (_mutationSource === 'edit' || _mutationSource.startsWith('apply_patch_'))
+        && statMatchesSnapshot(st, _mutationSnapshot)
+        && snapshotCoversFullFile(_mutationSnapshot)
+    ) {
+        return `[file unchanged: ${normalizeOutputPath(filePath)}]`;
+    }
     // MEDIA-WINS: .pdf/.ipynb dispatch runs BEFORE any cache/snapshot fast
     // path. A media file previously read as text can carry a stale result-
     // cache or read-snapshot entry; returning that cached TEXT instead of the