mixdog 1.0.1 → 1.0.3

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.1",
+  "version": "1.0.3",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -31,7 +31,7 @@
     "!scripts/bench/",
     "!scripts/recall-bench-*.txt",
     "!scripts/*-test.mjs",
-    "!scripts/*.test.mjs",
+    "!scripts/**/*.test.mjs",
     "!scripts/tool-contracts/",
     "!scripts/provider-toolcall/",
     "!scripts/session-transport/",

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/setup/references/actions.md

@@ -64,11 +64,11 @@ Read this when choosing a `setup` mutation.
 | Delete an existing schedule/webhook | `delete_automation` |
 | Enable/disable a schedule/webhook | `set_automation_enabled` |
 | Webhook listener enabled state, port, or domain | `set_webhook_config` |
-| Desktop keep-awake, usage pin, or Computer observe-only state | `set_desktop_settings` |
+| Desktop keep-awake, run in background after window close, usage pin, or Computer observe-only state | `set_desktop_settings` |
 | Desktop theme, display language, side panels, or zoom | `set_appearance` |
 | Register a Project and optionally set its display alias | `save_project` |
 | Unregister a Project without deleting its files | `remove_project` |
-| Revoke one linked device; re-pairing restores access | `revoke_linked_device` |
+| Revoke one linked device by its client id from `status connection`; re-pairing restores access | `revoke_linked_device` |
 | Managed local model context allocation; null restores automatic | `set_local_context` |
 
 ## Routes and workflow
@@ -116,7 +116,10 @@ values through chat.
 ## Built-in features
 
 Read `status features` and distinguish installation, enabled state, and live
-bridge state.
+bridge state. `status features` covers Git, Memory, Office, Code Tidy, Local
+Provider and Web Search plus Browser/Computer bridge activity; voice status and
+the Browser Use / Computer Use installed and enabled markers are read with
+`status desktop`.
 
 - Git, Memory, Office, and Local Provider are install-first capabilities.
 - Git and Office installation run on the Desktop when this conversation is

package/src/defaults/skills/setup/references/surfaces.md

@@ -37,7 +37,8 @@ An attached Desktop or TUI may navigate and return `opened:true`.
 - Settings → Providers: API-key, OAuth, local providers, and usage sign-in.
 - Extensions → Plugin → Git & GitHub: Git/GitHub CLI installation and connection.
 - Settings → Connection: web-app pairing and linked devices.
-- Settings → System: update, keep-awake, and Doctor.
+- Settings → System: update, keep-awake, run in background after the window
+  closes, and Doctor.
 - Projects: Project registration, name, Project Memories, and Common Memory.
 - Workflows: workflow packs, Main and Web Search defaults, and agent editing.
 - Extensions → Plugin: Built-in cards and plugins.
@@ -48,12 +49,15 @@ the user to Desktop.
 
 ## Desktop-backed settings
 
-Setup can read and change Desktop appearance, keep-awake, usage pin,
-Computer observe-only, Browser/Computer/voice installation and toggles,
-Projects, and linked-device revocation through the attached
+Setup can read and change Desktop appearance, keep-awake, run in background,
+usage pin, Computer observe-only, Browser/Computer/voice installation and
+toggles, Projects, and linked-device revocation through the attached
 Desktop. A receipt identifies `scope:desktop-host`; appearance is not applied
 to the paired browser. No Desktop claimant means no confirmed change.
 
+Computer observe-only has no Desktop settings control; setup is its only
+supported route. Usage pin is the pin toggle on the activity rail usage card.
+
 Schedules/webhooks and workflow/agent/skill definitions use their runtime
 actions directly. These do not require clicking their Desktop rails.
 

package/src/runtime/agent/orchestrator/context/role-instructions.mjs

@@ -281,7 +281,6 @@ export function composeSystemPrompt(opts) {
   // pre-tool preamble toward English.
   const environmentParts = [
     opts.sessionStartContext,
-    opts.projectInstructionsContext,
     opts.environmentContext,
     opts.languageContext,
   ].map(trimmedPromptSlice);

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/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/session/manager/session-prompt-composition.mjs

@@ -86,7 +86,7 @@ export function composeSessionSystem(opts, { profile, providerName, modelName, s
   const languageContext = leadOnly ? _buildLeadLanguageContext() : '';
   const shellEnvironmentContext = buildShellEnvironmentContext(opts, ownerIsAgent, surface.toolsForRouting);
   // Persisted env tail: refreshSessionBp3Environment rebuilds the env block
-  // as [session, project, bp3EnvironmentContext], so the language block must
+  // as [session, bp3EnvironmentContext], so the language block must
   // already sit at the end of this string to stay last after a refresh.
   const environmentTailContext = [shellEnvironmentContext, languageContext].filter(Boolean).join('\n\n---\n\n');
   const composed = composeSystemPrompt({

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);
 }