mixdog 0.9.172 → 0.9.173

package/src/runtime/agent/orchestrator/session/tool-batch/finalize.mjs

@@ -104,7 +104,7 @@ function traceCompleted(batch, completed, result, postprocessStartedAt) {
       telemetry: completed.resultTelemetry,
       preOffloadBytes,
       postOffloadBytes,
-      modelVisibleBytes: utf8Bytes(result),
+      modelVisibleBytes: postOffloadBytes,
       offloaded,
       resultKind: completed.resultKind,
     });

package/src/runtime/agent/orchestrator/session/tool-result-offload.mjs

@@ -123,11 +123,14 @@ function isAggregateOffloadEligible(toolName, result) {
 
 function rankAggregateOffloadCandidates(entries) {
   return entries
-    .map((entry, index) => ({
-      index,
-      length: offloadableTextLength(entry?.result),
-      eligible: isAggregateOffloadEligible(entry?.toolName, entry?.result) && offloadableTextLength(entry?.result) > 0,
-    }))
+    .map((entry, index) => {
+      const length = offloadableTextLength(entry?.result);
+      return {
+        index,
+        length,
+        eligible: isAggregateOffloadEligible(entry?.toolName, entry?.result) && length > 0,
+      };
+    })
     .filter((entry) => entry.eligible)
     .sort((a, b) => b.length - a.length || b.index - a.index)
     .map((entry) => entry.index);
@@ -238,7 +241,9 @@ export function persistToolResultArtifactSync({ sessionId, toolCallId, channel =
       try {
         if (fd !== undefined) closeSync(fd);
       } catch {
-        return null;
+        // The artifact is already written and byte-verified above; a failed
+        // descriptor close is cleanup, not a failed persist, and must never
+        // replace the verified meta this function returns.
       }
     }
   }
@@ -274,7 +279,8 @@ async function persistToolResultArtifact({ sessionId, toolCallId, channel = 'res
       try {
         await handle?.close();
       } catch {
-        return null;
+        // See persistToolResultArtifactSync: the verified artifact stands even
+        // when releasing the handle fails, so cleanup never nulls the result.
       }
     }
   }

package/src/runtime/agent/orchestrator/stable-hash-stringify.mjs

@@ -0,0 +1,10 @@
+// Key-sorted JSON, used purely as hash input: the same value must serialize to
+// the same bytes in every process, so object key order can never leak into a
+// prompt-cache key or a trace fingerprint. Kept deliberately minimal — cycles
+// and other JSON.stringify refusals throw here and are caught by the hashers.
+export function stableHashStringify(value) {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((item) => stableHashStringify(item)).join(',')}]`;
+  const keys = Object.keys(value).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableHashStringify(value[key])}`).join(',')}}`;
+}

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

@@ -398,8 +398,6 @@ function coercePatternStringValues(v) {
   return Array.isArray(v) ? v.map(coerce) : coerce(v);
 }
 
-// ---- per-tool guards ----
-
 function guardGrep(a) {
   for (const key of ['include_noise', 'text']) {
     if (hasOwn(a, key) && typeof a[key] !== 'boolean') {
@@ -660,17 +658,14 @@ function guardRead(a) {
   const publicError = normalizePublicReadTargets(a);
   if (publicError) return publicError;
   // Public targets are normalized above; legacy callers already use path.
-  const hasPath = hasOwn(a, 'path');
-  if (!hasPath) {
+  if (!hasOwn(a, 'path')) {
     return 'Error: read requires "path" (or alias file_path).';
   }
   // Some providers/models send a batched path array as a JSON string despite
   // the schema (or path:"[]" meaning cwd). The executor coerces via
   // coerceReadFamilyPathArg(); mirror that here so validation does not reject
   // shapes the executor would absorb.
-  if (hasOwn(a, 'path')) {
-    a.path = coerceReadFamilyPathArg(a.path);
-  }
+  a.path = coerceReadFamilyPathArg(a.path);
   absorbReadEchoedPathInteger(a, 'offset');
   absorbReadEchoedPathInteger(a, 'limit');
   // Absorb: parallel/JSON-stringified offset+limit arrays paired with a
@@ -685,39 +680,36 @@ function guardRead(a) {
     }
   }
   // path can be string | string[] | object[]; file_path is string
-  if (hasOwn(a, 'path')) {
-    const p = a.path;
-    const ok = typeof p === 'string' || (Array.isArray(p) && p.length > 0);
-    if (!ok) {
-      return `Error: read arg "path" must be string, string[], or object[] (got ${describeType(p)})`;
+  const p = a.path;
+  if (typeof p !== 'string' && !(Array.isArray(p) && p.length > 0)) {
+    return `Error: read arg "path" must be string, string[], or object[] (got ${describeType(p)})`;
+  }
+  if (Array.isArray(p)) {
+    // Absorb: a region array ({path,offset,limit}[]) carries its window
+    // per-entry; a top-level offset/limit becomes the default for any
+    // region missing its own window, then the top-level keys are dropped
+    // so they don't double-apply in the plain-read checks below.
+    const hasRegionObj = p.some((e) => e && typeof e === 'object' && !Array.isArray(e));
+    if (hasRegionObj && (isPresent(a, 'offset') || isPresent(a, 'limit'))) {
+      for (const e of p) {
+        if (!e || typeof e !== 'object' || Array.isArray(e)) continue;
+        if (isPresent(a, 'offset') && !isPresent(e, 'offset')) e.offset = a.offset;
+        if (isPresent(a, 'limit') && !isPresent(e, 'limit')) e.limit = a.limit;
+      }
+      delete a.offset;
+      delete a.limit;
     }
-    if (Array.isArray(p)) {
-      // Absorb: a region array ({path,offset,limit}[]) carries its window
-      // per-entry; a top-level offset/limit becomes the default for any
-      // region missing its own window, then the top-level keys are dropped
-      // so they don't double-apply in the plain-read checks below.
-      const hasRegionObj = p.some((e) => e && typeof e === 'object' && !Array.isArray(e));
-      if (hasRegionObj && (isPresent(a, 'offset') || isPresent(a, 'limit'))) {
-        for (const e of p) {
-          if (!e || typeof e !== 'object' || Array.isArray(e)) continue;
-          if (isPresent(a, 'offset') && !isPresent(e, 'offset')) e.offset = a.offset;
-          if (isPresent(a, 'limit') && !isPresent(e, 'limit')) e.limit = a.limit;
-        }
-        delete a.offset;
-        delete a.limit;
+    for (let i = 0; i < p.length; i++) {
+      const entry = p[i];
+      if (typeof entry === 'string') continue;
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        return `Error: read arg "path[${i}]" must be string or {path,offset,limit} object (got ${describeType(entry)})`;
       }
-      for (let i = 0; i < p.length; i++) {
-        const entry = p[i];
-        if (typeof entry === 'string') continue;
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
-          return `Error: read arg "path[${i}]" must be string or {path,offset,limit} object (got ${describeType(entry)})`;
-        }
-        const err = applyLineContextWindow(entry, `path[${i}].`);
-        if (err) return err;
-        for (const ek of ['offset', 'limit']) {
-          const eErr = checkIntInRange(entry, ek, 0, MAX_INT);
-          if (eErr) return eErr.replace(`"${ek}"`, `"path[${i}].${ek}"`);
-        }
+      const err = applyLineContextWindow(entry, `path[${i}].`);
+      if (err) return err;
+      for (const ek of ['offset', 'limit']) {
+        const eErr = checkIntInRange(entry, ek, 0, MAX_INT);
+        if (eErr) return eErr.replace(`"${ek}"`, `"path[${i}].${ek}"`);
       }
     }
   }
@@ -820,6 +812,23 @@ function guardTask(a) {
   return null;
 }
 
+// head_limit is spelled identically for list/find/glob: coerce a numeric
+// string in place, then validate. 0 is the valid "no cap" sentinel; a negative
+// value is nonsensical and downstream produces a degenerate window (clamps to
+// 0 → empty).
+function checkHeadLimit(a, toolName) {
+  if (!hasOwn(a, 'head_limit') || a.head_limit === undefined || a.head_limit === null) return null;
+  const coerced = coerceIntegerString(a.head_limit);
+  if (coerced !== null) a.head_limit = coerced;
+  if (!isFiniteInt(a.head_limit)) {
+    return `Error: ${toolName} arg "limit" must be a finite integer (got ${describeType(a.head_limit)})`;
+  }
+  if (a.head_limit < 0) {
+    return `Error: ${toolName} arg "limit" must be >= 0 (0 means no cap); got ${a.head_limit}`;
+  }
+  return null;
+}
+
 function guardList(a) {
   if (hasOwn(a, 'path') && !isString(a.path)) {
     return `Error: list arg "path" must be string (got ${describeType(a.path)})`;
@@ -842,19 +851,7 @@ function guardList(a) {
       return `Error: list arg "offset" must be a non-negative integer (got ${describeType(a.offset)})`;
     }
   }
-  if (hasOwn(a, 'head_limit') && a.head_limit !== undefined && a.head_limit !== null) {
-    const coerced = coerceIntegerString(a.head_limit);
-    if (coerced !== null) a.head_limit = coerced;
-    if (!isFiniteInt(a.head_limit)) {
-      return `Error: list arg "limit" must be a finite integer (got ${describeType(a.head_limit)})`;
-    }
-    // 0 is the valid "no cap" sentinel; a negative value is nonsensical
-    // and downstream produces a degenerate window (clamps to 0 → empty).
-    if (a.head_limit < 0) {
-      return `Error: list arg "limit" must be >= 0 (0 means no cap); got ${a.head_limit}`;
-    }
-  }
-  return null;
+  return checkHeadLimit(a, 'list');
 }
 
 function guardFind(a) {
@@ -871,17 +868,7 @@ function guardFind(a) {
   if (hasOwn(a, 'include_noise') && typeof a.include_noise !== 'boolean') {
     return `Error: find arg "include_noise" must be a boolean (got ${describeType(a.include_noise)})`;
   }
-  if (hasOwn(a, 'head_limit') && a.head_limit !== undefined && a.head_limit !== null) {
-    const coerced = coerceIntegerString(a.head_limit);
-    if (coerced !== null) a.head_limit = coerced;
-    if (!isFiniteInt(a.head_limit)) {
-      return `Error: find arg "limit" must be a finite integer (got ${describeType(a.head_limit)})`;
-    }
-    if (a.head_limit < 0) {
-      return `Error: find arg "limit" must be >= 0 (0 means no cap); got ${a.head_limit}`;
-    }
-  }
-  return null;
+  return checkHeadLimit(a, 'find');
 }
 
 function guardGlob(a) {
@@ -926,19 +913,7 @@ function guardGlob(a) {
       return `Error: glob arg "sort" must be one of natural|mtime (got ${JSON.stringify(a.sort)})`;
     }
   }
-  if (hasOwn(a, 'head_limit') && a.head_limit !== undefined && a.head_limit !== null) {
-    const coerced = coerceIntegerString(a.head_limit);
-    if (coerced !== null) a.head_limit = coerced;
-    if (!isFiniteInt(a.head_limit)) {
-      return `Error: glob arg "limit" must be a finite integer (got ${describeType(a.head_limit)})`;
-    }
-    // 0 is the valid "no cap" sentinel; a negative value is nonsensical
-    // and downstream produces a degenerate window (clamps to 0 → empty).
-    if (a.head_limit < 0) {
-      return `Error: glob arg "limit" must be >= 0 (0 means no cap); got ${a.head_limit}`;
-    }
-  }
-  return null;
+  return checkHeadLimit(a, 'glob');
 }
 
 // Valid code_graph modes — mirrors the enum in code-graph-tool-defs.mjs.

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

@@ -214,7 +214,8 @@ export const BUILTIN_TOOLS = [
         output: {
           type: 'string',
           enum: ['new', 'tail'],
-          description: 'read/wait only. Default new; tail replays recent output after an interruption or context loss. Up to 8 KiB per stream while running, 12 KiB on completion or replay; original logs are preserved.',
+          description:
+            'read/wait only. Default new; tail replays recent output after an interruption or context loss. Up to 8 KiB per stream while running, 12 KiB on completion or replay; original logs are preserved.',
         },
       },
       required: ['action'],

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

@@ -232,37 +232,38 @@ export async function runResultCacheInFlight(key, compute, options = {}) {
   return subscribeResultCacheInFlight(entry, subscriberSignal);
 }
 
-export async function runRawContentInFlight(fullPath, loader = fsPromises.readFile) {
-  const key = canonicalCachePath(fullPath);
-  const generation = getPathMutationGeneration(key);
-  const existing = RAW_CONTENT_INFLIGHT.get(key);
+// 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) {
+  const existing = inFlight.get(key);
   if (existing?.generation === generation) return await existing.promise;
   const promise = Promise.resolve()
-    .then(() => loader(fullPath))
+    .then(start)
     .finally(() => {
-      if (RAW_CONTENT_INFLIGHT.get(key)?.promise === promise) {
-        RAW_CONTENT_INFLIGHT.delete(key);
+      if (inFlight.get(key)?.promise === promise) {
+        inFlight.delete(key);
       }
     });
-  RAW_CONTENT_INFLIGHT.set(key, { generation, promise });
+  inFlight.set(key, { generation, 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)
+  );
+}
+
 export async function runReadOnlyStatInFlight(fullPath, loader = fsPromises.stat, kind = 'stat') {
   const canonicalPath = canonicalCachePath(fullPath);
-  const key = `${kind}|${canonicalPath}`;
-  const generation = getPathMutationGeneration(canonicalPath);
-  const existing = READ_ONLY_STAT_INFLIGHT.get(key);
-  if (existing?.generation === generation) return await existing.promise;
-  const promise = Promise.resolve()
-    .then(() => loader(fullPath))
-    .finally(() => {
-      if (READ_ONLY_STAT_INFLIGHT.get(key)?.promise === promise) {
-        READ_ONLY_STAT_INFLIGHT.delete(key);
-      }
-    });
-  READ_ONLY_STAT_INFLIGHT.set(key, { generation, promise });
-  return await promise;
+  return await runInFlightForGeneration(
+    READ_ONLY_STAT_INFLIGHT,
+    `${kind}|${canonicalPath}`,
+    getPathMutationGeneration(canonicalPath),
+    () => loader(fullPath)
+  );
 }
 
 function rawContentCacheDelete(key) {

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

@@ -321,7 +321,6 @@ function applyFileQuoteStyle(actualSpan, replacement) {
   return out.join('');
 }
 
-// ---------------------------------------------------------------------------
 // Encoding / line-ending fidelity (Windows-first).
 //
 // The edit path used to decode every target as UTF-8 and hand the native
@@ -331,7 +330,6 @@ function applyFileQuoteStyle(actualSpan, replacement) {
 // the file's BOM decides the codec, the file's dominant EOL decides the line
 // endings of old_string/new_string, and non-UTF-8 targets are edited in-process
 // (the native engine's payload is UTF-8 by protocol) and re-encoded in place.
-// ---------------------------------------------------------------------------
 const UTF8_BOM_BYTES = Buffer.from([0xef, 0xbb, 0xbf]);
 const UTF16LE_BOM_BYTES = Buffer.from([0xff, 0xfe]);
 const UTF16BE_BOM_BYTES = Buffer.from([0xfe, 0xff]);

package/src/runtime/agent/orchestrator/tools/builtin/git-command-policy.mjs

@@ -40,7 +40,10 @@ const ALWAYS_READ = new Set([
 ]);
 
 const SHELL_OPERATOR_CHARS = '|&;<>()';
-const OPERATION_ALIASES = new Map([
+// `git --version` / `-v` / `--help` / `-h` arrive in global-flag position; both
+// the policy classifier and the git tool fold them onto their subcommand form,
+// so the mapping is shared to keep the two from drifting apart.
+export const OPERATION_ALIASES = new Map([
   ['--version', 'version'],
   ['-v', 'version'],
   ['--help', 'help'],
@@ -94,7 +97,7 @@ export function commandHasShellSyntax(command) {
   return quote !== null;
 }
 
-export function gitActionOf(operation, args) {
+function gitActionOf(operation, args) {
   const first = args.find((value) => value && !value.startsWith('-'));
   if (operation === 'stash') return first || 'push';
   if (operation === 'worktree') return first || 'list';
@@ -151,42 +154,56 @@ export function gitPlanIsReadOnly(plan) {
   return false;
 }
 
-function parsedGitOperation(command) {
-  if (commandHasShellSyntax(command)) return null;
-  const tokens = tokenizeDirectArgv(command);
-  if (!tokens?.length || !/(^|[\\/])git(?:\.exe)?$/i.test(tokens[0])) return null;
+const GIT_GLOBAL_VALUE_FLAGS = ['-c', '--config-env', '--git-dir', '--work-tree', '--namespace'];
+const GIT_GLOBAL_BARE_FLAGS = [
+  '--no-pager',
+  '--paginate',
+  '--bare',
+  '--literal-pathspecs',
+  '--glob-pathspecs',
+  '--noglob-pathspecs',
+  '--icase-pathspecs',
+];
+
+// git's global flags sit between `git` and the subcommand, and every consumer
+// has to step over exactly the same set to find that subcommand. Returns its
+// index; the optional handlers let a caller capture what it skipped (the git
+// tool keeps `-C` as its cwd and the rest as global args, and rejects a
+// missing value) while a pure scan passes none.
+export function skipGitGlobalFlags(tokens, { onChdir, onValueFlag, onBareFlag } = {}) {
   let index = 1;
   while (index < tokens.length) {
     const token = tokens[index];
-    if (
-      token === '-C' ||
-      token === '-c' ||
-      token === '--config-env' ||
-      token === '--git-dir' ||
-      token === '--work-tree' ||
-      token === '--namespace'
-    ) {
+    if (token === '-C') {
+      onChdir?.(tokens[index + 1]);
       index += 2;
       continue;
     }
-    if (
-      /^-C.+/.test(token) ||
-      /^--(?:git-dir|work-tree|namespace|config-env)=/.test(token) ||
-      [
-        '--no-pager',
-        '--paginate',
-        '--bare',
-        '--literal-pathspecs',
-        '--glob-pathspecs',
-        '--noglob-pathspecs',
-        '--icase-pathspecs',
-      ].includes(token)
-    ) {
+    if (/^-C.+/.test(token)) {
+      onChdir?.(token.slice(2));
+      index++;
+      continue;
+    }
+    if (GIT_GLOBAL_VALUE_FLAGS.includes(token)) {
+      onValueFlag?.(token, tokens[index + 1]);
+      index += 2;
+      continue;
+    }
+    if (/^--(?:git-dir|work-tree|namespace|config-env)=/.test(token) || GIT_GLOBAL_BARE_FLAGS.includes(token)) {
+      onBareFlag?.(token);
       index++;
       continue;
     }
     break;
   }
+  return index;
+}
+
+function parsedGitOperation(command) {
+  if (commandHasShellSyntax(command)) return null;
+  const tokens = tokenizeDirectArgv(command);
+  if (!tokens?.length || !/(^|[\\/])git(?:\.exe)?$/i.test(tokens[0])) return null;
+  const index = skipGitGlobalFlags(tokens);
   const rawOperation = String(tokens[index] || '').toLowerCase();
   const operation = OPERATION_ALIASES.get(rawOperation) ?? rawOperation;
   return operation ? { operation, args: tokens.slice(index + 1) } : null;

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

@@ -12,6 +12,8 @@ import { ensureNativeSpawnServer, tryNativeSpawn } from '../lib/native-spawn-cli
 import {
   commandHasShellSyntax,
   gitPlanIsReadOnly as isReadOnly,
+  OPERATION_ALIASES,
+  skipGitGlobalFlags,
 } from './git-command-policy.mjs';
 import {
   buildSelectedStagePatch,
@@ -58,12 +60,6 @@ const SERVER_OPERATIONS = new Set(['daemon', 'instaweb']);
 // These answer anywhere: demanding a repository first turned an availability
 // probe into `git rev-parse exited 128` inside a plain directory.
 const REPO_FREE_OPERATIONS = new Set(['version', 'help']);
-const OPERATION_ALIASES = new Map([
-  ['--version', 'version'],
-  ['-v', 'version'],
-  ['--help', 'help'],
-  ['-h', 'help'],
-]);
 
 export const GIT_TOOL_DEF = {
   name: 'git',
@@ -102,7 +98,8 @@ export const GIT_TOOL_DEF = {
       },
       include_stage_ids: {
         type: 'boolean',
-        description: 'Include staging IDs outside the body cap for git diff or git diff -- <paths> only. Default false.',
+        description:
+          'Include staging IDs outside the body cap for git diff or git diff -- <paths> only. Default false.',
       },
       diff_id: { type: 'string', description: 'stage: exact diff_id from git diff with include_stage_ids:true.' },
       change_ids: {
@@ -173,7 +170,8 @@ function stageableDiffResult(plan, result, snapshot, limit) {
       rendered.text = appendText(rendered.text, `file: ${JSON.stringify(change.path)}`);
       previousPath = change.path;
     }
-    const location = change.kind || `@@ -${change.old_start},${change.deletions} +${change.new_start},${change.additions} @@`;
+    const location =
+      change.kind || `@@ -${change.old_start},${change.deletions} +${change.new_start},${change.additions} @@`;
     rendered.text = appendText(rendered.text, `change:${change.id} ${location}`);
   }
   return rendered;
@@ -206,52 +204,19 @@ function parseCommand(rawCommand, workDir) {
   }
   let cwd = resolve(workDir || process.cwd());
   const globalArgs = [];
-  let index = 1;
-  while (index < tokens.length) {
-    const token = tokens[index];
-    if (token === '-C') {
-      const path = tokens[++index];
+  const index = skipGitGlobalFlags(tokens, {
+    onChdir: (path) => {
       if (!path) throw new Error('git -C requires a path');
       cwd = resolve(cwd, path);
-      index++;
-      continue;
-    }
-    if (token.startsWith('-C') && token.length > 2) {
-      cwd = resolve(cwd, token.slice(2));
-      index++;
-      continue;
-    }
-    if (
-      token === '-c' ||
-      token === '--config-env' ||
-      token === '--git-dir' ||
-      token === '--work-tree' ||
-      token === '--namespace'
-    ) {
-      const value = tokens[index + 1];
+    },
+    onValueFlag: (token, value) => {
       if (!value) throw new Error(`${token} requires a value`);
       globalArgs.push(token, value);
-      index += 2;
-      continue;
-    }
-    if (
-      /^--(?:git-dir|work-tree|namespace|config-env)=/.test(token) ||
-      [
-        '--no-pager',
-        '--paginate',
-        '--bare',
-        '--literal-pathspecs',
-        '--glob-pathspecs',
-        '--noglob-pathspecs',
-        '--icase-pathspecs',
-      ].includes(token)
-    ) {
+    },
+    onBareFlag: (token) => {
       globalArgs.push(token);
-      index++;
-      continue;
-    }
-    break;
-  }
+    },
+  });
   const rawOperation = String(tokens[index] || '').toLowerCase();
   const operation = OPERATION_ALIASES.get(rawOperation) ?? rawOperation;
   if (!operation) throw new Error('git requires a subcommand');
@@ -413,13 +378,30 @@ async function runStageableDiff(plan, argv, repo, signal) {
   result.stdout = String(result.stdout);
   result.stderr = String(result.stderr);
   const paths = plan.args.slice(1);
-  const untracked = await runGit(plan, ['ls-files', '--others', '--exclude-standard', '--full-name', '-z', '--', ...paths], { signal });
+  const untracked = await runGit(
+    plan,
+    ['ls-files', '--others', '--exclude-standard', '--full-name', '-z', '--', ...paths],
+    { signal }
+  );
   if (!succeeded(untracked)) return untracked;
   for (const path of String(untracked.stdout).split('\0').filter(Boolean)) {
-    const added = await runGit({ ...plan, cwd: repo }, [
-      'diff', '--no-index', '--binary', '--no-ext-diff', '--no-textconv', '--no-color',
-      '--src-prefix=a/', '--dst-prefix=b/', '--', '/dev/null', path,
-    ], { signal });
+    const added = await runGit(
+      { ...plan, cwd: repo },
+      [
+        'diff',
+        '--no-index',
+        '--binary',
+        '--no-ext-diff',
+        '--no-textconv',
+        '--no-color',
+        '--src-prefix=a/',
+        '--dst-prefix=b/',
+        '--',
+        '/dev/null',
+        path,
+      ],
+      { signal }
+    );
     // --no-index uses exit 1 for a successfully produced patch.
     if (!succeeded({ ...added, exitCode: added.exitCode === 1 ? 0 : added.exitCode })) return added;
     result.stdout = appendText(result.stdout, String(added.stdout));

package/src/runtime/agent/orchestrator/tools/builtin/git-partial-stage.mjs

@@ -15,7 +15,7 @@ function decodePath(path) {
     const bytes = [];
     for (const token of path.slice(1, -1).matchAll(/\\([0-7]{1,3}|.)|[^\\]+/g)) {
       if (token[1] && /^[0-7]/.test(token[1])) bytes.push(Buffer.from([Number.parseInt(token[1], 8)]));
-      else bytes.push(Buffer.from(token[1] ? escapes[token[1]] ?? token[1] : token[0]));
+      else bytes.push(Buffer.from(token[1] ? (escapes[token[1]] ?? token[1]) : token[0]));
     }
     path = Buffer.concat(bytes).toString('utf8');
   }
@@ -45,9 +45,7 @@ function finishFile(files, file) {
   const pathLine = file.newLine === '+++ /dev/null' ? file.oldLine : file.newLine;
   if (pathLine) file.path = decodePath(pathLine.slice(4).replace(/\t$/, ''));
   file.stageable = Boolean(
-    file.diffLine &&
-      !file.blocked &&
-      (file.kind || (file.oldLine && file.newLine && file.hunks.length))
+    file.diffLine && !file.blocked && (file.kind || (file.oldLine && file.newLine && file.hunks.length))
   );
   files.push(file);
 }
@@ -94,7 +92,12 @@ function parseFiles(raw) {
     if (line.startsWith('--- ')) file.oldLine = line;
     else if (line.startsWith('+++ ')) file.newLine = line;
     else if (line.startsWith('new file mode ')) file.kind = 'new_file';
-    else if (/^(deleted file mode |old mode |new mode |similarity index |rename from |rename to |copy from |copy to |GIT binary patch)/.test(line)) file.kind ||= 'file';
+    else if (
+      /^(deleted file mode |old mode |new mode |similarity index |rename from |rename to |copy from |copy to |GIT binary patch)/.test(
+        line
+      )
+    )
+      file.kind ||= 'file';
     else if (line.startsWith('Binary files ')) file.blocked = true;
   }
   finishFile(files, file);

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

@@ -468,11 +468,7 @@ function renderFocusedContext(selected, sources, span, budget, notice) {
   const anchors = compact.length
     ? `\n# Additional matches\n${compact.map((anchor) => `${anchor.path}:${anchor.lineNo}:${compactAnchorContent(anchor.content)} [${anchorRangeHint(anchor, span)}]`).join('\n')}`
     : '';
-  const summary = compact.length
-    ? notice
-      ? notice.replace(/\]$/, `; ${rawBlocks.length} source spans, rest as path:line anchors]`)
-      : `\n[${rawBlocks.length} of ${ordered.length} shown; rest as path:line anchors]`
-    : notice;
+  const summary = compact.length ? anchorOverflowSummary(notice, rawBlocks.length, ordered.length) : notice;
   const text = `${raw}${anchors}${summary}`;
   return {
     text,
@@ -481,6 +477,13 @@ function renderFocusedContext(selected, sources, span, budget, notice) {
   };
 }
 
+// The overflow note extends an existing budget notice, or stands alone when the
+// output was not otherwise trimmed.
+function anchorOverflowSummary(notice, rawCount, totalCount) {
+  if (notice) return notice.replace(/\]$/, `; ${rawCount} source spans, rest as path:line anchors]`);
+  return `\n[${rawCount} of ${totalCount} shown; rest as path:line anchors]`;
+}
+
 export async function expandGrepAnchorContextOutput({
   allLines,
   workDir,