mixdog 1.0.2 → 1.0.4

package/README.md

@@ -487,6 +487,14 @@ npm install
 npm run dev
 ```
 
+Desktop development uses a fresh, isolated test profile on each launch, including
+its data, daemon and tool connections. It does not copy the installed app's
+settings or sign-ins. The profile path is printed and retained in the system
+temporary directory for diagnosis. CDP uses port `9342`; if it is occupied, reuse
+the running test app or choose another port with `npm run dev -- --port 9343`.
+On Windows, `npm run e2e:direct` and `npm run e2e:direct:source` also use isolated
+profiles and port `9342` (override with `-- -Port 9343`).
+
 Both packages discover `*.test.mjs` and `*-test.mjs` under their `src/` and
 `scripts/` directories. Fast, slow, and live tests run in separate lanes;
 live checks need their corresponding built artifacts or services. See

package/package.json

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

package/src/defaults/skills/browser-use/SKILL.md

@@ -159,12 +159,20 @@ not as two blocks joined.
 
 ## Foreground vs background
 
-- Use the visible foreground page for shared-screen work, a requested visual
-  result, or the user's next action. `open` with `tab` reveals that exact page
-  and retains it for user handoff; `background:false` is a temporary reveal.
-- For result-only work, prefer a named `background:true` page; keep the user's
-  current page intact. Later calls may omit `background`: naming a support page
-  does not promote it. Reporting a result does not require revealing a page.
+- Default to named `background:true` pages; the panel stays closed and the
+  user's current page stays intact. If the answer can be given in the
+  conversation, keep the page hidden even when it produced the answer;
+  screenshots, reports, and result-only actions never need a reveal.
+- Reveal a page only with `open` and its `tab`, and only when the page itself
+  is what the user needs after the turn:
+  - **Deliverable** — the user asked to see, show, or keep a page open, or the
+    page is the output: an edited document or dashboard, a cart or checkout,
+    a submitted form's result.
+  - **Handoff** — the user must act on the page: sign-in, CAPTCHA, 2FA,
+    payment, approval, or an unfinished workflow they continue.
+- When the user refers to the page already visible in this session's panel,
+  act on that page instead of opening another.
+- Later calls may omit `background`: naming a support page does not promote it.
 - Background pages run concurrently, so independent background work can share
   one assistant turn.
 - Pages, tabs, URLs, and targets are session-local; sign-in state, cookies,

package/src/defaults/skills/goal-management/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: goal-management
-description: Manage durable goals, task progress, approvals, and completion.
-when_to_use: 'Explicit Goals, approved multi-round work (migrations, improvement passes); not single-turn tasks.'
+description: Manage the task list of approved work carried across turns, its progress, approvals, and completion.
+when_to_use: 'Explicit Goal (`goal` tool) requests, approved multi-turn work in progress (migrations, improvement passes); not single-turn tasks or recurring schedules.'
 dependencies:
   tools:
     - type: tool

package/src/runtime/agent/orchestrator/providers/anthropic-midstream-recovery.mjs

@@ -24,6 +24,7 @@ import {
 } from './retry-classifier.mjs';
 import { _classifyMidstreamError, _midstreamSleepWithAbort, stampAnthropicStreamOutcome } from './anthropic-sse.mjs';
 import { notifyCurrentAnthropicRateLimit } from './admission-scheduler.mjs';
+import { noteAbandonedUsage } from '../../../shared/llm/usage-context.mjs';
 
 export function createAnthropicMidState(attemptIndex) {
   return {
@@ -144,7 +145,7 @@ export function createAnthropicMidstreamRecovery({
    * `{ retry: false, value }` when a non-streaming replay produced the turn,
    * and throws the (stamped) error when the turn is over.
    */
-  const onStreamError = async ({ err, midState, controller, response, attemptIndex }) => {
+  const decideStreamError = async ({ err, midState, controller, response, attemptIndex }) => {
     // Canonical stream-outcome contract: stamp before ANY safety
     // decision below. The parser's stamped verdict (when present)
     // is authoritative — coarse midState.partialToolCall must not
@@ -309,6 +310,14 @@ export function createAnthropicMidstreamRecovery({
     throw err;
   };
 
+  // A thrown error carries its partial usage to the send's accounting; an
+  // attempt replaced by a retry or a non-streaming replay is noted here.
+  const onStreamError = async (args) => {
+    const decision = await decideStreamError(args);
+    noteAbandonedUsage(args.err?.partialUsage, args.err?.partialModel);
+    return decision;
+  };
+
   const exhaustedError = () => firstAttemptError || new Error(unreachableMessage);
 
   return { onStreamError, exhaustedError };

package/src/runtime/agent/orchestrator/runtime-core/goal-tool-defs.mjs

@@ -31,7 +31,7 @@ export const GOAL_TOOL_DEFS = Object.freeze([
     name: 'goal',
     title: 'Goal',
     description: [
-      'Durable tasks with an idle reminder for unfinished work. Create for an explicit Goal request, or approved work spanning several rounds or turns: staged refactors and migrations, repeated improvement passes, open-ended objectives that must be finished, with or without a time budget. Single-turn tasks, planning or estimates alone, and unaccepted proposals do not qualify.',
+      'Task list kept across turns, with an idle reminder for unfinished work. Use for an explicit Goal request or approved multi-turn work (staged refactors, migrations, improvement passes, open-ended objectives), optionally time-boxed. Not for single-turn tasks, plans or estimates alone, unaccepted proposals, recurring schedules, or work waiting weeks on external events.',
       'Obtain required approval, load the goal-management skill for lifecycle and completion policy, then create or reconcile the Goal before starting approved work. Mutations need the latest revision.',
     ].join(' '),
     annotations: {

package/src/runtime/agent/orchestrator/session/cache/scoped-cache.mjs

@@ -20,9 +20,6 @@ export function scopedCacheGeneration() {
 // sessionId -> Map<key, { content, ts, firstToolUseId, depRoots }>
 const _scopedBySession = new Map();
 
-// sessionId -> Map<absPath, Set<cacheKey>>  — reverse index for O(1) path-targeted invalidation
-const _scopedReverseIdx = new Map();
-
 function _canonicalArgs(args) {
   if (args === null || args === undefined) return '';
   if (typeof args !== 'object') return String(args);
@@ -243,16 +240,6 @@ function _pathTouchesRoot(absPath, root) {
   );
 }
 
-function _dropScopedEntry(sessionId, key) {
-  _scopedBySession.get(sessionId)?.delete(key);
-  const index = _scopedReverseIdx.get(sessionId);
-  if (!index) return;
-  for (const [path, keys] of index) {
-    keys.delete(key);
-    if (keys.size === 0) index.delete(path);
-  }
-}
-
 /**
  * Look up a cached result for a deterministic multi-file-scope tool. Returns
  * null on miss. On hit returns the full entry
@@ -265,7 +252,7 @@ export function tryScopedToolCached({ sessionId, toolName, args, cwd, touch = tr
   const key = _scopedKey(toolName, args, cwd);
   const entry = map.get(key);
   if (!entry || Date.now() - entry.ts >= SCOPED_CACHE_TTL_MS) {
-    if (entry) _dropScopedEntry(sessionId, key);
+    if (entry) map.delete(key);
     return null;
   }
   if (touch) {
@@ -301,33 +288,12 @@ export function setScopedToolCached({
     _scopedBySession.set(sessionId, map);
   }
   const depRoots = _scopedDependencyRoots(toolName, args, cwd);
-  if (
-    !setBoundedTextCacheEntry(
-      map,
-      key,
-      { content, ts: Date.now(), firstToolUseId: toolUseId || null, depRoots },
-      { maxEntries: MAX_PER_SESSION, onEvict: (evictedKey) => _dropScopedEntry(sessionId, evictedKey) }
-    )
-  )
-    return;
-  // Register key in reverse index for dependency roots. Exact root hits use
-  // O(1) lookup; touched files under a root are caught by the small prefix scan
-  // in clearScopedToolsForSessionPaths (MAX_PER_SESSION is 100).
-  let ridx = _scopedReverseIdx.get(sessionId);
-  if (!ridx) {
-    ridx = new Map();
-    _scopedReverseIdx.set(sessionId, ridx);
-  }
-  const _registerAbs = (abs) => {
-    if (!abs || typeof abs !== 'string') return;
-    let s = ridx.get(abs);
-    if (!s) {
-      s = new Set();
-      ridx.set(abs, s);
-    }
-    s.add(key);
-  };
-  for (const dep of depRoots) _registerAbs(dep);
+  setBoundedTextCacheEntry(
+    map,
+    key,
+    { content, ts: Date.now(), firstToolUseId: toolUseId || null, depRoots },
+    { maxEntries: MAX_PER_SESSION }
+  );
 }
 
 /**
@@ -338,78 +304,51 @@ export function clearScopedToolsForSession(sessionId) {
   if (!sessionId) return;
   mutationGeneration += 1;
   _scopedBySession.delete(sessionId);
-  _scopedReverseIdx.delete(sessionId);
 }
 
 /**
- * Targeted scoped-cache invalidation: evict only entries whose cache
- * key is associated with at least one of the given touched paths. Uses a
- * reverse index (absPath → Set<cacheKey>) for exact root hits plus a bounded
- * root-prefix scan for files nested under cached directories/globs. Full wipe
+ * Targeted scoped-cache invalidation: evict only entries whose registered
+ * dependency roots contain, or are contained by, at least one of the given
+ * touched paths (single bounded pass; MAX_PER_SESSION entries). Full wipe
  * when paths cannot be resolved.
  */
 export function clearScopedToolsForSessionPaths(sessionId, touchedPaths, cwd) {
   if (!sessionId || !Array.isArray(touchedPaths) || touchedPaths.length === 0) return;
   mutationGeneration += 1;
-  const map = _scopedBySession.get(sessionId);
-  if (!map) return;
-  const absPaths = touchedCacheKeys(touchedPaths, cwd);
-  if (absPaths.length === 0) {
-    // Fallback: can't resolve — full wipe.
-    _scopedBySession.delete(sessionId);
-    _scopedReverseIdx.delete(sessionId);
-    return;
-  }
-  const ridx = _scopedReverseIdx.get(sessionId);
-  const evictedKeys = new Set();
-  for (const abs of absPaths) evictScopedEntriesForPath(map, ridx, abs, evictedKeys);
-  // Remove evicted keys from any other reverse-index sets they appeared in; prune empty Sets.
-  if (ridx && evictedKeys.size > 0) {
-    for (const [absKey, keySet] of ridx) {
-      for (const k of evictedKeys) keySet.delete(k);
-      if (keySet.size === 0) ridx.delete(absKey);
-    }
-  }
+  if (!_scopedBySession.has(sessionId)) return;
+  clearSessionForAbsPaths(sessionId, touchedCacheKeys(touchedPaths, cwd));
 }
 
-// The normalized absolute cache keys of the touched paths; unresolvable
-// entries are dropped.
+// Normalized, deduplicated absolute cache keys of the touched paths;
+// unresolvable entries are dropped.
 function touchedCacheKeys(touchedPaths, cwd) {
   const base = cwd && typeof cwd === 'string' ? cwd : process.cwd();
-  return touchedPaths
-    .map((p) => {
-      if (typeof p !== 'string' || p.length === 0) return null;
-      try {
-        return _normalizeCacheKey(_pathNorm(_pathIsAbs(p) ? p : _pathResolve(base, p)));
-      } catch {
-        return null;
-      }
-    })
-    .filter(Boolean);
+  const out = new Set();
+  for (const p of touchedPaths) {
+    if (typeof p !== 'string' || p.length === 0) continue;
+    try {
+      out.add(_normalizeCacheKey(_pathNorm(_pathIsAbs(p) ? p : _pathResolve(base, p))));
+    } catch {
+      /* unresolvable: dropped */
+    }
+  }
+  out.delete('');
+  return [...out];
 }
 
-// Evicts every entry keyed to `abs` in the reverse index, then every entry
-// whose dependency roots cover it. An index miss may still touch a cached
-// directory/root dependency (e.g. grep path:"src" then edit src/a.mjs); the
-// prefix scan is bounded by MAX_PER_SESSION and prevents stale scoped hits.
-function evictScopedEntriesForPath(map, ridx, abs, evictedKeys) {
-  const keys = ridx ? ridx.get(abs) : null;
-  if (keys && keys.size > 0) {
-    for (const key of keys) {
-      if (map.has(key)) {
-        map.delete(key);
-        evictedKeys.add(key);
-      }
-    }
-    keys.clear();
-    ridx.delete(abs);
+// Evicts the session's entries whose dependency roots touch any of the
+// already-normalized `absPaths` in a single pass. Empty `absPaths` means the
+// paths were unresolvable: full wipe.
+function clearSessionForAbsPaths(sessionId, absPaths) {
+  if (absPaths.length === 0) {
+    _scopedBySession.delete(sessionId);
+    return;
   }
+  const map = _scopedBySession.get(sessionId);
+  if (!map) return;
   for (const [key, entry] of map) {
     const roots = Array.isArray(entry?.depRoots) ? entry.depRoots : [];
-    if (roots.some((root) => _pathTouchesRoot(abs, root))) {
-      map.delete(key);
-      evictedKeys.add(key);
-    }
+    if (roots.some((root) => absPaths.some((abs) => _pathTouchesRoot(abs, root)))) map.delete(key);
   }
 }
 
@@ -418,8 +357,10 @@ function evictScopedEntriesForPath(map, ridx, abs, evictedKeys) {
 // that no watcher reports.
 registerCacheInvalidationListener((paths) => {
   mutationGeneration += 1;
-  for (const sessionId of _scopedBySession.keys()) {
-    if (paths?.length) clearScopedToolsForSessionPaths(sessionId, paths);
-    else clearScopedToolsForSession(sessionId);
+  if (paths?.length) {
+    const absPaths = touchedCacheKeys(paths);
+    for (const sessionId of [..._scopedBySession.keys()]) clearSessionForAbsPaths(sessionId, absPaths);
+  } else {
+    for (const sessionId of [..._scopedBySession.keys()]) clearScopedToolsForSession(sessionId);
   }
 });

package/src/runtime/agent/orchestrator/session/compact/runner.mjs

@@ -133,7 +133,12 @@ function summarySendOpts(opts) {
     onSteerMessage: undefined,
     signal: combinedSignal(opts.signal || opts.sendOpts?.signal || null, opts.timeoutMs || HANDOFF_TIMEOUT_MAX_MS),
   };
-  if (opts.sessionId) sendOpts.sessionId = `${opts.sessionId}:compact`;
+  // The `:compact` id isolates provider state (cache, socket pool); the
+  // spend still belongs to the source session.
+  if (opts.sessionId) {
+    sendOpts.sessionId = `${opts.sessionId}:compact`;
+    sendOpts.usageSessionId = opts.sessionId;
+  }
   if (opts.promptCacheKey || opts.sendOpts?.promptCacheKey) {
     sendOpts.promptCacheKey = `${opts.promptCacheKey || opts.sendOpts.promptCacheKey}:compact`;
   }

package/src/runtime/agent/orchestrator/session/loop/fresh-context.mjs

@@ -78,6 +78,8 @@ function summarizeConversation(target, ctx) {
   );
   const summarySession = {
     id: `${sessionId || 'unknown'}:compact`,
+    // Usage attribution: background sessions stay background.
+    sourceType: sessionRef?.sourceType,
     provider: target.providerName,
     model: target.model,
     cwd: sessionRef?.cwd,

package/src/runtime/agent/orchestrator/session/loop/tool-exec/before-hook.mjs

@@ -3,7 +3,7 @@
  * ask for approval before the tool runs.
  */
 import { resolvePreToolAskApproval } from '../tool-helpers.mjs';
-import { runAbortable } from '../../../../../shared/abort-race.mjs';
+import { runAbortable, throwIfAborted } from '../../../../../shared/abort-race.mjs';
 
 const isArgsObject = (value) => value && typeof value === 'object' && !Array.isArray(value);
 
@@ -67,8 +67,12 @@ export async function applyBeforeToolHook({
       const denied = await askApproval(call, { callerSessionId, executeOpts, toolApprovalHook, decision });
       if (denied) return denied;
     }
-  } catch {
-    // Hooks are policy extensions. A broken hook must not wedge the agent loop.
+  } catch (error) {
+    throwIfAborted(executeOpts.signal);
+    // A failed policy check fails closed: the tool must not run.
+    return {
+      denial: `Error: tool "${name}" denied: PreToolUse policy check failed: ${error?.message || String(error)}`,
+    };
   }
   return call;
 }

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

@@ -46,16 +46,13 @@ const STAT_CACHE = new Map(); // fullPath → { ts, stat }
 const STAT_CACHE_TTL_MS = 5_000;
 const STAT_CACHE_MAX_ENTRIES = 2_000;
 const RAW_CONTENT_CACHE = new Map(); // fullPath → { ts, mtimeMs, ctimeMs, size, rawBuf }
-const RAW_CONTENT_INFLIGHT = new Map(); // canonical path → { generation, promise }
+const RAW_CONTENT_INFLIGHT = new Map(); // canonical path → { path, promise }
 const RAW_CONTENT_CACHE_TTL_MS = 30_000;
 // 64: a parallel read batch fanning out over a component directory easily
 // tops 16 files; at 16 the batch thrashed its own cache before re-reads hit.
 // The 64MB byte cap below still bounds memory.
 const RAW_CONTENT_CACHE_MAX_ENTRIES = 64;
-const PATH_MUTATION_GENERATIONS = new Map(); // canonical path/root → monotonic generation
-const PATH_MUTATION_GENERATION_MAX_ENTRIES = 4096;
-let PATH_MUTATION_GLOBAL_GENERATION = 0;
-const READ_ONLY_STAT_INFLIGHT = new Map(); // kind + canonical path → { generation, promise }
+const READ_ONLY_STAT_INFLIGHT = new Map(); // kind + canonical path → { path, promise }
 const RAW_CONTENT_CACHE_MAX_BYTES = envByteBudget(
   'MIXDOG_RAW_CONTENT_CACHE_MAX_BYTES',
   'MIXDOG_RAW_CONTENT_CACHE_MAX_MB',
@@ -74,25 +71,6 @@ function cachePathsOverlap(a, b) {
   return a.startsWith(b.endsWith(sep) ? b : `${b}${sep}`) || b.startsWith(a.endsWith(sep) ? a : `${a}${sep}`);
 }
 
-function bumpPathMutationGeneration(path) {
-  const key = canonicalCachePath(path);
-  PATH_MUTATION_GENERATIONS.set(key, (PATH_MUTATION_GENERATIONS.get(key) || 0) + 1);
-  while (PATH_MUTATION_GENERATIONS.size > PATH_MUTATION_GENERATION_MAX_ENTRIES) {
-    const oldest = PATH_MUTATION_GENERATIONS.keys().next().value;
-    if (!oldest) break;
-    PATH_MUTATION_GENERATIONS.delete(oldest);
-  }
-}
-
-function getPathMutationGeneration(path) {
-  const key = canonicalCachePath(path);
-  let generation = PATH_MUTATION_GLOBAL_GENERATION;
-  for (const [changedPath, value] of PATH_MUTATION_GENERATIONS) {
-    if (cachePathsOverlap(key, changedPath)) generation += value;
-  }
-  return generation;
-}
-
 function cacheEntryOverlapsPaths(entry, affectedPaths) {
   const entryPaths = Array.isArray(entry?.paths) ? entry.paths : [];
   const entryScopes = Array.isArray(entry?.scopes) ? entry.scopes : [];
@@ -237,12 +215,12 @@ export async function runResultCacheInFlight(key, compute, options = {}) {
   return subscribeResultCacheInFlight(entry, subscriberSignal);
 }
 
-// A concurrent caller joins the read already in flight for this key instead
-// of issuing a second syscall; a mutation bumps the path generation, so an
-// entry recorded before it is never joined.
-async function runInFlightForGeneration(inFlight, key, generation, start) {
+// Invalidation detaches only affected in-flight entries. New readers never
+// join a pre-mutation operation, while its existing subscribers still finish.
+// Lookups need no scan of the project's historical mutations on every read.
+async function runPathInFlight(inFlight, key, path, start) {
   const existing = inFlight.get(key);
-  if (existing?.generation === generation) return await existing.promise;
+  if (existing) return await existing.promise;
   const promise = Promise.resolve()
     .then(start)
     .finally(() => {
@@ -250,23 +228,21 @@ async function runInFlightForGeneration(inFlight, key, generation, start) {
         inFlight.delete(key);
       }
     });
-  inFlight.set(key, { generation, promise });
+  inFlight.set(key, { path, promise });
   return await promise;
 }
 
 export async function runRawContentInFlight(fullPath, loader = fsPromises.readFile) {
   const key = canonicalCachePath(fullPath);
-  return await runInFlightForGeneration(RAW_CONTENT_INFLIGHT, key, getPathMutationGeneration(key), () =>
-    loader(fullPath)
-  );
+  return await runPathInFlight(RAW_CONTENT_INFLIGHT, key, key, () => loader(fullPath));
 }
 
 export async function runReadOnlyStatInFlight(fullPath, loader = fsPromises.stat, kind = 'stat') {
   const canonicalPath = canonicalCachePath(fullPath);
-  return await runInFlightForGeneration(
+  return await runPathInFlight(
     READ_ONLY_STAT_INFLIGHT,
     `${kind}|${canonicalPath}`,
-    getPathMutationGeneration(canonicalPath),
+    canonicalPath,
     () => loader(fullPath)
   );
 }
@@ -484,8 +460,8 @@ function cacheInvalidateAll() {
   STAT_CACHE.clear();
   RAW_CONTENT_CACHE.clear();
   RAW_CONTENT_CACHE_BYTES = 0;
-  PATH_MUTATION_GENERATIONS.clear();
-  PATH_MUTATION_GLOBAL_GENERATION += 1;
+  RAW_CONTENT_INFLIGHT.clear();
+  READ_ONLY_STAT_INFLIGHT.clear();
   runExtraInvalidationListeners();
 }
 
@@ -495,6 +471,11 @@ function cacheInvalidatePaths(paths) {
     cacheInvalidateAll();
     return;
   }
+  for (const inFlight of [RAW_CONTENT_INFLIGHT, READ_ONLY_STAT_INFLIGHT]) {
+    for (const [key, entry] of inFlight) {
+      if (affectedPaths.some((affected) => cachePathsOverlap(entry.path, affected))) inFlight.delete(key);
+    }
+  }
   for (const [key, entry] of RESULT_CACHE_INFLIGHT) {
     const scopes = Array.isArray(entry.scopes) ? entry.scopes : [];
     if (
@@ -522,7 +503,6 @@ function cacheInvalidatePaths(paths) {
   }
   for (const affected of affectedPaths) {
     deleteReadRangeIndexForPath(affected);
-    bumpPathMutationGeneration(affected);
   }
   runExtraInvalidationListeners(affectedPaths);
 }

package/src/runtime/agent/orchestrator/tools/builtin/lib/grep-path-fanout.mjs

@@ -14,11 +14,13 @@ import { isUncOrSmbPath, resolveSearchScope } from '../search-path-diagnostics.m
 import { buildGrepRgArgs } from '../search-builders.mjs';
 import { runRgWindowedLines } from '../native-search-runner.mjs';
 import { statReachable } from '../fs-reachability.mjs';
+import { runSharedNativeScan } from './shared-native-scan.mjs';
 import { markScopedCacheIncomplete } from '../../../session/cache/scoped-cache-outcome.mjs';
 import { GREP_CONTEXT_MAX, hasUnsupportedRipgrepRegex } from '../arg-guard.mjs';
 import { resolveSearchWindow } from './search-input-helpers.mjs';
 import { formatGrepFanoutSections, formatGrepOutput, grepNoMatchesBody } from './grep-output.mjs';
 import { expandGrepAnchorContextOutput } from './grep-context-expander.mjs';
+import { resolveGrepScope } from './grep-request.mjs';
 
 // Case-insensitive path keys on Windows, where rg echoes the operand path
 // in whatever case the caller wrote it.
@@ -30,12 +32,11 @@ function pathKey(value) {
 // The single-pattern request the combined path[] pass can answer, parsed
 // the way the canonical single-path parsing in search-grep-tool.mjs does
 // (keep in sync); null when the arguments fall outside its narrow
-// eligibility: single pattern, no glob/type, default flags, content-ish or
+// eligibility: single pattern, no type, default flags, content-ish or
 // files_with_matches mode. MIXDOG_GREP_PATH_COMBINED=0 disables.
 function combinedPathRequest(args, defaultHeadLimit) {
   if (
     process.env.MIXDOG_GREP_PATH_COMBINED === '0' ||
-    args.glob ||
     args.type ||
     args.multiline === true ||
     args['-o'] === true ||
@@ -81,8 +82,7 @@ function combinedPathRequest(args, defaultHeadLimit) {
 // order; null when one is a glob, unreachable, or on a share — the legacy
 // fan-out owns those diagnostics.
 async function resolvePathRoots(list, workDir) {
-  const roots = [];
-  for (const p of list) {
+  const roots = await Promise.all(list.map(async (p) => {
     const cleaned = normalizeInputPath(p);
     if (hasGlobMagic(cleaned)) return null;
     const resolved = resolveSearchScope(cleaned, workDir);
@@ -93,11 +93,21 @@ async function resolvePathRoots(list, workDir) {
     } catch {
       return null;
     }
-    roots.push({
+    return {
       arg: p,
       abs: normalizeOutputPath(isAbsolute(resolved) ? await trueCasePath(resolved) : resolved),
       isDir: st.isDirectory(),
-    });
+    };
+  }));
+  if (roots.some((root) => !root)) return null;
+  // An overlapping operand would scan a file twice and then attribute both
+  // copies to each containing section. Keep independent scope semantics.
+  for (let i = 0; i < roots.length; i++) {
+    const left = pathKey(roots[i].abs).replace(/\/+$/, '');
+    for (let j = i + 1; j < roots.length; j++) {
+      const right = pathKey(roots[j].abs).replace(/\/+$/, '');
+      if (left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`)) return null;
+    }
   }
   return roots;
 }
