mixdog 1.0.1 → 1.0.3

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;

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

@@ -9,6 +9,7 @@ import { GREP_AUTO_CONTEXT_LINES, trueCasePath } from '../path-utils.mjs';
 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 {
   dedupeFanoutMatchLines,
   formatGrepFanoutSections,
@@ -67,13 +68,15 @@ async function fanoutPrefilterCandidates(request) {
       multilineMode,
       withFilename: false,
     });
-    const pre = await request.runWindowedLines(
-      prefilterArgs,
-      { cwd: scope.cwd, signal: options.signal },
+    const pre = await runSharedNativeScan(request.runWindowedLines, {
+      cwd: scope.cwd,
+      argv: prefilterArgs,
       // Whole-scope fallback pass: the broad admission lane keeps it
       // from competing with interactive searches for disk bandwidth.
-      { offset: 0, limit: GREP_FANOUT_PREFILTER_FILE_CAP, summaryLimit: 0, bulkHint: true }
-    );
+      window: { offset: 0, limit: GREP_FANOUT_PREFILTER_FILE_CAP, summaryLimit: 0, bulkHint: true },
+      scopes: [grepResolvedPath],
+      signal: options.signal,
+    });
     return pre.complete && !pre.partial ? pre.lines : null;
   } catch {
     options.signal?.throwIfAborted();
@@ -245,11 +248,13 @@ async function streamCombinedLines(request, scope) {
   const combinedCap = Math.min(4000, Math.max(400, perPatternWindow * patterns.length));
   const combinedBulkHint = request.normalizedGlobPatterns.length === 0 && !request.fileType;
   try {
-    return await request.runWindowedLines(
-      combinedArgs,
-      { cwd: scope.cwd, signal: options.signal },
-      { offset: 0, limit: combinedCap, summaryLimit: 0, bulkHint: combinedBulkHint }
-    );
+    return await runSharedNativeScan(request.runWindowedLines, {
+      cwd: scope.cwd,
+      argv: combinedArgs,
+      window: { offset: 0, limit: combinedCap, summaryLimit: 0, bulkHint: combinedBulkHint },
+      scopes: [request.grepResolvedPath],
+      signal: options.signal,
+    });
   } catch {
     options.signal?.throwIfAborted();
     return null;

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

@@ -90,7 +90,7 @@ function rebaseAbsoluteGlob(glob, rootFwd) {
   };
 }
 
-async function resolveGrepScope(args, workDir) {
+export async function resolveGrepScope(args, workDir) {
   let searchPath = args.path || '.';
   const rawGlobs = uniqueStrings(stringList(args.glob).map(normalizeInputPath));
   if (hasGlobMagic(searchPath)) {

package/src/runtime/agent/orchestrator/tools/builtin/lib/shared-native-scan.mjs

@@ -0,0 +1,12 @@
+// Shares only identical in-flight native scans (no persistent result). The
+// existing single-flight layer isolates subscriber cancellation and detaches
+// a scan after a mutation without interrupting its current readers.
+import { runResultCacheInFlight } from '../cache-layers.mjs';
+
+export function runSharedNativeScan(runWindowedLines, { cwd, argv, window, scopes, signal }) {
+  return runResultCacheInFlight(
+    `grep-path-scan:${JSON.stringify([cwd, argv, window])}`,
+    ({ signal: sharedSignal }) => runWindowedLines(argv, { cwd, signal: sharedSignal }, window),
+    { signal, scopes }
+  );
+}

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

@@ -1,6 +1,8 @@
 import { open } from 'node:fs/promises';
 import { hashText } from './hash-utils.mjs';
+import { runResultCacheInFlight } from './cache-layers.mjs';
 import {
+  canonicalCachePath,
   getReadRangeIndex,
   nearestReadRangeAnchor,
   maybeRecordReadRangeAnchor,
@@ -13,6 +15,18 @@ import { READ_MAX_SCAN_BYTES, READ_STREAM_TIMEOUT_MS } from './read-constants.mj
 export async function readSourceWindows(path, intervals, { signal } = {}) {
   signal?.throwIfAborted();
   if (!intervals.length) return new Map();
+  const snapshot = intervals.map(({ start, end }) => ({ start, end }));
+  const key = `source-windows:${canonicalCachePath(path)}:${JSON.stringify(snapshot.map((w) => [w.start, w.end]))}`;
+  const shared = await runResultCacheInFlight(
+    key,
+    ({ signal: sharedSignal }) => scanSourceWindows(path, snapshot, sharedSignal),
+    { signal, scopes: [path] }
+  );
+  return new Map(shared);
+}
+
+async function scanSourceWindows(path, intervals, signal) {
+  signal?.throwIfAborted();
   const handle = await open(path, 'r');
   try {
     const st = await handle.stat();

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,30 +1,30 @@
 {
-  "version": "0.1.30",
+  "version": "0.1.31",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-darwin-arm64",
-      "sha256": "cf306f716eeacb46b4a6a99b94ceb97f20be6facc7e4c6aa3274124e38a13efc"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-darwin-arm64",
+      "sha256": "7fbbb99fd98da1fee7d3cdb90c73c9b4ec663a8ea108bbc0f7ee30e194571ed1"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-darwin-x64",
-      "sha256": "2ed1d6d98bee1db750c5b9df86ee2affa59f0afce28e2753772dca1dcdf9dd6d"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-darwin-x64",
+      "sha256": "8cdbcdf3e207ead5ba274b87363ba1e8acc2c68d5912d95a29cd89cbecdc3c46"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-linux-arm64",
-      "sha256": "9963d0fb086bcd99341436458b207b6e521e9750bf75f817f0e6e99ebf7a30db"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-linux-arm64",
+      "sha256": "704361e56ee605d6dd5edcb014e3cc0c3e11b7909639d5d8cacc9d75ad1134d2"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-linux-x64",
-      "sha256": "79c6811c6bb3e05f4e048ebbe98bf28429e4b82763106c488d929668a2326cba"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-linux-x64",
+      "sha256": "ef80b2bb372e98e5e71f11cf720fc709ec79f187d95c00bcef3b3c8d23f22f47"
     },
     "win32-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-win32-arm64.exe",
-      "sha256": "8a1c8d623ee6e54948da2c77f5a8def5c9eafc3c6f2866c0c46c91bdaae393d0"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-win32-arm64.exe",
+      "sha256": "8fe669f56b6bd17705cdd24e16e705a40dc4ffe210fad0e9692d51c365a9a072"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.30/mixdog-graph-win32-x64.exe",
-      "sha256": "8d123e5044aee4b41e820361bd0dd1012a09a2da93a0074d21774602505784f4"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.31/mixdog-graph-win32-x64.exe",
+      "sha256": "ca2e4045fd4757b4b4e39de9d4df7790d9bcccc083ffca96a6f0cffbb1130f1d"
     }
   }
 }

package/src/runtime/agent/orchestrator/tools/patch/apply-patch/codex-batch.mjs

@@ -2,6 +2,7 @@
 // target), then apply it in one shot under path locks with all-or-nothing
 // rollback.
 import { parsePatch } from 'diff';
+import { throwIfAborted } from '../../../../../shared/abort-race.mjs';
 import { withBuiltinPathLocks } from '../../builtin.mjs';
 import { withAdvisoryLocks } from '../../builtin/advisory-lock.mjs';
 import { wrapPatchMutationOutput } from '../mutation-output.mjs';
@@ -155,7 +156,7 @@ export async function runCodexBatch({ batch, basePath, v4aConvertOpts, rejectedV
 // it whenever the batch fails — by returned Error text OR by a thrown error
 // (V4A rename, persistence) — so mode:"atomic" really is all-or-nothing
 // instead of leaving an earlier commit in place.
-export function applyCodexBatchWithRollback({ batch, basePath, dryRun, readStateScope, options, runBatch }) {
+export function applyCodexBatchWithRollback({ batch, basePath, dryRun, readStateScope, abortSignal, options, runBatch }) {
   const { lockPaths, v4aRenamePlan } = batch;
   const registerUiDiff = (rollbackSnapshots) =>
     registerCommittedPatchUiDiff({
@@ -168,6 +169,7 @@ export function applyCodexBatchWithRollback({ batch, basePath, dryRun, readState
     });
   return withBuiltinPathLocks(lockPaths, () =>
     withAdvisoryLocks(lockPaths, async () => {
+      throwIfAborted(abortSignal);
       let rollbackSnapshots = [];
       if (!dryRun) {
         try {

package/src/runtime/agent/orchestrator/tools/patch/dispatch.mjs

@@ -8,6 +8,7 @@ import { countLabel, formatNativeSummary, kindLabel, traceNativeApply } from './
 import { unlink } from 'node:fs/promises';
 import { dirname as pathDirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
+import { throwIfAborted } from '../../../../shared/abort-race.mjs';
 import {
   normalizeOutputPath,
   invalidateBuiltinResultCache,
@@ -154,6 +155,7 @@ export async function dispatchNativePatch({
         dryRun,
         fuzzy: fuzz > 0,
         readStateScope,
+        signal,
       });
       if (!/^Error:/i.test(String(recovered || '').trimStart())) {
         return `${recovered}\n[native transport unavailable; create-only patch completed with the JS engine]`;
@@ -326,19 +328,19 @@ function findParsedForRow(row, parsed, basePath) {
   return null;
 }
 
-async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope }) {
+async function applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope, signal }) {
   const kind = classifyEntry(entry);
   const headerName = entryHeaderName(entry, kind);
   const fullPath = resolveEntryPath(basePath, headerName);
   const displayPath = normalizeOutputPath(stripDiffPrefix(headerName));
-  if (kind === 'create') await applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readStateScope });
-  else if (kind === 'delete') await applyJsDeleteEntry(fullPath, displayPath, { dryRun, readStateScope });
-  else await applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy, readStateScope });
+  if (kind === 'create') await applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readStateScope, signal });
+  else if (kind === 'delete') await applyJsDeleteEntry(fullPath, displayPath, { dryRun, readStateScope, signal });
+  else await applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy, readStateScope, signal });
   const { added, removed } = countHunkChanges(entry.hunks);
   return { kind, fullPath, displayPath, added, removed };
 }
 
-async function applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readStateScope }) {
+async function applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readStateScope, signal }) {
   // Add File is create-only. atomicWrite checks the absent-target
   // expectation again so a file appearing after preflight is not replaced.
   assertAddTargetAbsent(fullPath, displayPath);
@@ -350,9 +352,11 @@ async function applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readSt
   }
   const content = joinTextLinesForPatch(addedLines);
   if (dryRun) return;
+  throwIfAborted(signal);
   mkdirSync(pathDirname(fullPath), { recursive: true });
   try {
     await atomicWrite(fullPath, content, {
+      signal,
       sessionId: readStateScope,
       expectedTargetSnapshot: { exists: false },
     });
@@ -369,16 +373,17 @@ async function applyJsCreateEntry(entry, fullPath, displayPath, { dryRun, readSt
   recordReadSnapshotForPath(fullPath, readStateScope, { source: 'apply_patch_js', isPartialView: false });
 }
 
-async function applyJsDeleteEntry(fullPath, displayPath, { dryRun, readStateScope }) {
+async function applyJsDeleteEntry(fullPath, displayPath, { dryRun, readStateScope, signal }) {
   lstatRegularPatchFile(fullPath, displayPath);
   if (dryRun) return;
+  throwIfAborted(signal);
   await unlink(fullPath);
   invalidateBuiltinResultCache([fullPath]);
   markCodeGraphDirtyPaths([fullPath]);
   clearReadSnapshotForPath(fullPath, readStateScope);
 }
 
-async function applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy, readStateScope }) {
+async function applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy, readStateScope, signal }) {
   const preMutationStat = lstatRegularPatchFile(fullPath, displayPath);
   const { writePath, snapshotStat } = resolvePatchWriteTarget(fullPath, displayPath, preMutationStat);
   // Rewrite path: decode by BOM, re-encode into the same codec, and keep every
@@ -393,11 +398,13 @@ async function applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy,
   });
   const content = encodePatchTargetContent(joinTextLinesForPatch(updatedLines), rawEnc);
   if (dryRun) return;
+  throwIfAborted(signal);
   // The expected-target snapshot closes the read→write window: if anything
   // rewrote this file after we read it, the write fails instead of silently
   // clobbering it (and instead of inheriting a stale "body delivered" claim).
   try {
     await atomicWrite(writePath, content, {
+      signal,
       sessionId: readStateScope,
       expectedTargetSnapshot: snapshotStat
         ? {
@@ -427,13 +434,14 @@ async function applyJsUpdateEntry(entry, fullPath, displayPath, { dryRun, fuzzy,
   });
 }
 
-export async function dispatchJsPatchEntries({ rows, parsed, basePath, dryRun, fuzzy, readStateScope }) {
+export async function dispatchJsPatchEntries({ rows, parsed, basePath, dryRun, fuzzy, readStateScope, signal }) {
   const applied = [];
   for (const row of rows || []) {
     const entry = findParsedForRow(row, parsed, basePath);
     if (!entry) throw new Error(`apply_patch: missing parsed entry for ${row.displayPath}`);
     try {
-      applied.push(await applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope }));
+      throwIfAborted(signal);
+      applied.push(await applyJsParsedEntry(entry, basePath, { dryRun, fuzzy, readStateScope, signal }));
     } catch (err) {
       return `Error: ${err?.message || String(err)}`;
     }

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

@@ -66,6 +66,7 @@ async function apply_patch(rawArgs, cwd, options = {}) {
     basePath,
     dryRun,
     readStateScope,
+    abortSignal,
     options,
     runBatch: () =>
       runCodexBatch({

package/src/runtime/agent/orchestrator/tools/patch/wave.mjs

@@ -2,6 +2,7 @@
 // JS writer split. Both the Codex batch and the ordered sequence share these
 // apply semantics.
 import { parsePatch } from 'diff';
+import { throwIfAborted } from '../../../../shared/abort-race.mjs';
 import { symlinkWriteTarget } from '../builtin/atomic-write.mjs';
 import { dispatchNativePatch, dispatchJsPatchEntries } from './dispatch.mjs';
 import { patchTargetUsesUtf16 } from './matcher.mjs';
@@ -33,6 +34,7 @@ export function parseConvertedUnifiedPatch(unified) {
 // whether earlier waves already committed to disk.
 export async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewrites: whr }, basePath, opts) {
   const { fuzz, rejectPartial, dryRun, fuzzy, readStateScope, abortSignal } = opts;
+  throwIfAborted(abortSignal);
   // Create entries use the JS atomic writer even inside the base path. Its
   // expected-absent snapshot makes Add File create-only under external races;
   // the native patch engine intentionally supports overwrite-style additions.
@@ -47,6 +49,7 @@ export async function applyParsedWave({ parsed: wparsed, entries: wentries, head
   // binary that predates this build's byte-fidelity contract is not used at
   // all — everything takes the JS writer instead.
   const engineContractOk = await nativePatchSessionSatisfiesContract();
+  throwIfAborted(abortSignal);
   // Codec routing only concerns entries that REWRITE bytes; a delete does not.
   // An unverified engine, however, must receive no work at all — deletes
   // included — so the whole wave takes the JS writer.
@@ -117,6 +120,7 @@ export async function applyParsedWave({ parsed: wparsed, entries: wentries, head
       dryRun,
       fuzzy,
       readStateScope,
+      signal: abortSignal,
     });
     if (isPatchErrorText(jsResult)) return { executor, error: jsResult };
     resultParts.push(jsResult);

package/src/runtime/browser-bridge/input-fields.mjs

@@ -404,7 +404,7 @@ export const BROWSER_INPUT_FIELDS = {
     background: {
       type: 'boolean',
       description:
-        'true creates/targets a hidden support page; false reveals it; omitted never promotes a named one. open without true keeps it for user handoff.',
+        'true creates/targets a hidden support page; false reveals it until task end; omitted never promotes a named one. open without true keeps it for user handoff.',
     },
   },
 };

package/src/runtime/browser-bridge/tool-defs.mjs

@@ -22,7 +22,7 @@ import { BROWSER_INPUT_FIELDS } from './input-fields.mjs';
 const BROWSER_DESCRIPTION =
   "Drive Mixdog's in-app Chromium directly for rendered, signed-in or interactive pages; public page text uses web_fetch, external windows computer. " +
   'Load the browser-use skill before first use. ' +
-  'Background for results; open retains a handoff, background:false reveals temporarily. Respect user-closed panels. ' +
+  'Background by default; reveal only via open for a deliverable or handoff. Respect user-closed panels. ' +
   'Task end cleans owned pages/restores temporary panels; user pages persist. ' +
   'hide folds the panel; close_tab closes named background pages only. ' +
   'Pages are session-local; sign-in/storage shared; never provide session_id. ' +

package/src/runtime/computer-bridge/actions.mjs

@@ -72,19 +72,6 @@ for (const name of [
       'key',
     ].includes(name),
     focusGuard: ['invoke', 'set_value', 'toggle'].includes(name),
-    focusContinuation: [
-      'invoke',
-      'click',
-      'double_click',
-      'right_click',
-      'middle_click',
-      'triple_click',
-      'mouse_down',
-      'mouse_up',
-      'mouse_move',
-      'drag',
-      'scroll',
-    ].includes(name),
     policy: 'act',
   });
 }

package/src/runtime/media/adapters/antigravity-image.mjs

@@ -11,6 +11,7 @@ import { randomUUID } from 'node:crypto';
 import { resolveAntigravityAuth } from '../auth.mjs';
 import { timeoutSignal } from '../bounded-signal.mjs';
 import { upstreamError } from '../upstream-error.mjs';
+import { geminiUsage } from '../media-usage.mjs';
 import { geminiImageRequestBody, pickGeminiImagePart } from './gemini-image.mjs';
 import { CONTENT_ENDPOINTS, antigravityHeaders } from '../../agent/orchestrator/providers/antigravity-oauth-tokens.mjs';
 import { frameAndParseSse } from '../../agent/orchestrator/providers/lib/sse-framing.mjs';
@@ -35,6 +36,7 @@ function antigravityImageRequestBody({ projectId, model, prompt, options = {}, r
 export function antigravityImageParts(sseText) {
   const parts = [];
   let failure = null;
+  let usageMetadata = null;
   for (const event of frameAndParseSse(sseText).events) {
     if (event.error) continue;
     const value = event.value;
@@ -43,10 +45,12 @@ export function antigravityImageParts(sseText) {
     const chunk = value?.response && typeof value.response === 'object' ? value.response : value;
     const candidate = chunk?.candidates?.[0];
     parts.push(...(candidate?.content?.parts || []));
+    // usageMetadata is cumulative; the last chunk that carries it is the total.
+    if (chunk?.usageMetadata) usageMetadata = chunk.usageMetadata;
     const blocked = chunk?.promptFeedback?.blockReason;
     if (blocked && !failure) failure = `prompt blocked (${blocked})`;
   }
-  return { parts, failure };
+  return { parts, failure, usage: geminiUsage(usageMetadata) };
 }
 
 export async function generateImage(
@@ -68,6 +72,6 @@ export async function generateImage(
     signal: timeoutSignal(signal, REQUEST_TIMEOUT_MS),
   });
   if (!res.ok) throw upstreamError('Antigravity image', res.status, await res.text().catch(() => ''));
-  const { parts, failure } = antigravityImageParts(await res.text());
-  return pickGeminiImagePart(parts, 'Antigravity', failure);
+  const { parts, failure, usage } = antigravityImageParts(await res.text());
+  return pickGeminiImagePart(parts, 'Antigravity', failure, usage);
 }

package/src/runtime/media/adapters/codex-image.mjs

@@ -12,6 +12,7 @@ import { timeoutSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
+import { responsesUsage, withReportedUsage } from '../media-usage.mjs';
 import { CODEX_OAUTH_ORIGINATOR, CODEX_RESPONSES_URL } from '../../agent/orchestrator/providers/openai-oauth.mjs';
 import {
   codexUserAgent,
@@ -32,6 +33,12 @@ function imageTool(options = {}) {
 
 function collectImage(event, state) {
   const item = event?.item;
+  // Terminal Responses events carry the orchestrator's token usage. It does
+  // not include the hosted image tool's own tokens.
+  if (['response.completed', 'response.failed', 'response.incomplete'].includes(event?.type)) {
+    state.usage = responsesUsage(event?.response?.usage) || state.usage;
+    return;
+  }
   if (event?.type === 'response.output_item.done' && item?.type === 'image_generation_call') {
     if (typeof item.result === 'string' && item.result.length > 0) state.final = item.result;
     if (typeof item.model === 'string') state.actualModel = item.model;
@@ -142,12 +149,16 @@ export async function generateImage(
 
   const b64 = state.final || state.partial;
   if (!b64) {
-    throw mediaError(`ChatGPT returned no image data${failure ? `: ${failure}` : ''}`, 'MEDIA_EMPTY_RESULT', 502);
+    throw withReportedUsage(
+      mediaError(`ChatGPT returned no image data${failure ? `: ${failure}` : ''}`, 'MEDIA_EMPTY_RESULT', 502),
+      state.usage
+    );
   }
   return {
     bytes: decodeBase64Media(b64, 'ChatGPT image'),
     mime: 'image/png',
     revisedPrompt: state.revisedPrompt,
     actualModel: state.actualModel || null,
+    usage: state.usage || null,
   };
 }

package/src/runtime/media/adapters/gemini-image.mjs

@@ -11,6 +11,7 @@ import { timeoutSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
+import { geminiUsage, withReportedUsage } from '../media-usage.mjs';
 
 const BASE_URL = 'https://generativelanguage.googleapis.com/v1beta/models';
 const REQUEST_TIMEOUT_MS = 180_000;
@@ -51,20 +52,25 @@ async function post(model, key, body, signal, fetchFn) {
  * First inline image among a candidate's parts. A text-only answer is the
  * model's refusal and surfaces as such; it is never retried.
  */
-export function pickGeminiImagePart(parts, label, failure = null) {
+export function pickGeminiImagePart(parts, label, failure = null, usage = null) {
   const image = parts.find((part) => part?.inlineData?.data);
   if (!image) {
     const refusal = failure || parts.find((part) => typeof part?.text === 'string' && part.text.trim())?.text || '';
-    throw mediaError(
-      `${label} returned no image data${refusal ? `: ${String(refusal).slice(0, 200)}` : ''}`,
-      'MEDIA_EMPTY_RESULT',
-      502
+    throw withReportedUsage(
+      mediaError(
+        `${label} returned no image data${refusal ? `: ${String(refusal).slice(0, 200)}` : ''}`,
+        'MEDIA_EMPTY_RESULT',
+        502
+      ),
+      usage
     );
   }
   return {
     bytes: decodeBase64Media(image.inlineData.data, `${label} image`),
     mime: image.inlineData.mimeType || 'image/png',
     revisedPrompt: null,
+    // Without reported tokens the one image is priced per image, if the catalog lists it.
+    usage: usage || { images: 1 },
   };
 }
 
@@ -76,5 +82,10 @@ export async function generateImage(
   const res = await post(model, key, geminiImageRequestBody(prompt, options, references), signal, fetchFn);
   if (!res.ok) throw upstreamError('Gemini image', res.status, await res.text().catch(() => ''));
   const data = await res.json();
-  return pickGeminiImagePart(data?.candidates?.[0]?.content?.parts || [], 'Gemini');
+  return pickGeminiImagePart(
+    data?.candidates?.[0]?.content?.parts || [],
+    'Gemini',
+    null,
+    geminiUsage(data?.usageMetadata)
+  );
 }