mixdog 0.9.38 → 0.9.39

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

@@ -25,62 +25,69 @@ function isHump(prevCh, ch) {
         && /[A-Z]/.test(ch);
 }
 
-/**
- * @param {string} query   user query (partial name)
- * @param {string} str     candidate path (relative)
- * @returns {number|null}  score, or null if `query` is not a subsequence
- */
-export function fuzzyScore(query, str) {
+function prepareFuzzyScore(query) {
     if (!query) return 0;
     const normalizedQuery = String(query).replace(/[\/\\_.\-\s]+/g, '');
     if (!normalizedQuery) return 0;
     const q = normalizedQuery.toLowerCase();
-    const s = str.toLowerCase();
     const qlen = q.length;
-    const slen = s.length;
-    if (qlen === 0) return 0;
-    if (qlen > slen) return null;
-
-    const lastSep = Math.max(str.lastIndexOf('/'), str.lastIndexOf('\\'));
-
-    let score = 0;
-    let si = 0;
-    let prevMatch = -2;
-    let firstMatchIdx = -1;
-
-    for (let qi = 0; qi < qlen; qi++) {
-        const qc = q[qi];
-        let found = -1;
-        for (let k = si; k < slen; k++) {
-            if (s[k] === qc) { found = k; break; }
-        }
-        if (found === -1) return null;
-        if (firstMatchIdx === -1) firstMatchIdx = found;
+    return (str) => {
+        const s = str.toLowerCase();
+        const slen = s.length;
+        if (qlen === 0) return 0;
+        if (qlen > slen) return null;
 
-        score += 1; // base point per matched char
+        const lastSep = Math.max(str.lastIndexOf('/'), str.lastIndexOf('\\'));
 
-        if (found === prevMatch + 1) score += 5; // contiguous run
+        let score = 0;
+        let si = 0;
+        let prevMatch = -2;
+        let firstMatchIdx = -1;
 
-        const prevCh = found > 0 ? str[found - 1] : undefined;
-        if (prevCh === undefined || isBoundaryChar(prevCh) || isHump(prevCh, str[found])) {
-            score += 8; // word-boundary start
-        }
+        for (let qi = 0; qi < qlen; qi++) {
+            const qc = q[qi];
+            let found = -1;
+            for (let k = si; k < slen; k++) {
+                if (s[k] === qc) { found = k; break; }
+            }
+            if (found === -1) return null;
+            if (firstMatchIdx === -1) firstMatchIdx = found;
 
-        if (str[found] === normalizedQuery[qi]) score += 1; // exact-case tie-break
+            score += 1; // base point per matched char
 
-        prevMatch = found;
-        si = found + 1;
-    }
+            if (found === prevMatch + 1) score += 5; // contiguous run
 
-    // Matches that begin inside the basename (after the last separator) are far
-    // more relevant than ones buried in directory components.
-    if (firstMatchIdx > lastSep) score += 10;
+            const prevCh = found > 0 ? str[found - 1] : undefined;
+            if (prevCh === undefined || isBoundaryChar(prevCh) || isHump(prevCh, str[found])) {
+                score += 8; // word-boundary start
+            }
 
-    // Mild pulls: shorter candidates and earlier first matches rank higher.
-    score -= Math.floor(slen / 16);
-    score -= Math.floor(firstMatchIdx / 8);
+            if (str[found] === normalizedQuery[qi]) score += 1; // exact-case tie-break
 
-    return score;
+            prevMatch = found;
+            si = found + 1;
+        }
+
+        // Matches that begin inside the basename (after the last separator) are far
+        // more relevant than ones buried in directory components.
+        if (firstMatchIdx > lastSep) score += 10;
+
+        // Mild pulls: shorter candidates and earlier first matches rank higher.
+        score -= Math.floor(slen / 16);
+        score -= Math.floor(firstMatchIdx / 8);
+
+        return score;
+    };
+}
+
+/**
+ * @param {string} query   user query (partial name)
+ * @param {string} str     candidate path (relative)
+ * @returns {number|null}  score, or null if `query` is not a subsequence
+ */
+export function fuzzyScore(query, str) {
+    const scorer = prepareFuzzyScore(query);
+    return typeof scorer === 'function' ? scorer(str) : scorer;
 }
 
 // Below this per-query-char score, a subsequence-only match (query chars in
@@ -97,6 +104,53 @@ function normalizeForContains(s) {
     return String(s || '').toLowerCase().replace(/[\/\\_.\-\s]+/g, '');
 }
 
+function compareRanked(a, b) {
+    return (b.score - a.score)
+        || (a.item.path < b.item.path ? -1 : a.item.path > b.item.path ? 1 : 0);
+}
+
+function compareRankedNodes(a, b) {
+    return compareRanked(a.entry, b.entry) || (a.ordinal - b.ordinal);
+}
+
+function siftDownRankedHeap(heap, index) {
+    for (;;) {
+        const left = index * 2 + 1;
+        const right = left + 1;
+        let worst = index;
+        if (left < heap.length && compareRankedNodes(heap[left], heap[worst]) > 0) worst = left;
+        if (right < heap.length && compareRankedNodes(heap[right], heap[worst]) > 0) worst = right;
+        if (worst === index) return;
+        const node = heap[index];
+        heap[index] = heap[worst];
+        heap[worst] = node;
+        index = worst;
+    }
+}
+
+// Keep the worst retained candidate at index zero. The ordinal completes the
+// public comparator only for heap bookkeeping, preserving stable-sort behavior
+// for duplicate score/path entries.
+function retainTopRanked(heap, entry, ordinal, limit) {
+    const node = { entry, ordinal };
+    if (heap.length < limit) {
+        heap.push(node);
+        for (let index = heap.length - 1; index > 0;) {
+            const parent = Math.floor((index - 1) / 2);
+            if (compareRankedNodes(heap[index], heap[parent]) <= 0) break;
+            const parentNode = heap[parent];
+            heap[parent] = heap[index];
+            heap[index] = parentNode;
+            index = parent;
+        }
+        return;
+    }
+    if (compareRankedNodes(node, heap[0]) < 0) {
+        heap[0] = node;
+        siftDownRankedHeap(heap, 0);
+    }
+}
+
 /**
  * Rank candidates by fuzzy score against `query`, dropping non-matches.
  * @param {string} query
@@ -106,30 +160,41 @@ function normalizeForContains(s) {
  */
 export function fuzzyRank(query, items, limit = 0) {
     const normQuery = normalizeForContains(query);
+    const score = prepareFuzzyScore(query);
     // Floor scales with query length: a scattered subsequence earns ~1 point
     // per char, while any contiguous run (+5/char) or word-boundary hit
     // (+8) pushes a genuine match well past 4/char.
     const floor = normQuery.length * SUBSEQUENCE_MIN_PER_CHAR;
     const scored = [];
-    for (const item of items) {
+    // Preserve slice's legacy coercion behavior for non-integer public callers;
+    // normal tool limits are positive integers and take the bounded fast path.
+    const bounded = Number.isInteger(limit) && limit > 0;
+    for (let ordinal = 0; ordinal < items.length; ordinal++) {
+        const item = items[ordinal];
         const p = String(item.path || '');
-        const pathScore = fuzzyScore(query, p);
-        const base = p.split(/[\\/]/).pop() || '';
-        const baseScore = fuzzyScore(query, base);
+        const lastSep = Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
+        const base = p.slice(lastSep + 1);
+        const pathScore = typeof score === 'function' ? score(p) : score;
+        const baseScore = typeof score === 'function' ? score(base) : score;
         const sc = Math.max(pathScore ?? -Infinity, baseScore === null ? -Infinity : baseScore + 40);
         if (!Number.isFinite(sc)) continue;
         // Strong match: the query (separators stripped) is a contiguous
         // substring of the basename or the full path. These ALWAYS pass so an
         // exact substring/basename hit can never be starved out as noise.
-        const strong = normQuery.length > 0
-            && (normalizeForContains(base).includes(normQuery)
-                || normalizeForContains(p).includes(normQuery));
+        const strong = normQuery.length > 0 && normalizeForContains(p).includes(normQuery);
         // Otherwise it is subsequence-only: keep it only if it clears the
         // per-char floor. Weak scattered matches (the pgAdmin-style junk that
         // merely contains the query chars in order) fall below it and drop out.
         if (!strong && sc < floor) continue;
-        scored.push({ item, score: sc });
+        const entry = { item, score: sc };
+        if (bounded) retainTopRanked(scored, entry, ordinal, limit);
+        else scored.push(entry);
+    }
+    if (!bounded) {
+        scored.sort(compareRanked);
+        return limit > 0 ? scored.slice(0, limit) : scored;
     }
-    scored.sort((a, b) => (b.score - a.score) || (a.item.path < b.item.path ? -1 : a.item.path > b.item.path ? 1 : 0));
-    return limit > 0 ? scored.slice(0, limit) : scored;
+    return scored
+        .sort(compareRankedNodes)
+        .map(({ entry }) => entry);
 }

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

@@ -20,6 +20,7 @@ import {
     cacheGet,
     cacheSet,
     getCachedReadOnlyStat,
+    statCacheSet,
     statPathsForMtime,
     lstatPathsForMtime,
     registerCacheInvalidationListener,
@@ -92,23 +93,41 @@ export async function executeListTool(args, workDir, options = {}) {
             // wall-clock cost changes. Concurrency is capped so a 10-path batch
             // cannot exhaust the child-spawn / FS-handle budget.
             const LIST_FANOUT_CONCURRENCY = 4;
-            const bodies = new Array(targets.length);
+            // Collapse semantic-duplicate targets: two spellings that resolve to
+            // the same directory (e.g. `foo` and `./foo`) are stat'd/walked ONCE.
+            // Each caller label keeps its own `# list <p>` section reusing the
+            // shared body, so output stays byte-identical — only the duplicate
+            // concurrent walk is eliminated.
+            const resolveKey = (p) => {
+                try { return normalizeOutputPath(resolveAgainstCwd(normalizeInputPath(p), workDir)); }
+                catch { return p; }
+            };
+            const keyByIndex = new Array(targets.length);
+            const uniqueKeys = [];
+            const repByKey = new Map();
+            for (let i = 0; i < targets.length; i++) {
+                const k = resolveKey(targets[i]);
+                keyByIndex[i] = k;
+                if (!repByKey.has(k)) { repByKey.set(k, targets[i]); uniqueKeys.push(k); }
+            }
+            const bodyByKey = new Map();
             let cursor = 0;
             const runWorker = async () => {
                 for (;;) {
                     const i = cursor++;
-                    if (i >= targets.length) return;
+                    if (i >= uniqueKeys.length) return;
+                    const k = uniqueKeys[i];
                     try {
-                        bodies[i] = await executeListTool({ ...args, path: targets[i] }, workDir, options);
+                        bodyByKey.set(k, await executeListTool({ ...args, path: repByKey.get(k) }, workDir, options));
                     } catch (err) {
-                        bodies[i] = `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+                        bodyByKey.set(k, `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`);
                     }
                 }
             };
             await Promise.all(
-                Array.from({ length: Math.min(LIST_FANOUT_CONCURRENCY, targets.length) }, runWorker),
+                Array.from({ length: Math.min(LIST_FANOUT_CONCURRENCY, uniqueKeys.length) }, runWorker),
             );
-            const sections = targets.map((p, i) => `# list ${p}\n${bodies[i]}`);
+            const sections = targets.map((p, i) => `# list ${p}\n${bodyByKey.get(keyByIndex[i])}`);
             if (capped) sections.push(`... [capped at 10 of ${list.length} paths]`);
             return sections.join('\n\n');
         }
@@ -150,8 +169,12 @@ export async function executeListTool(args, workDir, options = {}) {
     });
     const cached = cacheGet(cacheKey);
     if (cached !== null) return cached;
-    try { await assertPathReachable(fullPath); }
+    let _preStat;
+    try { _preStat = await assertPathReachable(fullPath); }
     catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    // Feed the reachability preflight's stat into the cache so the root is
+    // stat'd once instead of immediately re-stat'd by getCachedReadOnlyStat.
+    if (_preStat) statCacheSet(fullPath, _preStat);
     let st;
     try { st = getCachedReadOnlyStat(fullPath); }
     catch (err) {
@@ -283,8 +306,10 @@ export async function executeTreeTool(args, workDir, options = {}) {
     });
     const cached = cacheGet(cacheKey);
     if (cached !== null) return cached;
-    try { await assertPathReachable(fullPath); }
+    let _preStat;
+    try { _preStat = await assertPathReachable(fullPath); }
     catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    if (_preStat) statCacheSet(fullPath, _preStat);
     let st;
     try { st = getCachedReadOnlyStat(fullPath); }
     catch (err) {
@@ -357,7 +382,7 @@ export async function executeTreeTool(args, workDir, options = {}) {
 
 // ── Broad-enumeration cache (shared `rg --files` sweep) ──────────────────
 // A `rg --files` sweep of a root depends ONLY on (root, hidden, depth,
-// includeNoise) — NOT on the per-query narrowing. Yet both the fuzzy-find
+// includeNoise, ignoreMode) — NOT on the per-query narrowing. Yet both the fuzzy-find
 // broad pass and the find_files broad fast path re-run that full sweep for
 // every query item AND for every concurrent caller (measured 1-4s each when
 // 8 explorer sub-sessions hit the same root). Cache the PARSED file list per
@@ -387,8 +412,8 @@ function findEnumTtlMs() {
     return Math.floor(n); // 0 = disabled
 }
 
-function findEnumKey({ root, hidden, depth, includeNoise }) {
-    return `${root}\u0000${hidden ? 1 : 0}\u0000${depth ?? ''}\u0000${includeNoise ? 1 : 0}`;
+function findEnumKey({ root, hidden, depth, includeNoise, ignoreMode }) {
+    return `${root}\u0000${hidden ? 1 : 0}\u0000${depth ?? ''}\u0000${includeNoise ? 1 : 0}\u0000${ignoreMode}`;
 }
 
 // Parse `rg --files` stdout into the same normalized relative-path list both
@@ -405,11 +430,12 @@ function parseRgFileList(stdout) {
 // Run (or reuse) the broad `rg --files` sweep for a root. Returns
 // { files, truncated, partial }. The returned `files` array is SHARED — callers
 // must treat it as read-only. `rgArgs` must be the broad-pass args (no per-query
-// narrowing); the cache key is the 4 dims only, so any caller producing an
+// narrowing); the cache key includes every enumeration-affecting dimension, so
+// any caller producing an
 // equivalent sweep for the same dims reuses the result.
-async function getBroadEnumeration({ root, hidden, depth, includeNoise, rgArgs, cwd, runRgImpl = runRg, bestEffort = false }) {
+async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMode, rgArgs, cwd, runRgImpl = runRg, bestEffort = false }) {
     const ttl = findEnumTtlMs();
-    const key = findEnumKey({ root, hidden, depth, includeNoise });
+    const key = findEnumKey({ root, hidden, depth, includeNoise, ignoreMode });
     if (ttl > 0) {
         const hit = FIND_ENUM_CACHE.get(key);
         if (hit && hit.gen === FIND_ENUM_GEN && hit.expiresAt > Date.now()) {
@@ -460,12 +486,12 @@ export async function prewarmFindEnumeration(root) {
     try {
         if (!root || typeof root !== 'string') return;
         const hidden = true, includeNoise = false, depth = null;
-        const rgArgs = ['--files', '--no-ignore', '--hidden'];
+        const rgArgs = ['--files', '--no-require-git', '--hidden'];
         for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
         rgArgs.push('.');
         await getBroadEnumeration({
             root: normalizeOutputPath(root),
-            hidden, depth, includeNoise,
+            hidden, depth, includeNoise, ignoreMode: 'git',
             rgArgs, cwd: root, bestEffort: true,
         });
     } catch { /* best-effort warm; never surface */ }
@@ -543,11 +569,10 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     });
     const cached = cacheGet(cacheKey);
     if (cached !== null) return cached;
-    // --no-ignore: match the find_files fast path contract — do not consult
-    // .gitignore, so a .gitignored-but-present file is still discoverable.
+    // Common discovery respects .gitignore even outside a Git repository.
+    // include_noise deliberately retains the old hardened --no-ignore behavior.
     // Noise dirs stay excluded via DEFAULT_IGNORE_GLOBS below.
-    // Shared rg flags for both enumeration passes below.
-    const baseRgArgs = ['--files', '--no-ignore'];
+    const baseRgArgs = ['--files', includeNoise ? '--no-ignore' : '--no-require-git'];
     if (hidden) baseRgArgs.push('--hidden');
     if (depth != null) baseRgArgs.push('--max-depth', String(depth));
     // Noise-exclusion globs are kept SEPARATE and always appended LAST (after
@@ -586,7 +611,7 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     try {
         broadEnum = await getBroadEnumeration({
             root: normalizeOutputPath(fullPath),
-            hidden, depth, includeNoise,
+            hidden, depth, includeNoise, ignoreMode: includeNoise ? 'all' : 'git',
             rgArgs: [...baseRgArgs, ...ignoreGlobs, '.'],
             cwd: fullPath,
             runRgImpl,
@@ -594,25 +619,67 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     } catch (err) {
         return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
     }
-    const rgTruncated = broadEnum.truncated;
-    const rgPartial = broadEnum.partial;
+    let rgTruncated = broadEnum.truncated;
+    let rgPartial = broadEnum.partial;
+    const passOneItems = broadEnum.files.map((path) => ({ path }));
+    // Any single path segment is an exact-name candidate, including names with
+    // spaces, extensionless names, and literal glob characters. The comparison
+    // below is direct, so glob syntax has no special meaning in this decision.
+    const exactFilenameQuery = !/[\\/]/.test(query);
+    const queryLower = query.toLowerCase();
+    const passOneHasExactBasename = !exactFilenameQuery || broadEnum.files.some((path) =>
+        path.slice(path.lastIndexOf('/') + 1).toLowerCase() === queryLower);
+    const passOneHasCandidate = fuzzyRank(query, passOneItems, 1).length > 0;
+    let fallbackRan = false;
+    let fallbackPaths = [];
+    // Only pay for the hardened tree walk when common discovery has no answer,
+    // or when an exact filename could be hidden by .gitignore. Reuse the
+    // hardened broad cache shared with find_files: its key distinguishes
+    // ignoreMode, so this cannot collide with the common pass.
+    if (!includeNoise && (!passOneHasCandidate || !passOneHasExactBasename)) {
+        try {
+            const fallbackArgs = ['--files', '--no-ignore', ...baseRgArgs.slice(2), ...ignoreGlobs, '.'];
+            const fallbackEnum = await getBroadEnumeration({
+                root: normalizeOutputPath(fullPath),
+                hidden, depth, includeNoise, ignoreMode: 'all',
+                rgArgs: fallbackArgs, cwd: fullPath, runRgImpl,
+            });
+            rgTruncated ||= fallbackEnum.truncated;
+            rgPartial ||= fallbackEnum.partial;
+            fallbackPaths = fallbackEnum.files;
+            fallbackRan = true;
+        } catch {
+            // This required fallback leaves the result incomplete. Surface the
+            // existing partial warning and prevent the final output cache from
+            // preserving a pass-one-only answer.
+            rgPartial = true;
+        }
+    }
     // Narrowed enumeration: only files whose NAME contains the query
     // (case-insensitive substring glob). This output is tiny and effectively
     // never truncated, so exact/substring hits are guaranteed to reach ranking
     // regardless of whether the broad pass was cut at the cap. Best-effort:
     // failures here never fail the tool — the broad pass still stands.
     let narrowPaths = [];
-    try {
+    // Only spawn the per-query narrowed rg pass when the broad enumeration was
+    // cut (cap/exit-2): an untruncated broad pass already contains every file,
+    // so every narrowed substring hit is a broad-set duplicate that the
+    // dedup below drops — running it would add zero items. Skipping it there
+    // removes a redundant full-tree walk per query with identical output.
+    if (rgTruncated || rgPartial) try {
         // A positive --iglob whitelist makes ripgrep re-admit paths its own
         // `!**/<noise>/**` negations would otherwise exclude (the whitelist
         // wins regardless of glob order), so noise dirs are pruned in JS here
         // instead — matching the broad pass's effective exclusion set.
-        const narrowStdout = await runRgImpl([...baseRgArgs, '--iglob', `*${escapeGlobLiteral(query)}*`, '.'], { cwd: fullPath });
+        const narrowBaseArgs = fallbackRan
+            ? ['--files', '--no-ignore', ...baseRgArgs.slice(2)]
+            : baseRgArgs;
+        const narrowStdout = await runRgImpl([...narrowBaseArgs, '--iglob', `*${escapeGlobLiteral(query)}*`, '.'], { cwd: fullPath });
         narrowPaths = parseRgFiles(narrowStdout).filter((p) =>
             includeNoise || !p.split('/').some((seg) => NOISE_DIR_NAMES.has(seg)));
     } catch { /* best-effort backstop; broad pass already collected */ }
-    // Merge broad + narrowed, deduplicating by path (broad order preserved,
-    // narrowed-only exact-name candidates appended).
+    // Merge pass one + fallback + narrowed, deduplicating by path. Pass-one
+    // order always wins so the fallback cannot perturb common-path ranking.
     const seen = new Set();
     const items = [];
     for (const p of broadEnum.files) {
@@ -620,6 +687,11 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
         seen.add(p);
         items.push({ path: p });
     }
+    for (const p of fallbackPaths) {
+        if (seen.has(p)) continue;
+        seen.add(p);
+        items.push({ path: p });
+    }
     for (const p of narrowPaths) {
         if (seen.has(p)) continue;
         seen.add(p);
@@ -638,6 +710,9 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
     if (!noMatch && hasMore) lines.push(`... (top ${headLimit}; raise head_limit for more)`);
     if (rgTruncated) lines.push('... [warning] rg stdout truncated at 20MB cap; broad ranking incomplete (exact-name hits still merged)');
     if (rgPartial && !rgTruncated) lines.push('... [warning] rg exit 2 (partial results); broad ranking may be incomplete');
+    if (!fallbackRan && headLimit > 0 && fuzzyRank(query, passOneItems, headLimit).length >= headLimit) {
+        lines.push('[gitignored trees not searched; retry with include_noise:true]');
+    }
     const result = lines.join('\n');
     // Do not cache a truncated/partial enumeration — the broad ranking is
     // known-incomplete, so a later call with a larger head_limit must re-run.
@@ -753,8 +828,10 @@ export async function executeFindFilesTool(args, workDir, options = {}) {
         return subject.toLowerCase().includes(nameLower);
     };
 
-    try { await assertPathReachable(fullPath); }
+    let _preStat;
+    try { _preStat = await assertPathReachable(fullPath); }
     catch (err) { return `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`; }
+    if (_preStat) statCacheSet(fullPath, _preStat);
     let rootStat;
     try { rootStat = getCachedReadOnlyStat(fullPath); }
     catch (err) {
@@ -794,7 +871,7 @@ export async function executeFindFilesTool(args, workDir, options = {}) {
             if (!namePattern) {
                 const enumRes = await getBroadEnumeration({
                     root: normalizeOutputPath(fullPath),
-                    hidden, depth, includeNoise,
+                    hidden, depth, includeNoise, ignoreMode: 'all',
                     rgArgs, cwd: fullPath,
                 });
                 rgStdoutTruncated = enumRes.truncated;

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

@@ -2,6 +2,7 @@ import { homedir } from 'os';
 import { isAbsolute, relative, resolve } from 'path';
 import { realpathSync, statSync } from 'node:fs';
 import { isWSL } from '../../../../shared/wsl.mjs';
+import { statCacheSet } from './cache-layers.mjs';
 
 // Restore the on-disk casing of a path (win32 only). rg relativizes candidate
 // paths against its process cwd with a CASE-SENSITIVE prefix strip before
@@ -248,7 +249,13 @@ export function coerceReadFamilyPathArg(path, workDir = null) {
         if (/\s/.test(trimmed)) {
             let fullPathExists = false;
             try {
-                statSync(resolveAgainstCwd(normalizeInputPath(trimmed), workDir));
+                // Seed the stat cache with this existence probe so the caller's
+                // immediate getCachedReadOnlyStat on the same resolved path
+                // reuses it instead of re-stat'ing. Pure de-dup: a cache miss
+                // just falls back to the caller's own stat.
+                const _full = resolveAgainstCwd(normalizeInputPath(trimmed), workDir);
+                const _st = statSync(_full);
+                statCacheSet(_full, _st);
                 fullPathExists = true;
             } catch { /* split only when the literal path is missing */ }
             if (!fullPathExists) {

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

@@ -89,7 +89,7 @@ export function readEntryLineWindow(entry) {
     };
 }
 
-export function coalesceObjectReadEntries(rawEntries) {
+export function coalesceObjectReadEntries(rawEntries, resolvePath = null) {
     const out = new Array(rawEntries.length);
     const groups = new Map();
     for (let i = 0; i < rawEntries.length; i++) {
@@ -99,7 +99,9 @@ export function coalesceObjectReadEntries(rawEntries) {
             continue;
         }
         const win = readEntryLineWindow(entry);
-        const key = entry.path || '';
+        // Group by RESOLVED path so two path strings that point at the same
+        // file share one coalesced disk window instead of each opening it.
+        const key = (typeof resolvePath === 'function' ? resolvePath(entry.path || '') : (entry.path || ''));
         if (!groups.has(key)) groups.set(key, []);
         groups.get(key).push({ index: i, entry, offset: win.offset, end: win.end });
     }

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

@@ -101,7 +101,9 @@ function ensureReadRangeIndexDiskSwept() {
 function loadReadRangeIndexFromDisk(fullPath, st) {
     ensureReadRangeIndexDiskSwept();
     const file = readRangeIndexFilePath(fullPath);
-    if (!file || !st || !existsSync(file)) return null;
+    // No existsSync preflight: a missing file surfaces as an ENOENT from
+    // readFileSync below, caught by the same try/catch — one FS pass, not two.
+    if (!file || !st) return null;
     try {
         const row = JSON.parse(readFileSync(file, 'utf-8'));
         if (!readRangeIndexMatches(row, fullPath, st)) return null;

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

@@ -124,7 +124,10 @@ export function recordReadSnapshot(fullPath, st, scope = null, meta = {}) {
     }
     if (!next.contentHash && snapshotCoversFullFile(next)) {
         try {
-            const content = decodeRawBufferForSnapshotCheck(readFileSync(fullPath));
+            // Reuse the raw-content cache (populated by the read that produced
+            // this snapshot) instead of a fresh readFileSync + decode purely to
+            // hash. Decodes via the same helper, so the hash is byte-identical.
+            const content = readTextForSnapshotCheck(fullPath, null, st);
             next.contentHash = hashText(content);
         } catch {}
     }

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

@@ -225,7 +225,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         // range into one huge window. Far-apart reads stay separate,
         // which avoids scanning and then slicing thousands of lines
         // just to return two tiny windows.
-        const entries = coalesceObjectReadEntries(rawEntries);
+        const entries = coalesceObjectReadEntries(rawEntries, (p) => resolveAgainstCwd(p, workDir));
         // Deduplicate so the same union-range is read only once per path.
         const _seen = new Map(); // cacheKey → dedupedEntries index
         const dedupedEntries = [];
@@ -282,11 +282,31 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         // re-order results to match the caller's original entry order.
         const _origEntries2 = Array.isArray(args._readsOrigEntries) ? args._readsOrigEntries : null;
         const _entryMap2 = Array.isArray(args._readsEntryToDeduped) ? args._readsEntryToDeduped : null;
+        // Dedup string-batch entries by RESOLVED path + window so a file that
+        // appears twice (incl. two path strings that resolve to the same file)
+        // is stat/opened/read ONCE, not per duplicate. Duplicates copy the
+        // primary's body, keeping the per-index render byte-identical. Skipped
+        // when `overrides` (reads[] coalesce path) is set — those entries were
+        // already deduped upstream and carry the union-slice bookkeeping.
+        const _readIndexFor = new Array(entries.length);
+        if (!overrides) {
+            const _dedup = new Map();
+            for (let i = 0; i < entries.length; i++) {
+                const e = entries[i];
+                if (!e || !e.path) { _readIndexFor[i] = i; continue; }
+                const rp = resolveAgainstCwd(e.path, workDir);
+                const k = `${rp}|${e.mode ?? ''}|${e.offset ?? ''}|${e.limit ?? ''}|${e.n ?? ''}|${e.full ?? ''}`;
+                if (_dedup.has(k)) { _readIndexFor[i] = _dedup.get(k); }
+                else { _dedup.set(k, i); _readIndexFor[i] = i; }
+            }
+        } else {
+            for (let i = 0; i < entries.length; i++) _readIndexFor[i] = i;
+        }
         const tasks = entries.map((entry, index) => ({
             entry,
             index,
             offset: _isFullModeReadEntry(entry) ? _readEntryLineWindow(entry).offset : 0,
-        })).sort((a, b) => {
+        })).filter((t) => _readIndexFor[t.index] === t.index).sort((a, b) => {
             const ap = a.entry?.path || '';
             const bp = b.entry?.path || '';
             if (ap !== bp) return ap < bp ? -1 : 1;
@@ -320,6 +340,17 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             readChains.set(key, next.catch(() => {}));
             return next;
         }));
+        // Fan the primary read's result out to its duplicate indices so every
+        // caller slot is populated without a second disk window.
+        for (let i = 0; i < entries.length; i++) {
+            const src = _readIndexFor[i];
+            if (src === i) continue;
+            const e = entries[i];
+            const s = results[src];
+            results[i] = s
+                ? { path: e.path, mode: e.mode || 'full', n: e.n, body: s.body }
+                : { path: e.path, mode: e.mode || 'full', n: e.n, body: 'Error: dedup mapping failed' };
+        }
         const orderedResults = _origEntries2
             ? _origEntries2.map((orig, i) => {
                 const r = results[_entryMap2 ? _entryMap2[i] : i] || { path: orig.path, mode: orig.mode || 'full', body: 'Error: dedup mapping failed' };