@@ -190,17 +200,23 @@ async function runCombinedPathFanout({ args, list, workDir, options, callContext
   const roots = await resolvePathRoots(list, workDir);
   if (!roots) return null;
   const { headLimit, offset } = request;
-  const rgArgs = combinedPathRgArgs(args, request, roots, workDir);
+  const rgArgs = await combinedPathRgArgs(args, request, roots, workDir);
+  if (!rgArgs) return null;
   const perWindow = headLimit === Infinity ? 300 : offset + headLimit + 4;
   const cap = Math.min(4000, Math.max(400, perWindow * roots.length));
   let streamed;
   try {
-    streamed = await runRgWindowedLines(
-      rgArgs,
-      { cwd: workDir, signal: options.signal },
-      { offset: 0, limit: cap, summaryLimit: 0 }
-    );
+    const runWindowedLines =
+      typeof options.__runRgWindowedLines === 'function' ? options.__runRgWindowedLines : runRgWindowedLines;
+    streamed = await runSharedNativeScan(runWindowedLines, {
+      cwd: workDir,
+      argv: rgArgs,
+      window: { offset: 0, limit: cap, summaryLimit: 0 },
+      scopes: roots.map((root) => root.abs),
+      signal: options.signal,
+    });
   } catch {
+    options.signal?.throwIfAborted();
     return null;
   }
   if (!streamed.complete || streamed.partial) return null;
@@ -211,26 +227,36 @@ async function runCombinedPathFanout({ args, list, workDir, options, callContext
 }
 
 // One rg invocation over every root's files at once.
-function combinedPathRgArgs(args, request, roots, workDir) {
-  return buildGrepRgArgs({
-    patterns: [request.pattern],
-    includeNoise: args.include_noise === true,
-    text: args.text === true,
-    searchPath: workDir,
-    globPatterns: [],
-    outputMode: request.outMode,
-    caseInsensitive: request.caseInsensitive,
-    showLineNumbers: true,
-    beforeN: null,
-    afterN: null,
-    contextN: null,
-    multilineMode: false,
-    fileType: '',
-    onlyMatching: false,
-    pcre2: false,
-    withFilename: true,
-    candidateFiles: roots.map((r) => r.abs),
-  });
+async function combinedPathRgArgs(args, request, roots, workDir) {
+  const perRoot = await Promise.all(roots.map(async (root) => {
+    const scope = await resolveGrepScope({ ...args, path: root.arg }, workDir);
+    if (scope.result !== undefined) return null;
+    return buildGrepRgArgs({
+      patterns: [request.pattern],
+      includeNoise: args.include_noise === true,
+      text: args.text === true,
+      searchPath: isAbsolute(scope.searchPath) ? root.abs : scope.searchPath,
+      // Match buildGrepScope: an explicit file operand wins over its glob.
+      globPatterns: root.isDir ? scope.normalizedGlobPatterns : [],
+      outputMode: request.outMode,
+      caseInsensitive: request.caseInsensitive,
+      showLineNumbers: true,
+      beforeN: null,
+      afterN: null,
+      contextN: null,
+      multilineMode: false,
+      fileType: '',
+      onlyMatching: false,
+      pcre2: false,
+      withFilename: true,
+    }).slice(0, -1);
+  }));
+  if (perRoot.some((argv) => !argv)) return null;
+  const first = JSON.stringify(perRoot[0]);
+  // Native filters are rooted at each operand. Only identical normalized
+  // rules (including explicit noise-directory exceptions) may share a scan.
+  if (perRoot.some((argv) => JSON.stringify(argv) !== first)) return null;
+  return [...perRoot[0], ...roots.map((root) => root.abs)];
 }
 
 // The per-root sections in argument order; roots without a hit collapse
@@ -252,6 +278,7 @@ async function renderCombinedPathSections(request, roots, byRoot, bodyContext) {
 // recursion bottoms out after one level. Results retain input order even
 // though every path starts immediately.
 export async function runGrepPathFanout(input) {
+  input.options.signal?.throwIfAborted();
   const combined = await runCombinedPathFanout(input);
   if (combined !== null) return combined;
   const { args, list, workDir, executeChildBuiltinTool, readStateScope, options, callContextCharBudget } = input;