mixdog 0.9.117 → 0.9.119

package/README.md

@@ -44,13 +44,11 @@ harnesses — **78/89** vs Claude Code's **77/89** (within single-run noise)
 and **75/89** matching Codex CLI — while finishing faster, ending leaner,
 and costing less.
 
-Each comparison matches the primary model and reasoning level on
-both sides, comparing each product as shipped: mixdog routes scoped
-read-only Explorer lookups to a smaller model, mirroring Claude Code's
-built-in Explore subagent (Haiku 4.5 by default in the 2.1.x baseline).
-Codex CLI ships no equivalent helper — the Sol-led mixdog run used GPT-5.6
-Luna for that scoped Explorer work. Results are self-reported single runs
-(`k=1`, 2026-08), not leaderboard submissions.
+The published mixdog runs are strict single-model benchmarks: one primary
+model, one session, no sub-agent delegation or helper-model lookups. Each
+comparison matches the primary model and reasoning level against the native
+harness's standard run. Results are self-reported single runs (`k=1`,
+2026-08), not leaderboard submissions.
 
 #### Claude Opus 5 vs Claude Code
 
@@ -105,9 +103,9 @@ every number above live under `benchmarks/terminal-bench-2.1/`.
   below).
 - Installable web app over relay pairing — scan a QR code to open your
   running sessions in a phone browser and keep going from any network.
-- Optional Discord/Telegram channels, webhook endpoints, and cron schedules
-  with quiet hours for remote/event-driven workflows; channel voice messages
-  are transcribed locally with a managed Whisper server.
+- Optional Discord/Telegram channels and cron schedules with quiet hours for
+  remote/event-driven workflows; channel voice messages are transcribed
+  locally with a managed Whisper server.
 - First-class Windows support: ConPTY terminals, PowerShell-aware shell
   profiles, and a one-click desktop installer.
 
@@ -126,9 +124,8 @@ every number above live under `benchmarks/terminal-bench-2.1/`.
 
 - Skills, MCP servers, hooks, and plugins load through standard-compatible
   interfaces.
-- Built-in Web Search, Explorer, and Maintainer services, plus editable
-  starter agents (`worker`, `heavy-worker`, `reviewer`) and user-authored
-  custom roles.
+- Built-in Web Search and Maintainer services, plus editable starter agents
+  (`worker`, `heavy-worker`, `reviewer`) and user-authored custom roles.
 
 ## Run
 
@@ -168,8 +165,7 @@ mixdog --provider anthropic-oauth --model claude-opus-5 worker "fix the failing
 mixdog --provider openai-oauth --model gpt-5.6-sol reviewer "review the current diff"
 ```
 
-Roles: `explore`, `worker`, `heavy-worker`, `reviewer`, `maintainer`,
-`web-researcher`.
+Roles: `worker`, `heavy-worker`, `reviewer`, `maintainer`, `web-researcher`.
 
 ## TUI basics
 
@@ -208,8 +204,7 @@ current Anthropic models.
 Workflows and agents are Markdown definition packs (`WORKFLOW.md`,
 `AGENT.md`). Built-ins ship with mixdog; custom packs live under the data
 directory (`workflows/<id>/`, `agents/<id>/`) and are edited on the desktop
-app's Workflows page. Schedules and webhooks are also managed in the desktop
-app.
+app's Workflows page. Schedules are managed in the desktop app as well.
 
 ## Desktop app
 
@@ -230,9 +225,8 @@ wizard covers first-run setup. For development run `npm run dev` inside
 - **Editor and review** — Monaco editor pane with LSP integration, git and
   inline diff viewers, and turn-by-turn review of agent edits with approval
   cards.
-- **Source control** — git dock for staging/commits/branches,
-  auto-generated commit messages, GitHub CLI integration, pull-request
-  browsing, and a dedicated review pane.
+- **Source control** — git dock for staging, commits, and branches, with
+  auto-generated commit messages.
 - **File explorer** — Windows-Explorer-grade folder pane: breadcrumbs and
   path box, ribbon toolbar, places/drives/tree sidebar, grouped grid and
   details views with shell icons and thumbnails, rubber-band selection,
@@ -243,8 +237,8 @@ wizard covers first-run setup. For development run `npm run dev` inside
 - **Studio** — media studio for image and video generation over
   authenticated provider lanes, with a persistent local gallery, reference
   images, and per-model resolution/aspect/duration controls.
-- **Automation** — visual editors for workflow and agent packs, cron
-  schedules, webhooks, and channel integrations.
+- **Automation** — visual editors for workflow and agent packs, plus cron
+  schedules.
 - **Settings hub** — provider auth, capability sweep, git identity, and
   QR device pairing for the installable web app, preloaded so every
   category opens instantly.
@@ -254,7 +248,6 @@ wizard covers first-run setup. For development run `npm run dev` inside
 ```bash
 npm run smoke                # fast core feature smoke
 npm run smoke:all            # feature-surface smoke suite
