mixdog 0.9.36 → 0.9.37

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

@@ -32,6 +32,7 @@ import {
 import { formatMtime, formatListSize } from './list-formatting.mjs';
 import { TOOL_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
 import { runRg } from './rg-runner.mjs';
+import { hasSpareCapacity as childSpawnHasSpareCapacity } from '../../../../shared/child-spawn-gate.mjs';
 import { fuzzyRank } from './fuzzy-match.mjs';
 import { assertPathReachable } from './fs-reachability.mjs';
 
@@ -84,16 +85,30 @@ export async function executeListTool(args, workDir, options = {}) {
         const capped = list.length > 10;
         const targets = capped ? list.slice(0, 10) : list;
         if (targets.length > 1) {
-            const sections = [];
-            for (const p of targets) {
-                let body;
-                try {
-                    body = await executeListTool({ ...args, path: p }, workDir, options);
-                } catch (err) {
-                    body = `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+            // Bounded parallel fan-out: each target is an independent listing
+            // (own guard/cache/reachability), so run them concurrently instead
+            // of serially. Bodies land in a fixed-index array so the emitted
+            // section order still matches the caller's `path[]` order — only the
+            // 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);
+            let cursor = 0;
+            const runWorker = async () => {
+                for (;;) {
+                    const i = cursor++;
+                    if (i >= targets.length) return;
+                    try {
+                        bodies[i] = await executeListTool({ ...args, path: targets[i] }, workDir, options);
+                    } catch (err) {
+                        bodies[i] = `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+                    }
                 }
-                sections.push(`# list ${p}\n${body}`);
-            }
+            };
+            await Promise.all(
+                Array.from({ length: Math.min(LIST_FANOUT_CONCURRENCY, targets.length) }, runWorker),
+            );
+            const sections = targets.map((p, i) => `# list ${p}\n${bodies[i]}`);
             if (capped) sections.push(`... [capped at 10 of ${list.length} paths]`);
             return sections.join('\n\n');
         }
@@ -349,8 +364,9 @@ export async function executeTreeTool(args, workDir, options = {}) {
 // key with in-flight promise dedup (N concurrent callers share ONE sweep)
 // plus a short TTL for serial reuse. Truncated/partial sweeps are
 // known-incomplete and are NEVER cached.
-const FIND_ENUM_CACHE = new Map(); // key -> { files, expiresAt }
+const FIND_ENUM_CACHE = new Map(); // key -> { files, expiresAt, gen }
 const FIND_ENUM_INFLIGHT = new Map(); // key -> Promise<{files,truncated,partial}>
+let FIND_ENUM_GEN = 0;
 
 // The broad enumeration is a DERIVED cache the scope/path invalidation layer
 // does not otherwise know about — a file created/renamed after a sweep would
@@ -358,6 +374,7 @@ const FIND_ENUM_INFLIGHT = new Map(); // key -> Promise<{files,truncated,partial
 // write-invalidation event (TTL remains the secondary bound). Full clear is
 // fine: entries are cheap to rebuild.
 registerCacheInvalidationListener(() => {
+    FIND_ENUM_GEN += 1;
     FIND_ENUM_CACHE.clear();
     FIND_ENUM_INFLIGHT.clear();
 });
@@ -390,18 +407,31 @@ function parseRgFileList(stdout) {
 // 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
 // equivalent sweep for the same dims reuses the result.
-async function getBroadEnumeration({ root, hidden, depth, includeNoise, rgArgs, cwd, runRgImpl = runRg }) {
+async function getBroadEnumeration({ root, hidden, depth, includeNoise, rgArgs, cwd, runRgImpl = runRg, bestEffort = false }) {
     const ttl = findEnumTtlMs();
     const key = findEnumKey({ root, hidden, depth, includeNoise });
     if (ttl > 0) {
         const hit = FIND_ENUM_CACHE.get(key);
-        if (hit && hit.expiresAt > Date.now()) {
+        if (hit && hit.gen === FIND_ENUM_GEN && hit.expiresAt > Date.now()) {
             return { files: hit.files, truncated: false, partial: false };
         }
         if (hit) FIND_ENUM_CACHE.delete(key); // expired
-        const inflight = FIND_ENUM_INFLIGHT.get(key);
-        if (inflight) return inflight;
     }
+    // Single-flight is independent of the persistent TTL cache. Even when
+    // MIXDOG_FIND_ENUM_CACHE_TTL_MS=0 disables reuse across calls, concurrent
+    // query[] fan-out should still share the one broad `rg --files` sweep
+    // instead of spawning N identical enumerations.
+    const inflight = FIND_ENUM_INFLIGHT.get(key);
+    if (inflight) return inflight;
+    // Non-competing prewarm: past the cache/single-flight fast paths this runs
+    // a fresh `rg` sweep (a child-spawn slot). Best-effort warmers skip that
+    // spawn when the gate has no spare capacity, returning a known-incomplete
+    // result — and skipping BEFORE registering FIND_ENUM_INFLIGHT so a real
+    // caller is never attached to (or cache-poisoned by) a skipped warm.
+    if (bestEffort && !childSpawnHasSpareCapacity()) {
+        return { files: [], truncated: false, partial: true };
+    }
+    const genAtStart = FIND_ENUM_GEN;
     const run = (async () => {
         const stdout = await runRgImpl(rgArgs, { cwd });
         const truncated = Boolean(stdout && typeof stdout === 'object' && stdout.truncated);
@@ -409,17 +439,18 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, rgArgs,
         const files = parseRgFileList(stdout);
         // Never cache a truncated/partial sweep — it is known-incomplete, so a
         // later query with a larger head_limit must re-run the enumeration.
-        if (ttl > 0 && !truncated && !partial) {
-            FIND_ENUM_CACHE.set(key, { files, expiresAt: Date.now() + ttl });
+        // Also never let an in-flight prewarm/real sweep repopulate after a
+        // write invalidation cleared the cache during the sweep.
+        if (ttl > 0 && !truncated && !partial && FIND_ENUM_GEN === genAtStart) {
+            FIND_ENUM_CACHE.set(key, { files, expiresAt: Date.now() + ttl, gen: genAtStart });
         }
         return { files, truncated, partial };
     })();
-    if (ttl > 0) {
-        FIND_ENUM_INFLIGHT.set(key, run);
-        try { return await run; }
-        finally { FIND_ENUM_INFLIGHT.delete(key); }
+    FIND_ENUM_INFLIGHT.set(key, run);
+    try { return await run; }
+    finally {
+        if (FIND_ENUM_INFLIGHT.get(key) === run) FIND_ENUM_INFLIGHT.delete(key);
     }
-    return run;
 }
 
 // Best-effort warm of the broad enumeration for a root using the `find` tool's
@@ -435,7 +466,7 @@ export async function prewarmFindEnumeration(root) {
         await getBroadEnumeration({
             root: normalizeOutputPath(root),
             hidden, depth, includeNoise,
-            rgArgs, cwd: root,
+            rgArgs, cwd: root, bestEffort: true,
         });
     } catch { /* best-effort warm; never surface */ }
 }
@@ -450,16 +481,31 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
         const capped = list.length > 5;
         const targets = capped ? list.slice(0, 5) : list;
         if (targets.length > 1) {
-            const sections = [];
-            for (const q of targets) {
-                let body;
-                try {
-                    body = await executeFuzzyFindTool({ ...args, query: q }, workDir, options);
-                } catch (err) {
-                    body = `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+            // Bounded parallel fan-out: every query shares ONE broad `rg --files`
+            // sweep via the enumeration cache's in-flight single-flight dedup, so
+            // running them concurrently collapses N broad sweeps into one and
+            // overlaps the tiny per-query narrowed passes. Bodies land at a fixed
+            // index so the emitted section order still matches the caller's
+            // query[] order — only wall-clock cost changes. Concurrency is capped
+            // so a 5-query batch cannot exhaust the child-spawn budget.
+            const FIND_FANOUT_CONCURRENCY = 4;
+            const bodies = new Array(targets.length);
+            let cursor = 0;
+            const runWorker = async () => {
+                for (;;) {
+                    const i = cursor++;
+                    if (i >= targets.length) return;
+                    try {
+                        bodies[i] = await executeFuzzyFindTool({ ...args, query: targets[i] }, workDir, options);
+                    } catch (err) {
+                        bodies[i] = `Error: ${normalizeErrorMessage(err instanceof Error ? err.message : String(err))}`;
+                    }
                 }
-                sections.push(`# find ${q}\n${body}`);
-            }
+            };
+            await Promise.all(
+                Array.from({ length: Math.min(FIND_FANOUT_CONCURRENCY, targets.length) }, runWorker),
+            );
+            const sections = targets.map((q, i) => `# find ${q}\n${bodies[i]}`);
             if (capped) sections.push(`... [capped at 5 of ${list.length} queries]`);
             return sections.join('\n\n');
         }

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

@@ -24,11 +24,20 @@ function _stripLineCoordForReach(s) {
         .replace(/:\d+(?:-\d+)?(?::.*)?$/, '');
 }
 
+// Batch fan-out cap: array/object read shapes read only the first N entries
+// (the >N slice below truncates the rest with a `_batchCapNote`). The
+// reachability preflight must honour the SAME cap so a path that will be
+// capped away is never stat-probed and can never reject the batch via a guard.
+const READ_BATCH_PATH_CAP = 10;
+
 function _collectReachCandidates(p) {
     const out = [];
     const push = (s) => { if (typeof s === 'string' && s) out.push(s); };
     if (typeof p === 'string') push(p);
-    else if (Array.isArray(p)) for (const e of p) push((e && typeof e === 'object') ? (e.path ?? e.file_path) : e);
+    // Only the first READ_BATCH_PATH_CAP entries survive the fan-out cap, so
+    // preflight only the paths that will actually be read. Capped-away paths
+    // (incl. UNC/device) must NOT be probed or allowed to fail the batch.
+    else if (Array.isArray(p)) for (const e of p.slice(0, READ_BATCH_PATH_CAP)) push((e && typeof e === 'object') ? (e.path ?? e.file_path) : e);
     return out;
 }
 
@@ -66,11 +75,17 @@ async function _readReachPreflight(rawPath, workDir, helpers) {
     // line-coordinate strip only needs to land in the right directory — exact
     // suffix parsing is not required for the stat to be representative.
     const candidates = [];
+    const seenFull = new Set();
     for (const raw of _collectReachCandidates(rawPath)) {
         const stripped = _stripLineCoordForReach(normalizeInputPath(raw));
         const full = resolveAgainstCwd(stripped, workDir);
         const guardMsg = _guardedReadError(stripped, helpers) || _guardedReadError(full, helpers);
         if (guardMsg) return guardMsg;
+        // Dedup by resolved path so a batch repeating the same file (or the
+        // same union window) issues one stat probe, not one per entry —
+        // bounding the preflight's FS work to the distinct target set.
+        if (seenFull.has(full)) continue;
+        seenFull.add(full);
         candidates.push(full);
     }
     if (candidates.length === 0) return null;
@@ -113,7 +128,14 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
     args.path = coerceReadFamilyPathArg(args.path, workDir);
     // Reachability preflight up front (all shapes) — before readPathStringGuardError /
     // image stat, all of which can touch sync FS.
-    {
+    // options._skipReachPreflight: set only by the batch dispatcher on its
+    // child reads (below). The parent batch call already ran this exact
+    // preflight over EVERY candidate path in the array (_collectReachCandidates
+    // covers array/object shapes), so re-running it per child re-stats the same
+    // mounts N times. The UNC/device/ADS string guards still run inside the
+    // child (readPathStringGuardError / image fast-path) — only the async
+    // reachability stat is skipped, never the security guards.
+    if (options?._skipReachPreflight !== true) {
         const _reErr = await _readReachPreflight(args.path, workDir, helpers);
         if (_reErr) return _reErr;
     }
@@ -289,7 +311,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
                 // document/image content-block object that would stringify to
                 // "[object Object]" and drop the payload. Scalar reads (the
                 // single-file path below) keep the rich block shapes.
-                const body = await executeChildBuiltinTool('read', readEntry, workDir, { suppressReadUnchangedStub: true, mediaTextOnly: true });
+                const body = await executeChildBuiltinTool('read', readEntry, workDir, { suppressReadUnchangedStub: true, mediaTextOnly: true, _skipReachPreflight: true });
                 results[index] = { path: entry.path, mode: entry.mode || 'full', n: entry.n, body };
             };
             const key = entry.path || `#missing-${index}`;

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

@@ -31,6 +31,7 @@ export function buildGrepCacheKey(parts) {
         onlyMatching,
         pcre2,
         withFilename,
+        patternCapTotal = 0,
     } = parts;
     return [
         'grep',
@@ -50,6 +51,10 @@ export function buildGrepCacheKey(parts) {
         Array.isArray(fileType) ? fileType.join('\x01') : (fileType || ''),
         pcre2 ? 'p1' : 'p0',
         withFilename ? 'H1' : 'H0',
+        // Cap total keeps a capped request (first-N of M patterns, carrying the
+        // "[capped at N of M]" notice) from colliding with an exact N-pattern
+        // request or with a differently-capped one (of 15 vs of 20).
+        'pc' + String(patternCapTotal || 0),
     ].join('|');
 }
 
@@ -126,13 +131,15 @@ export function buildGrepRgArgs(parts) {
     return rgArgs;
 }
 
-export function buildGlobCacheKey({ patterns, basePath, headLimit, offset, extraIgnore, sort }) {
+export function buildGlobCacheKey({ patterns, basePath, headLimit, offset, extraIgnore, sort, patternCapTotal = 0 }) {
     // extraIgnore (rg ignore globs from _extraIgnoreDirs) alters which files
     // match, so it MUST partake in the key — otherwise calls that differ only
     // by extra ignores collide and return stale over-/under-filtered results.
     // Sorted so the same ignore set in any order maps to one key.
     const extra = Array.isArray(extraIgnore) && extraIgnore.length ? [...extraIgnore].sort().join('\x01') : '';
-    return ['glob', patterns.join('\x01'), basePath, headLimit ?? '', offset ?? '', sort || 'natural', extra].join('|');
+    // patternCapTotal: a capped pattern set (first-N of M) must not collide with
+    // an exact N-pattern request or a differently-capped one.
+    return ['glob', patterns.join('\x01'), basePath, headLimit ?? '', offset ?? '', sort || 'natural', extra, 'pc' + String(patternCapTotal || 0)].join('|');
 }
 
 export function buildListCacheKey(parts) {

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

@@ -523,7 +523,12 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
                 }
                 parts.push(`# grep ${p}\n${body}`);
             }
-            if (list.length > GREP_PATH_CAP) parts.push(`[capped at ${GREP_PATH_CAP} of ${list.length} paths]`);
+            if (list.length > GREP_PATH_CAP) {
+                parts.push(`[capped at ${GREP_PATH_CAP} of ${list.length} paths]`);
+                // Omitted paths mean the returned result cannot cover the whole
+                // requested path set — never let it be cached as complete.
+                if (options?.scopedCacheOutcome) markScopedCacheIncomplete(options.scopedCacheOutcome);
+            }
             return parts.join('\n\n');
         }
         args.path = list[0];
@@ -542,9 +547,15 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
     let patterns = uniqueStrings(rawPatterns.map(normalizeSearchPattern));
     const GREP_PATTERN_ARRAY_CAP = 10;
     let patternCapNote = '';
+    let patternCapTotal = 0;
     if (patterns.length > GREP_PATTERN_ARRAY_CAP) {
         patternCapNote = `[capped at ${GREP_PATTERN_ARRAY_CAP} of ${patterns.length} patterns]\n`;
+        patternCapTotal = patterns.length;
         patterns = patterns.slice(0, GREP_PATTERN_ARRAY_CAP);
+        // Dropping input patterns means the returned result cannot cover the
+        // full requested pattern set — never cache it as complete. Applies to
+        // every downstream path (fan-out, chunk-merge, single combined).
+        if (options?.scopedCacheOutcome) markScopedCacheIncomplete(options.scopedCacheOutcome);
     }
     if (patterns.length === 0) {
         if (args.glob || hasGlobMagic(args.path)) {
@@ -725,16 +736,18 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         && !options._grepPatternFanout) {
         const seen = new Set();
         const subOptions = { ...options, _grepPatternFanout: true };
-        const parts = [];
-        for (const p of patterns) {
-            let sub;
+        // Each pattern is an INDEPENDENT grep; run them concurrently and then
+        // apply dedup/section assembly in the original pattern order so the
+        // shared `seen` set and output text stay byte-identical to the
+        // sequential version.
+        const subs = await Promise.all(patterns.map(async (p) => {
             try {
-                sub = await executeGrepTool({ ...args, pattern: p }, workDir, executeChildBuiltinTool, readStateScope, subOptions);
+                return await executeGrepTool({ ...args, pattern: p }, workDir, executeChildBuiltinTool, readStateScope, subOptions);
             } catch (err) {
-                sub = `Error: ${err && err.message ? err.message : err}`;
+                return `Error: ${err && err.message ? err.message : err}`;
             }
-            parts.push(`# grep pattern:${JSON.stringify(p)}\n${dedupeFanoutMatchLines(sub, seen)}`);
-        }
+        }));
+        const parts = patterns.map((p, i) => `# grep pattern:${JSON.stringify(p)}\n${dedupeFanoutMatchLines(subs[i], seen)}`);
         return patternCapNote + parts.join('\n\n');
     }
 
@@ -749,20 +762,27 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
             ...(outputMode === 'count' ? { output_mode: 'content' } : {}),
         };
         const chunkMergeOptions = { ...options, _grepChunkMerge: true };
+        // Fetch every chunk concurrently with the full aggregate budget, then
+        // replay the sequential room-based accumulation over the results in
+        // chunk order. rg output order is deterministic, so slicing this
+        // superset by the sequential `room` yields identical lines, and the
+        // re-extract with `room` reproduces the same truncation flags — the
+        // merged output and `truncatedAggregate` are byte-identical to the
+        // old serial loop while the grep calls overlap.
+        const chunkBodies = await Promise.all(patternChunks.map((chunk) => executeGrepTool(
+            { ...chunkBaseArgs, pattern: chunk, head_limit: aggregateBudget },
+            workDir,
+            executeChildBuiltinTool,
+            readStateScope,
+            chunkMergeOptions,
+        )));
         const mergedRaw = [];
-        for (const chunk of patternChunks) {
+        for (const chunkBody of chunkBodies) {
             if (mergedRaw.length >= aggregateBudget) {
                 truncatedAggregate = true;
                 break;
             }
             const room = aggregateBudget - mergedRaw.length;
-            const chunkBody = await executeGrepTool(
-                { ...chunkBaseArgs, pattern: chunk, head_limit: room },
-                workDir,
-                executeChildBuiltinTool,
-                readStateScope,
-                chunkMergeOptions,
-            );
             const extracted = extractGrepChunkResultLines(chunkBody, room);
             if (extracted.error) return extracted.error.startsWith('Error:') ? extracted.error : `Error: ${extracted.error}`;
             const slice = extracted.lines.slice(0, room);
@@ -784,6 +804,16 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         const sliced = offset > 0 ? merged.slice(offset) : merged;
         const limit = headLimit === Infinity ? sliced.length : headLimit;
         const windowed = limit === Infinity ? sliced : sliced.slice(0, limit);
+        // Cache-outcome fidelity: the concurrent chunk fetches run with the full
+        // aggregateBudget as head_limit, so a child may report itself complete
+        // even though the replay above trimmed its lines to a smaller `room`
+        // (truncatedAggregate), the final head_limit window dropped lines, or an
+        // offset paged past earlier matches. Mirror the other grep return paths
+        // and mark the scoped cache incomplete so a partial/paged chunk-merge
+        // result is never cached as whole.
+        if (options?.scopedCacheOutcome && (truncatedAggregate || offset > 0 || windowed.length < sliced.length)) {
+            markScopedCacheIncomplete(options.scopedCacheOutcome);
+        }
         if (!windowed.length) {
             const patternStr = patterns.length === 1 ? JSON.stringify(patterns[0]) : JSON.stringify(patterns);
             const globStr = normalizedGlobPatterns.length > 0 ? ` glob=${JSON.stringify(normalizedGlobPatterns)}` : '';
@@ -791,7 +821,10 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         }
         return formatGrepOutput({
             windowed,
-            totalWindowed: merged.length,
+            // POST-offset total so formatGrepOutput's remaining/total math (which
+            // re-adds `offset`) does not conjure phantom "more" results from the
+            // offset-skipped prefix.
+            totalWindowed: sliced.length,
             totalKnown: !truncatedAggregate,
             headLimit,
             offset,
@@ -828,6 +861,10 @@ export async function executeGrepTool(args, workDir, executeChildBuiltinTool, re
         fileType,
         pcre2: pcre2Mode,
         withFilename: forceGrepFilename,
+        // Capped requests carry the "[capped at N of M]" notice; key on the
+        // original count so they never collide with an exact N-pattern request
+        // (or a differently-capped one) in the internal result cache.
+        patternCapTotal,
     });
     // Single-file grep registers a whole-file read snapshot (parity with
     // apply_patch), satisfying the read-before-edit guard while keeping drift
@@ -1193,17 +1230,22 @@ export async function executeGlobTool(args, workDir, options = {}) {
             .filter((p) => p && !seen.has(p) && seen.add(p));
         if (list.length > 1) {
             const capped = list.slice(0, GLOB_PATH_CAP);
-            const parts = [];
-            for (const p of capped) {
-                let body;
+            // Independent per-path globs run concurrently; assemble sections in
+            // the original (capped) order so output stays identical.
+            const bodies = await Promise.all(capped.map(async (p) => {
                 try {
-                    body = await executeGlobTool({ ...args, path: p }, workDir, options);
+                    return await executeGlobTool({ ...args, path: p }, workDir, options);
                 } catch (err) {
-                    body = `Error: ${err && err.message ? err.message : err}`;
+                    return `Error: ${err && err.message ? err.message : err}`;
                 }
-                parts.push(`# glob ${p}\n${body}`);
+            }));
+            const parts = capped.map((p, i) => `# glob ${p}\n${bodies[i]}`);
+            if (list.length > GLOB_PATH_CAP) {
+                parts.push(`[capped at ${GLOB_PATH_CAP} of ${list.length} paths]`);
+                // Omitted paths mean the returned listing is not the whole
+                // requested set — never cache it as complete.
+                if (options?.scopedCacheOutcome) markScopedCacheIncomplete(options.scopedCacheOutcome);
             }
-            if (list.length > GLOB_PATH_CAP) parts.push(`[capped at ${GLOB_PATH_CAP} of ${list.length} paths]`);
             return parts.join('\n\n');
         }
         args.path = list[0] ?? '.';
@@ -1238,9 +1280,15 @@ export async function executeGlobTool(args, workDir, options = {}) {
     }
     const GLOB_PATTERN_ARRAY_CAP = 10;
     let globPatternCapNote = '';
+    let globPatternCapTotal = 0;
     if (patterns.length > GLOB_PATTERN_ARRAY_CAP) {
         globPatternCapNote = `[capped at ${GLOB_PATTERN_ARRAY_CAP} of ${patterns.length} patterns]\n`;
+        globPatternCapTotal = patterns.length;
         patterns = patterns.slice(0, GLOB_PATTERN_ARRAY_CAP);
+        // Omitted patterns: mark the scoped cache incomplete and (below) key the
+        // internal cache on the original count so a capped glob never collides
+        // with an exact N-pattern request or is served as the whole set.
+        if (options?.scopedCacheOutcome) markScopedCacheIncomplete(options.scopedCacheOutcome);
     }
 
     const basePaths = (Array.isArray(args.path) && args.path.length > 0)
@@ -1339,7 +1387,7 @@ export async function executeGlobTool(args, workDir, options = {}) {
         .map((root) => normalizeOutputPath(resolvedForSearchRoot(root)))
         .sort()
         .join('\x01');
-    const cacheKey = buildGlobCacheKey({ patterns, basePath: cacheBasePath, headLimit, offset, extraIgnore: extraIgnoreGlobs, sort: sortMode });
+    const cacheKey = buildGlobCacheKey({ patterns, basePath: cacheBasePath, headLimit, offset, extraIgnore: extraIgnoreGlobs, sort: sortMode, patternCapTotal: globPatternCapTotal });
     const cached = cacheGet(cacheKey);
     if (cached !== null) return cached;
 

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

@@ -16,6 +16,7 @@ import {
 import {
     executeBashTool,
     executeTaskTool,
+    formatShellToolFailure,
 } from './builtin/bash-tool.mjs';
 import {
     executeFindFilesTool,
@@ -464,7 +465,7 @@ export async function executeBuiltinTool(name, args, cwd, options = {}) {
     }
     const toolName = canonicalizeBuiltinToolName(name);
     const argError = validateBuiltinArgs(toolName, args);
-    if (argError) return argError;
+    if (argError) return toolName === 'shell' ? formatShellToolFailure(argError) : argError;
     // Fallback live-progress emit for direct callers (in-process toolExecutor
     // path). The MCP dispatch path already fired the central start message and
     // sets progressStarted:true, so guard against a double-emit there. No-op

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

@@ -13,7 +13,7 @@
 // worker at tools/.
 import { resolve as pathResolve } from 'node:path';
 import { Worker } from 'node:worker_threads';
-import { acquire as acquireChildSpawnSlot } from '../../../../shared/child-spawn-gate.mjs';
+import { acquire as acquireChildSpawnSlot, hasSpareCapacity as childSpawnHasSpareCapacity } from '../../../../shared/child-spawn-gate.mjs';
 import {
   canonicalGraphCwd as _canonicalGraphCwd,
   codeGraphCache as _codeGraphCache,
@@ -55,8 +55,10 @@ const _inflightAsyncBuilds = new Map();
 
 export function prewarmCodeGraph(cwd) {
   if (!cwd) return;
-  // Reuse the buildCodeGraphAsync single-flight path. Fire-and-forget.
-  buildCodeGraphAsync(cwd).catch(() => { /* best-effort */ });
+  // Reuse the buildCodeGraphAsync single-flight path. Fire-and-forget, and
+  // best-effort: skip a fresh worker spawn when the child-spawn gate is busy
+  // so this warm never queues ahead of real code_graph/find queries.
+  buildCodeGraphAsync(cwd, null, { bestEffort: true }).catch(() => { /* best-effort */ });
 }
 
 export function prewarmCodeGraphSymbols(cwd, symbols, { language = null } = {}) {
@@ -64,7 +66,7 @@ export function prewarmCodeGraphSymbols(cwd, symbols, { language = null } = {})
   const wanted = (Array.isArray(symbols) ? symbols : [symbols])
     .map((s) => String(s || '').trim())
     .filter(Boolean);
-  buildCodeGraphAsync(cwd).then((graph) => {
+  buildCodeGraphAsync(cwd, null, { bestEffort: true }).then((graph) => {
     if (!graph) return;
     for (const symbol of wanted) {
       try { _lookupCandidateNodes(graph, symbol, language); } catch { /* best-effort */ }
@@ -80,7 +82,7 @@ export function prewarmCodeGraphIfProject(cwd) {
   return true;
 }
 
-export async function buildCodeGraphAsync(cwd, signal = null) {
+export async function buildCodeGraphAsync(cwd, signal = null, { bestEffort = false } = {}) {
   if (signal?.aborted) throw new Error('aborted');
   const graphCwd = _canonicalGraphCwd(cwd);
   const cached = _codeGraphCache.get(graphCwd);
@@ -107,6 +109,13 @@ export async function buildCodeGraphAsync(cwd, signal = null) {
       (e) => { cleanup(); throw e; },
     );
   }
+  // Non-competing prewarm: once past the cache/single-flight fast paths a
+  // fresh build must spawn the worker (a child-spawn slot). Best-effort warmers
+  // skip that spawn when the gate has no spare capacity, returning null so the
+  // caller no-ops — and skipping BEFORE registering the in-flight entry so a
+  // concurrent REAL caller is never attached to (and thus never starved by) a
+  // skipped warm.
+  if (bestEffort && !childSpawnHasSpareCapacity()) return null;
   const _genAtStart = _getCodeGraphGen(graphCwd);
   let _worker = null;
   const promise = new Promise((resolve, reject) => {
@@ -151,11 +160,12 @@ export async function buildCodeGraphAsync(cwd, signal = null) {
       w.once('message', (msg) => {
         try {
           if (msg && msg.ok && msg.graph && typeof msg.signature === 'string') {
-            if (_getCodeGraphGen(graphCwd) === _genAtStart) {
+            const genStillCurrent = _getCodeGraphGen(graphCwd) === _genAtStart;
+            if (genStillCurrent) {
               _setCodeGraphCache(graphCwd, { ts: Date.now(), signature: msg.signature, graph: msg.graph });
               _setDiskCodeGraphEntry(graphCwd, msg.graph);
             }
-            settle(msg.graph);
+            settle(genStillCurrent ? msg.graph : new Error('code-graph build invalidated during prewarm'));
           } else {
             settle(new Error('code-graph prewarm worker failed'));
           }

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

@@ -360,8 +360,8 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
     const userLimit = Number.isFinite(rawLimit) && rawLimit > 0
       ? Math.min(500, Math.floor(rawLimit))
       : null;
-    await _prewarmReferenceSourceText(graph, symbol, lang);
-    const refResult = _cheapReferenceSearch(graph, symbol, cwd, { language: lang, limit: userLimit, fileRel: rel, scopeRelPrefix });
+    const _refNodes = await _prewarmReferenceSourceText(graph, symbol, lang);
+    const refResult = _cheapReferenceSearch(graph, symbol, cwd, { language: lang, limit: userLimit, fileRel: rel, scopeRelPrefix, nodes: _refNodes });
     return narrowedByCaller ? refResult : _augmentNoHitDiagnostic(refResult, '(no references)', graph, cwd, symbol);
   }
 
@@ -390,12 +390,12 @@ async function codeGraph(args, cwd, signal = null, options = {}) {
     const userLimit = Number.isFinite(rawLimit) && rawLimit > 0
       ? Math.min(500, Math.floor(rawLimit))
       : null;
-    await _prewarmReferenceSourceText(graph, symbol, lang);
+    const _callerNodes = await _prewarmReferenceSourceText(graph, symbol, lang);
     const depth = Math.max(1, Math.min(5, Math.floor(Number(args?.depth) || 1)));
     if (depth > 1) {
       return _formatTransitiveCallers(graph, symbol, cwd, { language: lang, depth, page: args?.page });
     }
-    const refs = _cheapReferenceSearch(graph, symbol, cwd, { language: lang, limit: userLimit, fileRel: rel, scopeRelPrefix });
+    const refs = _cheapReferenceSearch(graph, symbol, cwd, { language: lang, limit: userLimit, fileRel: rel, scopeRelPrefix, nodes: _callerNodes });
     const callerResult = _formatCallerReferences(graph, symbol, refs, userLimit ? { limit: userLimit } : undefined);
     return narrowedByCaller ? callerResult : _augmentNoHitDiagnostic(callerResult, '(no callers)', graph, cwd, symbol);
   }
@@ -575,13 +575,16 @@ export async function executeCodeGraphTool(name, args, cwd, signal = null, optio
           const symbolList = _collectGraphSymbolList(args);
           if (symbolList.length > 1) {
             return (async () => {
-              const sections = [];
-              for (const sym of symbolList) {
+              // Concurrent fan-out: the underlying graph build is single-flight
+              // and cached per cwd (buildCodeGraphAsync), so parallel sections
+              // share one build instead of serializing on it. Order and
+              // per-section error isolation are preserved by the indexed map.
+              const sections = await Promise.all(symbolList.map(async (sym) => {
                 let body;
                 try { body = await dispatchOne({ ...args, symbol: sym, symbols: undefined }); }
                 catch (e) { body = `Error: ${e?.message || String(e)}`; }
-                sections.push(`# ${batchMode} ${sym}\n${body}`);
-              }
+                return `# ${batchMode} ${sym}\n${body}`;
+              }));
               return sections.join('\n\n');
             })();
           }
@@ -594,13 +597,12 @@ export async function executeCodeGraphTool(name, args, cwd, signal = null, optio
           if (fileList.length > 1) {
             const capped = fileList._capped;
             return (async () => {
-              const sections = [];
-              for (const f of fileList) {
+              const sections = await Promise.all(fileList.map(async (f) => {
                 let body;
                 try { body = await dispatchOne({ ...args, file: f, files: undefined }); }
                 catch (e) { body = `Error: ${e?.message || String(e)}`; }
-                sections.push(`# ${batchMode} ${f}\n${body}`);
-              }
+                return `# ${batchMode} ${f}\n${body}`;
+              }));
               if (capped) sections.push(`Note: file list capped at ${CODE_GRAPH_FILE_BATCH_CAP} entries.`);
               return sections.join('\n\n');
             })();

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

@@ -119,6 +119,7 @@ export function _deserializeGraph(cwd, payload) {
 export function _attachGraphRuntimeCaches(graph) {
   if (!graph || typeof graph !== 'object') return graph;
   if (!graph._referenceSearchCache) graph._referenceSearchCache = new Map();
+  if (!graph._keywordSearchCache) graph._keywordSearchCache = new Map();
   if (!graph._maskedLinesCache) graph._maskedLinesCache = new Map();
   if (!graph._sourceLinesCache) graph._sourceLinesCache = new Map();
   if (!graph._sourceTextCache) graph._sourceTextCache = new Map();
@@ -144,6 +145,9 @@ export function _estimateGraphRuntimeCacheBytes(graph) {
   for (const memo of graph._referenceSearchCache?.values() || []) {
     total += Buffer.byteLength(String(memo || ''), 'utf8');
   }
+  for (const memo of graph._keywordSearchCache?.values() || []) {
+    total += Buffer.byteLength(String(memo || ''), 'utf8');
+  }
   return total;
 }
 
@@ -153,6 +157,7 @@ export function _clearGraphRuntimeCaches(graph) {
   graph._maskedLinesCache?.clear();
   graph._sourceLinesCache?.clear();
   graph._referenceSearchCache?.clear();
+  graph._keywordSearchCache?.clear();
   graph._symbolTokenIndex?.clear();
   graph._symbolTokenIndexDirty = true;
 }