mixdog 0.9.116 → 0.9.118

package/package.json

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

package/scripts/tool-stress.mjs

@@ -0,0 +1,145 @@
+// Tool-layer burst stress: hammers the in-process tool execution surface with
+// concurrent multi-session waves and checks that results stay correct and
+// bounded under load (no unhandled rejections, no resource-pressure failures,
+// patch/read integrity preserved, cancellation clean). One-shot script:
+// `node scripts/tool-stress.mjs`. Exit 0 = stable, 1 = instability found.
+import '../src/runtime/shared/uv-threadpool-boot.mjs';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { executeBuiltinTool } from '../src/runtime/agent/orchestrator/tools/builtin.mjs';
+import { executeCodeGraphTool } from '../src/runtime/agent/orchestrator/tools/code-graph.mjs';
+import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+import { normalizeToolEnvelope } from '../src/runtime/agent/orchestrator/session/tool-envelope.mjs';
+
+const root = join(fileURLToPath(new URL('.', import.meta.url)), '..');
+const SESSIONS = 8;
+const WAVES = 5;
+const stats = new Map(); // tool -> {n, errs:[], lat:[]}
+const failures = [];
+
+function record(tool, ms, result, expectRe) {
+  let s = stats.get(tool);
+  if (!s) { s = { n: 0, errs: [], lat: [] }; stats.set(tool, s); }
+  s.n += 1; s.lat.push(ms);
+  const text = String(result ?? '');
+  if (/^Error:|resource pressure|ERESOURCEPRESSURE|EAGAIN/i.test(text)) s.errs.push(text.slice(0, 160));
+  else if (expectRe && !expectRe.test(text)) s.errs.push(`unexpected output: ${text.slice(0, 120)}`);
+}
+
+async function timed(tool, expectRe, fn) {
+  const t0 = Date.now();
+  try {
+    const raw = await fn();
+    const out = normalizeToolEnvelope(raw).result;
+    record(tool, Date.now() - t0, out, expectRe);
+    return out;
+  } catch (err) {
+    record(tool, Date.now() - t0, `Error: thrown ${err?.message || err}`);
+    return null;
+  }
+}
+
+function pct(list, p) {
+  if (!list.length) return 0;
+  const sorted = [...list].sort((a, b) => a - b);
+  return sorted[Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length))];
+}
+
+const tmp = mkdtempSync(join(tmpdir(), 'mixdog-tool-stress-'));
+const t0 = Date.now();
+try {
+  // ── Phase A+C: concurrent multi-session waves (search/read/graph/shell +
+  // per-session patch integrity riding the same load) ──────────────────────
+  for (let wave = 0; wave < WAVES; wave++) {
+    const calls = [];
+    for (let s = 0; s < SESSIONS; s++) {
+      const opts = { sessionId: `stress-s${s}` };
+      const marker = `stress_w${wave}_s${s}`;
+      calls.push(
+        timed('grep', /path-string|paths only|grep|\(no matches\)|Fuzzy/i, () => executeBuiltinTool('grep', {
+          pattern: ['Fuzzy filename', 'paths only'], path: 'src/runtime/agent/orchestrator/tools/builtin', glob: '*.mjs', limit: 20, context: 0,
+        }, root, opts)),
+        timed('glob', /tool-defs\.mjs|\.mjs/, () => executeBuiltinTool('glob', {
+          pattern: '**/*.mjs', path: 'src/session-runtime', limit: 40,
+        }, root, opts)),
+        timed('find', /tool-defs|no fuzzy match/, () => executeBuiltinTool('find', {
+          query: 'tool-defs', limit: 8,
+        }, root, opts)),
+        timed('list', /01-tool\.md|file/, () => executeBuiltinTool('list', {
+          path: 'src/rules/shared',
+        }, root, opts)),
+        timed('read', /Tool Use|read/, () => executeBuiltinTool('read', {
+          path: [['src/rules/shared/01-tool.md', 0, 10], ['package.json', 0, 5]],
+        }, root, opts)),
+        timed('code_graph', /symbol|binding|files|edges/i, () => executeCodeGraphTool('code_graph', {
+          mode: 'symbols', files: 'scripts/smoke.mjs',
+        }, root)),
+        timed('shell', /55350/, () => executeBuiltinTool('shell', {
+          command: 'node -e "console.log(123*450)"', timeout: 60_000,
+        }, root, opts)),
+        (async () => {
+          const patch = [
+            '*** Begin Patch',
+            `*** Add File: ${marker}.txt`,
+            `+payload ${marker}`,
+            '*** End Patch',
+          ].join('\n');
+          await timed('apply_patch', /applied|OK/i, () => executePatchTool('apply_patch', { patch, base_path: tmp }, tmp, opts));
+          const back = await timed('read-verify', new RegExp(`payload ${marker}`), () => executeBuiltinTool('read', { path: `${marker}.txt` }, tmp, opts));
+          if (!String(back || '').includes(`payload ${marker}`)) failures.push(`patch integrity lost for ${marker}`);
+        })(),
+      );
+    }
+    await Promise.all(calls);
+  }
+
+  // ── Phase B: oversized inputs stay budget-bounded ─────────────────────────
+  await Promise.all([
+    timed('grep-broad', /Showing|import|export/, () => executeBuiltinTool('grep', {
+      pattern: 'import', path: 'src', limit: 300, mode: 'files',
+    }, root, { sessionId: 'stress-big' })),
+    timed('glob-broad', /\.mjs|entries/, () => executeBuiltinTool('glob', {
+      pattern: '**/*', path: 'src/runtime/agent/orchestrator/tools', limit: 0,
+    }, root, { sessionId: 'stress-big' })),
+    timed('read-big', /./, () => executeBuiltinTool('read', {
+      path: 'src/tui/dist/index.mjs', limit: 2000,
+    }, root, { sessionId: 'stress-big' })),
+  ]);
+  for (const [tool, s] of stats) {
+    if (tool.endsWith('-broad') || tool === 'read-big') {
+      const worst = Math.max(...s.lat);
+      if (worst > 30_000) failures.push(`${tool} exceeded 30s budget: ${worst}ms`);
+    }
+  }
+
+  // ── Phase D: cancellation under load ─────────────────────────────────────
+  const bg = await timed('shell-async', /task_id/, () => executeBuiltinTool('shell', {
+    command: 'node -e "setTimeout(()=>{}, 30000)"', mode: 'async', timeout: 60_000,
+  }, root, { sessionId: 'stress-cancel' }));
+  const bgId = (/task_id:\s*(\S+)/.exec(String(bg)) || [])[1];
+  if (!bgId) failures.push('async shell did not return task_id');
+  else {
+    await timed('task-cancel', /cancelled/, () => executeBuiltinTool('task', { action: 'cancel', task_id: bgId }, root, { sessionId: 'stress-cancel' }));
+    const st = await timed('task-status', /cancelled|failed/, () => executeBuiltinTool('task', { action: 'status', task_id: bgId }, root, { sessionId: 'stress-cancel' }));
+    if (!/cancelled/.test(String(st))) failures.push(`cancelled task not reported cancelled: ${String(st).slice(0, 120)}`);
+  }
+} finally {
+  try { rmSync(tmp, { recursive: true, force: true }); } catch { /* best-effort */ }
+}
+
+// ── Report ──────────────────────────────────────────────────────────────────
+let errTotal = 0;
+for (const [tool, s] of [...stats.entries()].sort()) {
+  errTotal += s.errs.length;
+  console.log(
+    `${tool.padEnd(14)} n=${String(s.n).padStart(3)} errs=${s.errs.length}`
+    + ` p50=${pct(s.lat, 50)}ms p95=${pct(s.lat, 95)}ms max=${Math.max(...s.lat)}ms`,
+  );
+  for (const e of s.errs.slice(0, 3)) console.log(`  ! ${e}`);
+}
+for (const f of failures) console.log(`FAIL ${f}`);
+const calls = [...stats.values()].reduce((a, s) => a + s.n, 0);
+console.log(`tool stress ${failures.length || errTotal ? 'FAILED' : 'passed'} calls=${calls} errors=${errTotal} failures=${failures.length} elapsed=${Math.round((Date.now() - t0) / 1000)}s`);
+process.exit(failures.length || errTotal ? 1 : 0);

