mixdog 0.9.135 → 0.9.136

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';
 }
@@ -567,6 +568,7 @@ export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
     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
@@ -638,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.
@@ -713,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

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,8 +391,11 @@ 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'];
         // Explicit literal basenames (no glob magic in the final segment)
@@ -391,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,
@@ -440,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) {
@@ -454,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]' : '')
@@ -507,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'],
+    );
+});