-npm run smoke:tui            # TUI feature smoke
 npm run test:tool-contracts  # optional tool contract suite
 npm run build:tui            # build the bundled Ink TUI
 npm run audit:models         # inspect model catalog metadata
@@ -313,9 +306,9 @@ vendor/
 
 ## Published package contents
 
-The npm tarball ships `README.md`, `src/`, `vendor/`, and runtime `scripts/`
-only (`package.json#files`); tests, smokes, benches, and `docs/` stay in the
-repository.
+The npm tarball ships the README, notices and licenses, runtime sources,
+vendored runtime code, and selected scripts. `package.json#files` is the
+canonical package-content list.
 
 ## License
 

package/package.json

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

package/scripts/tool-stress.mjs

@@ -11,6 +11,7 @@ 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;
@@ -23,14 +24,15 @@ function record(tool, ms, result, expectRe) {
   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)}`);
+  if (/^Error:|resource pressure|ERESOURCEPRESSURE|EAGAIN/i.test(text)) s.errs.push(text.slice(0, 1000));
+  else if (expectRe && !expectRe.test(text)) s.errs.push(`unexpected output: ${text.slice(0, 1000)}`);
 }
 
 async function timed(tool, expectRe, fn) {
   const t0 = Date.now();
   try {
-    const out = await fn();
+    const raw = await fn();
+    const out = normalizeToolEnvelope(raw).result;
     record(tool, Date.now() - t0, out, expectRe);
     return out;
   } catch (err) {

package/src/output-styles/detailed.md

@@ -11,14 +11,15 @@ keep-coding-instructions: true
 Detailed — a teammate's update; clarity outranks terseness.
 
 - Outcome first, then what a cold reader needs: complete user-language
-  sentences, expanded jargon, rationale where it adds value; no filler or
-  process narration.
-- Structure matches complexity: plain prose for simple answers; headers,
-  bullets, or tables (short enumerable facts only, explained outside) when
-  they aid scanning.
+  sentences readable in one pass, expanded jargon, rationale only where it
+  adds value; no filler or process narration.
+- Structure matches complexity: casual answers stay plain prose; reports
+  order outcome → changes → verification → next steps.
+- 3+ parallel facts become a flat `- ` list: one fact per bullet, one line
+  when possible, ordered by importance, parallel phrasing, related points
+  merged, never nested; tables only for short enumerable facts.
 - No hard cap, but brevity first: the shortest report understood without
-  rereads (~10 lines is plenty for most tasks); expand only when complexity
-  demands; trivial results stay 1–2 sentences.
-- Cite `file:line`; snippets only when load-bearing.
-- Never dump raw tool output; blockers and failures in one clause each.
-- Never name this style unless asked.
+  rereads (~10 lines is plenty); trivial results stay 1–2 sentences.
+- Cite `file:line`; snippets only when load-bearing; never dump raw tool
+  output; blockers and failures in one clause each; never name this style
+  unless asked.

package/src/output-styles/minimal.md

@@ -9,7 +9,7 @@ keep-coding-instructions: true
 
 Minimal — net result in plain sentences; hard cap 400 characters.
 
-- Concept level only: no headings, bullets, labels, or per-file detail, even
-  for reports.
+- Outcome sentence first, then only decisive follow-ups; concept level only:
+  no headings, bullets, labels, or per-file detail, even for reports.
 - Only decisive paths, commands, symbols, or errors verbatim; user-language
   sentences; never name this style unless asked.

package/src/output-styles/simple.md

@@ -10,12 +10,12 @@ keep-coding-instructions: true
 
 Simple — a teammate's update, tightened; hard cap 800 characters.
 
-- Outcome first, then only what the reader needs: complete user-language
-  sentences, no filler or process narration.
-- Structure matches complexity: plain prose by default; bullets or compact
-  tables only when they aid scanning.
-- Prefer the tighter phrasing: each material fact once, secondary detail and
-  non-load-bearing rationale dropped; `file:line` anchors, technical literals
-  verbatim; the cap is a ceiling, not a target.
+- Outcome first in complete user-language sentences; no filler or process
+  narration; reports order outcome → changes → verification.
+- Short answers stay plain prose; 3+ parallel facts become a flat `- `
+  list — one fact per bullet, one line, ordered by importance, never nested.
+- Each material fact once, secondary detail and non-load-bearing rationale
+  dropped; `file:line` anchors, technical literals verbatim; the cap is a
+  ceiling, not a target.
 - Never dump raw tool output; blockers and failures in one clause each.
   Never name this style unless asked.

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

@@ -254,6 +254,31 @@ export function _composeShellFailure(statusMarker, errorPrefix, warningBlock, pa
     return `${errorPrefix}${statusMarker}${warningBlock ? `\n${warningBlock}` : ''}\n\n${payload}`;
 }
 
+const INLINE_HOIST_CLEANUP_PATHS = new Set();
+let inlineHoistExitHookInstalled = false;
+function scheduleInlineHoistCleanup(file) {
+    if (!file) return;
+    INLINE_HOIST_CLEANUP_PATHS.add(file);
+    if (!inlineHoistExitHookInstalled) {
+        inlineHoistExitHookInstalled = true;
+        process.once('exit', () => {
+            for (const pending of INLINE_HOIST_CLEANUP_PATHS) {
+                try { unlinkSync(pending); } catch {}
+            }
+            INLINE_HOIST_CLEANUP_PATHS.clear();
+        });
+    }
+    // A long-lived pwsh standby can emit its completion marker just before a
+    // nested native process has opened the hoisted script. Keep the transport
+    // file briefly past marker settlement; normal daemon lifetime cleans it
+    // here, while the exit hook prevents one-shot CLI/test leftovers.
+    const timer = setTimeout(() => {
+        INLINE_HOIST_CLEANUP_PATHS.delete(file);
+        try { unlinkSync(file); } catch {}
+    }, 10_000);
+    timer.unref?.();
+}
+
 export async function executeBashTool(args, workDir, options = {}) {
     const requestedCwd = args.cwd ?? args.workdir;
     const cwdResult = resolveOptionalCwd(requestedCwd, workDir);
@@ -848,7 +873,7 @@ export async function executeBashTool(args, workDir, options = {}) {
     finally {
         combinedBashAbort?.cleanup?.();
         if (_inlineHoistPath) {
-            try { unlinkSync(_inlineHoistPath); } catch { /* best-effort cleanup */ }
+            scheduleInlineHoistCleanup(_inlineHoistPath);
         }
         if (shellEffects.mutationMode === 'paths') {
             invalidateBuiltinResultCache(shellEffects.paths);

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/list-tool.mjs

@@ -1,5 +1,5 @@
-import { readdirSync } from 'fs';
-import { basename, relative } from 'path';
+import { readdirSync, watch } from 'fs';
+import { basename, isAbsolute, relative } from 'path';
 import {
     coerceReadFamilyPathArg,
     extractGlobBaseDirectory,
@@ -22,6 +22,7 @@ import {
     statCacheSet,
     statPathsForMtime,
     registerCacheInvalidationListener,
+    invalidateBuiltinResultCache,
 } from './cache-layers.mjs';
 import { formatListSize, formatMtime } from './list-formatting.mjs';
 import {
@@ -415,17 +416,106 @@ 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();
+const FIND_ENUM_WATCHERS = 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;
+}
+function invalidateFindEnumerationRoot(root) {
+    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 ensureFindEnumerationWatcher(root) {
+    const existing = FIND_ENUM_WATCHERS.get(root);
+    if (existing) {
+        existing.touchedAt = Date.now();
+        return true;
+    }
+    try {
+        const pending = new Set();
+        const record = { watcher: null, timer: null, touchedAt: Date.now() };
+        const flush = () => {
+            record.timer = null;
+            const paths = [...pending];
+            pending.clear();
+            invalidateBuiltinResultCache(paths.length ? paths : [root]);
+            const warm = setTimeout(() => void prewarmFindEnumeration(root), 100);
+            warm.unref?.();
+        };
+        record.watcher = watch(root, { recursive: true, persistent: false }, (_event, filename) => {
+            const rel = filename == null ? '' : String(filename);
+            pending.add(rel ? resolveAgainstCwd(rel, root) : root);
+            if (record.timer) clearTimeout(record.timer);
+            record.timer = setTimeout(flush, 40);
+            record.timer.unref?.();
+        });
+        record.watcher.on('error', () => {
+            if (record.timer) clearTimeout(record.timer);
+            FIND_ENUM_WATCHERS.delete(root);
+            invalidateFindEnumerationRoot(root);
+            try { record.watcher.close(); } catch {}
+        });
+        record.watcher.unref?.();
+        FIND_ENUM_WATCHERS.set(root, record);
+        if (FIND_ENUM_WATCHERS.size > 8) {
+            const oldest = [...FIND_ENUM_WATCHERS.entries()]
+                .filter(([candidate]) => candidate !== root)
+                .sort((a, b) => a[1].touchedAt - b[1].touchedAt)[0];
+            if (oldest) {
+                FIND_ENUM_WATCHERS.delete(oldest[0]);
+                try { oldest[1].watcher.close(); } catch {}
+                invalidateFindEnumerationRoot(oldest[0]);
+            }
+        }
+        return true;
+    } catch {
+        return false;
+    }
+}
+registerCacheInvalidationListener((affectedPaths) => {
+    if (!Array.isArray(affectedPaths) || affectedPaths.length === 0) {
+        const roots = new Set([
+            ...FIND_ENUM_CACHE.keys(),
+            ...FIND_ENUM_INFLIGHT.keys(),
+        ].map(findEnumerationRootFromKey));
+        for (const root of roots) {
+            if (!FIND_ENUM_WATCHERS.has(root)) invalidateFindEnumerationRoot(root);
+        }
+        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) {
+        invalidateFindEnumerationRoot(root);
+    }
 });
 
 function findEnumTtlMs() {
@@ -503,9 +593,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 +616,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 +628,16 @@ 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) {
+            const watched = ensureFindEnumerationWatcher(root);
+            FIND_ENUM_CACHE.set(key, {
+                files,
+                expiresAt: watched ? Number.MAX_SAFE_INTEGER : Date.now() + ttl,
+                gen: genAtStart,
+                rootGen: rootGenAtStart,
+            });
         }
         return { files, truncated, partial };
     })();
@@ -556,13 +656,23 @@ export async function prewarmFindEnumeration(root) {
     try {
         if (!root || typeof root !== 'string') return;
         const hidden = true, includeNoise = false, depth = null;
-        const rgArgs = ['--files', '--no-require-git', '--hidden'];
-        for (const ex of DEFAULT_IGNORE_GLOBS) rgArgs.push('--glob', ex);
-        rgArgs.push('.');
+        const common = ['--files', '--no-require-git', '--hidden'];
+        const all = ['--files', '--no-ignore', '--hidden'];
+        for (const ex of DEFAULT_IGNORE_GLOBS) {
+            common.push('--glob', ex);
+            all.push('--glob', ex);
+        }
+        common.push('.');
+        all.push('.');
         await getBroadEnumeration({
             root: normalizeOutputPath(root),
             hidden, depth, includeNoise, ignoreMode: 'git',
-            rgArgs, cwd: root, bestEffort: true,
+            rgArgs: common, cwd: root, bestEffort: true,
+        });
+        await getBroadEnumeration({
+            root: normalizeOutputPath(root),
+            hidden, depth, includeNoise, ignoreMode: 'targeted-all',
+            rgArgs: all, cwd: root, bestEffort: true,
         });
     } catch { /* best-effort warm; never surface */ }
 }
@@ -585,21 +695,115 @@ 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),
+    try {
+        const inventoryArgs = ['--files', '--no-ignore'];
+        if (hidden) inventoryArgs.push('--hidden');
+        if (depth != null) inventoryArgs.push('--max-depth', String(depth));
+        if (!includeNoise) {
+            for (const ex of DEFAULT_IGNORE_GLOBS) inventoryArgs.push('--glob', ex);
+        }
+        inventoryArgs.push('.');
+        const inventory = await getBroadEnumeration({
+            root: normalizeOutputPath(root),
+            hidden,
+            depth,
+            includeNoise,
+            ignoreMode: 'targeted-all',
+            rgArgs: inventoryArgs,
+            cwd: root,
+            runRgImpl,
+            signal,
+        });
+        if (!inventory.truncated && !inventory.partial) {
+            const lowerTerms = terms.map((term) => term.toLowerCase());
+            return {
+                files: inventory.files.filter((path) => {
+                    const lower = path.toLowerCase();
+                    return lowerTerms.some((term) => lower.includes(term));
+                }),
+                truncated: false,
+                partial: false,
+            };
+        }
+    } catch {
+        if (signal?.aborted) throw findEnumerationAbortError(signal);
+    }
+    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;
 }

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

@@ -113,6 +113,42 @@ export async function warmNativeSearchServer() {
   }
 }
 
+/** Fast Windows process table snapshot served by the resident native helper.
+ *  Returns [{pid,parentPid,identity}] or null; callers stay conservative when
+ *  the binary is unavailable or the request misses its short deadline. */
+export async function tryNativeProcessSnapshot({ timeoutMs = 750 } = {}) {
+  if (process.platform !== 'win32' || process.env.MIXDOG_SEARCH_SERVER === '0') return null;
+  let server = _ensureServer();
+  if (!server && await warmNativeSearchServer()) server = _ensureServer();
+  if (!server) return null;
+  const id = ++server.sequence;
+  _setServerReferenced(server, true);
+  const response = await new Promise((resolve) => {
+    let settled = false;
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+      if (server.pending.size === 0) _setServerReferenced(server, false);
+    };
+    const timer = setTimeout(() => {
+      server.pending.delete(id);
+      settle(null);
+    }, Math.max(1, Number(timeoutMs) || 750));
+    timer.unref?.();
+    server.pending.set(id, { resolve: settle, reject: () => settle(null) });
+    try {
+      server.child.stdin.write(`${JSON.stringify({ id, processSnapshot: true })}\n`);
+    } catch {
+      server.pending.delete(id);
+      settle(null);
+    }
+  });
+  if (!response || response.error || !Array.isArray(response.rows)) return null;
+  return response.rows;
+}
+
 export async function tryServeSearch(argsList, execOptions = {}, opts = {}) {
   if (process.env.MIXDOG_SEARCH_SERVER === '0') return null;
   const server = _ensureServer();