package/src/cli.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import './runtime/shared/uv-threadpool-boot.mjs';
 import { fileURLToPath } from 'node:url';
 import { classifyCliInvocation } from './headless-command.mjs';
 import {

package/src/rules/shared/01-tool.md

@@ -1,7 +1,7 @@
 # Tool Use
 
 - Baseline routing assigns each facet directly by the evidence needed to
-  determine the complete edit:
+  determine the complete answer or edit:
   path/name only→`find`; wildcard/recursive paths→`glob` (including known-root
   unknown descendants); exact directory entries→`list`;
   source content/value/`path:line`→`grep`; exact symbol/relation→`code_graph`;
@@ -18,41 +18,45 @@
   relies on it. Within the current project, pass
   project-relative paths and omit optional scopes equal to its root; explicit
   paths may be outside cwd only for targets outside the project.
-- Plan the fewest dependent rounds, then the fewest calls. A conclusive
-  result ends its facet, and known state — anything the task supplied, a
-  tool returned, or a check already proved — is never re-found,
-  re-derived, or re-verified. Batch calls iff none needs
+- Plan the fewest dependent rounds, then the fewest calls. Known state —
+  anything the task supplied, a tool returned, or a check already proved —
+  is never re-found, re-derived, or re-verified; a change to its subject
+  re-opens it. Batch calls iff none needs
   another's output or can change another's inputs/state; otherwise
   serialize. Before each batch, deduplicate the facets still required by the request,
   route each once to the cheapest sufficient tool with all required
   variants/scopes — every distinct sample/format in the same batch —
   and launch every independent call together — never
   split or duplicate a facet across tools, mutate merely to widen
-  retrieval, reserve known work, or cap fanout. Guessed terms go wide
-  with batched fan-out; narrow a scope only on verified cues — returned
-  siblings/conventions or known literals. Mine each returned output for
-  every remaining facet before the next round. Symbol relations end at
+  retrieval, reserve known work, or cap fanout. Each round asks everything
+  it can and keeps everything it gets: guesses go wide in one batch, scopes
+  narrow only on verified cues — returned siblings/conventions or known
+  literals — and returned output is fully mined before the next round.
+  Symbol relations end at
   `code_graph`; values/locations end at the context grep returns; `read`
   covers only what returned spans cannot, as an anchored offset/limit
-  window. The moment evidence determines the answer, edit, or deliverable,
-  stop retrieving; patch if needed.
+  window. A conclusive result ends its facet; evidence that determines the
+  answer, edit, or deliverable ends retrieval — patch if needed.
 - Once the edit or deliverable is determined, finish in one assistant turn:
   before `apply_patch`, obtain every target hunk's exact current content and
   anchor from `grep`, `code_graph`, or `read`; never infer patch context from
   another file, a sample, or expected text. Then issue `apply_patch` calls
   serially, never in parallel; use one cohesive call with one file section per
-  target, all patches first, and their one
-  batched verification `shell` in the same turn, running the real required
-  postconditions on every changed file and produced artifact, never echoing
-  a claim;
-  runtime waits for every patch and skips the shell
-  if any fails. Retry only failed envelopes; rerun a failed check only
-  after a fix that can change its result, else report it unresolved.
+  target, all patches first, then their one batched verification `shell` in
+  the same turn — the runtime runs it after every patch and only if all
+  succeeded, so verification never needs its own turn. It runs the real
+  required postconditions on every changed file and produced artifact,
+  never echoing a claim; a postcondition that did not actually run is
+  unresolved, not passed. Retry only failed envelopes; rerun a failed check only
+  after a change that can alter its outcome — commands alike; else switch
+  route or report it unresolved.
   Hand-authored text is edited only with `apply_patch`; computed artifacts
   (data/reports/derived values) come from `shell` computation, never
   hand-transcribed numbers. Earlier `shell` is only for runtime/state
   evidence unavailable to file tools—an independent facet, batched with
   the rest; independent probes are parallel shell calls, never one
   serial script per round.
-- A background `task_id` ends the turn; completion resumes work. Never poll;
-  use task control only for recovery or a required blocking result.
+- A long or uncertain command runs async — never nohup — and its
+  `task_id` ends the turn; completion resumes work. Never poll in any
+  form — sleep/status probes included; task control is for recovery or a
+  required blocking result only.

package/src/runtime/agent/orchestrator/session/loop/pre-dispatch-deny.mjs

@@ -19,8 +19,6 @@ const WORKER_DENIED_TOOLS = new Set([
     // (type=spawn|send|close|list). Denying the one name blocks all worker
     // session control.
     'agent',
-    // channels module (owner/Discord-facing)
-    'reply', 'fetch',
     // host input injection
     'inject_input',
 ]);

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

@@ -32,7 +32,7 @@ export const BUILTIN_TOOLS = [
         name: 'read',
         title: 'Mixdog Read',
         annotations: { title: 'Mixdog Read', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false },
-        description: 'Known-file contents or line ranges; not directories. Replaces cat/head/tail.',
+        description: 'Known-file contents or line ranges; images render for viewing; not directories. Replaces cat/head/tail.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -75,7 +75,7 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: 'Run a shell command. Sync inline by default; async returns task_id and sends a completion notification. Executable/runtime/state evidence only — never file exploration in any command segment: NOT ls/find/cat/head/tail/grep/rg/sed; dedicated file tools cover those.',
+        description: 'Run a shell command; async returns task_id and sends a completion notification. Executable/runtime/state evidence only — never file exploration in any command segment: NOT ls/find/cat/head/tail/grep/rg/sed; dedicated file tools cover those.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -194,7 +194,7 @@ export const BUILTIN_TOOLS = [
                     description: 'Filename or directory path fragments matched against path strings; query[] batches.',
                 },
                 path: { type: 'string', description: 'Project-relative base; omit for project root; absolute only outside.' },
-                limit: { type: 'number', description: 'Max paths across the call. Defaults to 25.' },
+                limit: { type: 'number', description: 'Max paths; default 25; 0 unlimited.' },
                 include_noise: { type: 'boolean', description: 'Also search gitignored/dependency trees.' },
             },
             required: ['query'],

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

@@ -357,19 +357,17 @@ export async function lstatPathsForMtime(paths, workDir, concurrency = Infinity,
     return out;
 }
 
-// Extra invalidation listeners: sibling modules with their own derived caches
-// (e.g. the broad find-enumeration cache in list-tool) register a clear
-// callback here so every write-invalidation event that drops the result/stat/
-// raw caches also drops theirs. Full clear is intentional — those entries are
-// cheap to rebuild and a path-scoped diff is not worth the coupling.
+// Extra invalidation listeners: sibling modules with derived caches receive
+// the normalized affected paths, or null for a full clear, so unrelated
+// project inventories survive writes in another temporary/project root.
 const EXTRA_INVALIDATION_LISTENERS = new Set();
 export function registerCacheInvalidationListener(fn) {
     if (typeof fn === 'function') EXTRA_INVALIDATION_LISTENERS.add(fn);
     return () => EXTRA_INVALIDATION_LISTENERS.delete(fn);
 }
-function runExtraInvalidationListeners() {
+function runExtraInvalidationListeners(affectedPaths = null) {
     for (const fn of EXTRA_INVALIDATION_LISTENERS) {
-        try { fn(); } catch { /* best-effort: one listener must not block others */ }
+        try { fn(affectedPaths); } catch { /* best-effort: one listener must not block others */ }
     }
 }
 
@@ -411,9 +409,7 @@ function cacheInvalidatePaths(paths) {
         deleteReadRangeIndexForPath(affected);
         bumpPathMutationGeneration(affected);
     }
-    // Broad enumeration entries are not path-scoped, so any partial
-    // invalidation still fully drops them (cheap to rebuild).
-    runExtraInvalidationListeners();
+    runExtraInvalidationListeners(affectedPaths);
 }
 
 export function invalidateBuiltinResultCache(paths = null) {

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

@@ -13,6 +13,12 @@
 import { stat } from 'node:fs/promises';
 
 const FS_REACHABILITY_DEADLINE_MS = 5000;
+// Under burst load the libuv threadpool can queue a healthy local stat past
+// the base deadline (slow ≠ dead). Before declaring the path unreachable,
+// keep waiting for the SAME pending probe up to this extended ceiling: a
+// loaded-but-alive filesystem answers within it, a dead mount stays silent.
+const FS_REACHABILITY_EXTENDED_MS = 15_000;
+let _lastSlowStatWarnAt = 0;
 
 // Resolve true when the path is reachable (exists OR cleanly absent — ENOENT,
 // EACCES, etc. are "the FS answered", let the real sync logic produce its own
@@ -34,8 +40,25 @@ export async function assertPathReachable(path, deadlineMs = FS_REACHABILITY_DEA
         deadline,
     ]);
     if (result === 'TIMEOUT') {
+        // Grace window: distinguish threadpool queueing from a dead mount by
+        // waiting longer for the probe that is still in flight.
+        let extTimer = null;
+        const extended = await Promise.race([
+            probe.finally(() => { if (extTimer) clearTimeout(extTimer); }),
+            new Promise((resolve) => {
+                extTimer = setTimeout(() => resolve('TIMEOUT'), Math.max(ms, FS_REACHABILITY_EXTENDED_MS - ms));
+            }),
+        ]);
+        if (extended !== 'TIMEOUT') {
+            const now = Date.now();
+            if (now - _lastSlowStatWarnAt > 30_000) {
+                _lastSlowStatWarnAt = now;
+                process.stderr.write(`[fs-reachability] slow stat >${ms}ms under load (resolved in grace window): ${path}\n`);
+            }
+            return extended;
+        }
         const err = new Error(
-            `path unreachable: stat exceeded ${ms}ms (possible dead mount / hung filesystem): ${path}`,
+            `path unreachable: stat exceeded ${FS_REACHABILITY_EXTENDED_MS}ms (possible dead mount / hung filesystem): ${path}`,
         );
         err.code = 'EFSUNREACHABLE';
         throw err;

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

@@ -1,5 +1,5 @@
 import { readdirSync } from 'fs';
-import { basename, relative } from 'path';
+import { basename, isAbsolute, relative } from 'path';
 import {
     coerceReadFamilyPathArg,
     extractGlobBaseDirectory,
@@ -415,17 +415,52 @@ export async function executeTreeTool(args, workDir, options = {}) {
 // known-incomplete and are NEVER cached.
 const FIND_ENUM_CACHE = new Map(); // key -> { files, expiresAt, gen }
 const FIND_ENUM_INFLIGHT = new Map(); // key -> { promise, controller, subscribers }
+const FIND_TARGETED_BATCHES_BY_RUNNER = new WeakMap();
+const FIND_ENUM_ROOT_GEN = new Map();
 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
-// stay invisible to broad find reuse for the whole TTL. Drop all entries on any
-// 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();
+// does not otherwise know about. Invalidate only inventories whose roots
+// overlap the written paths; a patch in an isolated temp root must not force
+// every active Project to rescan.
+function findEnumerationPathsOverlap(left, right) {
+    const contains = (base, target) => {
+        const rel = relative(base, target);
+        return rel === '' || (!isAbsolute(rel) && !/^\.\.(?:[\\/]|$)/.test(rel));
+    };
+    return contains(left, right) || contains(right, left);
+}
+function findEnumerationRootFromKey(key) {
+    return String(key).split('\u0000', 1)[0];
+}
+function findEnumerationRootGeneration(root) {
+    return FIND_ENUM_ROOT_GEN.get(root) || 0;
+}
+registerCacheInvalidationListener((affectedPaths) => {
+    if (!Array.isArray(affectedPaths) || affectedPaths.length === 0) {
+        FIND_ENUM_GEN += 1;
+        FIND_ENUM_ROOT_GEN.clear();
+        FIND_ENUM_CACHE.clear();
+        FIND_ENUM_INFLIGHT.clear();
+        return;
+    }
+    const keys = new Set([...FIND_ENUM_CACHE.keys(), ...FIND_ENUM_INFLIGHT.keys()]);
+    const affectedRoots = new Set();
+    for (const key of keys) {
+        const root = findEnumerationRootFromKey(key);
+        if (affectedPaths.some((affected) => findEnumerationPathsOverlap(root, affected))) {
+            affectedRoots.add(root);
+        }
+    }
+    for (const root of affectedRoots) {
+        FIND_ENUM_ROOT_GEN.set(root, findEnumerationRootGeneration(root) + 1);
+        for (const key of [...FIND_ENUM_CACHE.keys()]) {
+            if (findEnumerationRootFromKey(key) === root) FIND_ENUM_CACHE.delete(key);
+        }
+        for (const key of [...FIND_ENUM_INFLIGHT.keys()]) {
+            if (findEnumerationRootFromKey(key) === root) FIND_ENUM_INFLIGHT.delete(key);
+        }
+    }
 });
 
 function findEnumTtlMs() {
@@ -503,9 +538,10 @@ function subscribeToFindEnumeration(key, entry, signal = null) {
 async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMode, rgArgs, cwd, runRgImpl = runRg, bestEffort = false, signal = null }) {
     const ttl = findEnumTtlMs();
     const key = findEnumKey({ root, hidden, depth, includeNoise, ignoreMode });
+    const rootGen = findEnumerationRootGeneration(root);
     if (ttl > 0) {
         const hit = FIND_ENUM_CACHE.get(key);
-        if (hit && hit.gen === FIND_ENUM_GEN && hit.expiresAt > Date.now()) {
+        if (hit && hit.gen === FIND_ENUM_GEN && hit.rootGen === rootGen && hit.expiresAt > Date.now()) {
             return { files: hit.files, truncated: false, partial: false };
         }
         if (hit) FIND_ENUM_CACHE.delete(key); // expired
@@ -525,6 +561,7 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMo
         return { files: [], truncated: false, partial: true };
     }
     const genAtStart = FIND_ENUM_GEN;
+    const rootGenAtStart = rootGen;
     const controller = new AbortController();
     const entry = { promise: null, controller, subscribers: new Set() };
     entry.promise = (async () => {
@@ -536,8 +573,15 @@ async function getBroadEnumeration({ root, hidden, depth, includeNoise, ignoreMo
         // later query with a larger head_limit must re-run the enumeration.
         // 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 });
+        if (ttl > 0 && !truncated && !partial
+            && FIND_ENUM_GEN === genAtStart
+            && findEnumerationRootGeneration(root) === rootGenAtStart) {
+            FIND_ENUM_CACHE.set(key, {
+                files,
+                expiresAt: Date.now() + ttl,
+                gen: genAtStart,
+                rootGen: rootGenAtStart,
+            });
         }
         return { files, truncated, partial };
     })();
@@ -585,21 +629,82 @@ async function getTargetedFindEnumeration({
     const key = JSON.stringify([root, hidden, depth ?? '', includeNoise, terms]);
     const runs = context?.targetedRuns;
     if (runs?.has(key)) return runs.get(key);
-    const run = (async () => {
-        const rgArgs = ['--files', '--no-ignore'];
-        if (hidden) rgArgs.push('--hidden');
-        if (depth != null) rgArgs.push('--max-depth', String(depth));
-        for (const query of terms) rgArgs.push('--iglob', `*${escapeFindGlobLiteral(query)}*`);
-        rgArgs.push('.');
-        const stdout = await runRgImpl(rgArgs, { cwd: root, signal });
-        const paths = parseRgFileList(stdout).filter((path) =>
-            includeNoise || !path.split('/').some((segment) => NOISE_DIR_NAMES.has(segment)));
-        return {
-            files: paths,
-            truncated: Boolean(stdout && typeof stdout === 'object' && stdout.truncated),
-            partial: Boolean(stdout && typeof stdout === 'object' && stdout.partial),
+    let batches = FIND_TARGETED_BATCHES_BY_RUNNER.get(runRgImpl);
+    if (!batches) {
+        batches = new Map();
+        FIND_TARGETED_BATCHES_BY_RUNNER.set(runRgImpl, batches);
+    }
+    const batchKey = JSON.stringify([root, hidden, depth ?? '', includeNoise]);
+    let batch = batches.get(batchKey);
+    if (!batch) {
+        batch = {
+            terms: new Set(),
+            waiters: new Set(),
+            controller: new AbortController(),
         };
-    })();
+        batches.set(batchKey, batch);
+        setImmediate(async () => {
+            if (batches.get(batchKey) === batch) batches.delete(batchKey);
+            if (batch.waiters.size === 0) return;
+            const rgArgs = ['--files', '--no-ignore'];
+            if (hidden) rgArgs.push('--hidden');
+            if (depth != null) rgArgs.push('--max-depth', String(depth));
+            for (const query of batch.terms) {
+                rgArgs.push('--iglob', `*${escapeFindGlobLiteral(query)}*`);
+            }
+            if (!includeNoise) {
+                for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
+            }
+            rgArgs.push('.');
+            try {
+                const stdout = await runRgImpl(rgArgs, {
+                    cwd: root,
+                    signal: batch.controller.signal,
+                });
+                const paths = parseRgFileList(stdout).filter((path) =>
+                    includeNoise || !path.split('/').some((segment) => NOISE_DIR_NAMES.has(segment)));
+                const result = {
+                    files: paths,
+                    truncated: Boolean(stdout && typeof stdout === 'object' && stdout.truncated),
+                    partial: Boolean(stdout && typeof stdout === 'object' && stdout.partial),
+                };
+                for (const waiter of [...batch.waiters]) waiter.resolve(result);
+            } catch (error) {
+                for (const waiter of [...batch.waiters]) waiter.reject(error);
+            }
+        });
+    }
+    for (const term of terms) batch.terms.add(term);
+    const run = new Promise((resolve, reject) => {
+        let settled = false;
+        const waiter = {
+            resolve(value) {
+                if (settled) return;
+                settled = true;
+                batch.waiters.delete(waiter);
+                if (signal instanceof AbortSignal) signal.removeEventListener('abort', onAbort);
+                resolve(value);
+            },
+            reject(error) {
+                if (settled) return;
+                settled = true;
+                batch.waiters.delete(waiter);
+                if (signal instanceof AbortSignal) signal.removeEventListener('abort', onAbort);
+                reject(error);
+            },
+        };
+        const onAbort = () => {
+            waiter.reject(findEnumerationAbortError(signal));
+            if (batch.waiters.size === 0) {
+                try { batch.controller.abort(findEnumerationAbortError(signal)); } catch {}
+            }
+        };
+        batch.waiters.add(waiter);
+        if (signal instanceof AbortSignal) {
+            if (signal.aborted) onAbort();
+            else signal.addEventListener('abort', onAbort, { once: true });
+        }
+    });
     if (runs) runs.set(key, run);
     return run;
 }