mixdog 1.2.3 → 1.2.5

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

@@ -12,9 +12,16 @@
 // adapter expects — the caller (builtin.mjs default: case) falls back to
 // the existing EXTERNAL_TOOL_REDIRECTS guidance message in that case.
 import { readFileSync, mkdirSync, existsSync, lstatSync, realpathSync, statSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { dirname, relative, resolve } from 'node:path';
 import { atomicWrite, symlinkWriteTarget } from './atomic-write.mjs';
-import { fileVersion } from './file-version.mjs';
+import { fileVersion, sameFileVersion } from './file-version.mjs';
+import { withBuiltinPathLocks } from './path-locks.mjs';
+import { withAdvisoryLocks } from './advisory-lock.mjs';
+import { canonicalCachePath } from './read-range-index.mjs';
+import { readSourceWindows } from './read-source-windows.mjs';
+import { isReadLineClipped } from './read-formatting.mjs';
+import { readSourceWindow } from '../../../../shared/read-row-numbers.mjs';
+import { cursorNativeCall, releaseCursorNativeCall } from '../../providers/cursor-native-context.mjs';
 import { assertPathsReachable } from './fs-reachability.mjs';
 import {
   normalizeInputPath,
@@ -30,12 +37,12 @@ import {
   isBlockedDevicePath,
   isSpecialFileStat,
 } from './device-paths.mjs';
-import { recordReadSnapshot } from './read-snapshot-runtime.mjs';
+import { recordReadSnapshot, getReadSnapshot } from './read-snapshot-runtime.mjs';
 import { executeBashTool } from './bash-tool.mjs';
 import { nativeEditSessionSatisfiesContract, runServerEdit } from '../patch/native-server.mjs';
 import { decodeValidUtf8OrNull, detectPatchTargetCodec, nearestPatchLineMatch } from '../patch/matcher.mjs';
 import { hashText } from './hash-utils.mjs';
-import { invalidateBuiltinResultCache } from './cache-layers.mjs';
+import { invalidateBuiltinResultCache, rawContentCacheGet } from './cache-layers.mjs';
 import { markCodeGraphDirtyPaths } from '../code-graph-state.mjs';
 import { reviewFileContent } from '../../../../shared/bounded-file-read.mjs';
 
@@ -515,13 +522,14 @@ function readEditTarget(fullPath) {
   let statBefore = {};
   let content;
   let fileEnc;
+  let rawBuf;
   try {
     try {
       statBefore = { ...fileVersion(statSync(fullPath)) };
     } catch {
       /* readFileSync below surfaces the real error */
     }
-    const rawBuf = readFileSync(fullPath);
+    rawBuf = readFileSync(fullPath);
     fileEnc = detectPatchTargetCodec(rawBuf);
     content = fileEnc.certain ? decodeEditBuffer(rawBuf, fileEnc) : null;
   } catch (err) {
@@ -536,7 +544,7 @@ function readEditTarget(fullPath) {
         ' Convert the encoding first.',
     };
   }
-  return { content, fileEnc, statBefore };
+  return { content, fileEnc, statBefore, rawBuf };
 }
 
 /**
@@ -759,7 +767,7 @@ function resolveStrReplaceArgs(args) {
   return out;
 }
 
-async function adaptStrReplace(args, workDir, options) {
+async function adaptStrReplace(args, workDir, options, resolvedTarget = null) {
   const resolved = resolveStrReplaceArgs(args);
   if (resolved.error) return resolved.error;
   let oldStr = resolved.old_string;
@@ -769,7 +777,16 @@ async function adaptStrReplace(args, workDir, options) {
   }
   if (oldStr === newStr) return SAME_STRINGS_ERROR;
   const replaceAll = args?.replace_all === true || String(args?.replace_all || '').toLowerCase() === 'true';
-  const target = await resolveTargetPath(args, workDir);
+  if (!resolvedTarget) {
+    return withEditTargetLock(
+      args,
+      workDir,
+      options,
+      (target) => adaptStrReplace(args, workDir, options, target),
+      oldStr.length === 0
+    );
+  }
+  const target = resolvedTarget || (await resolveTargetPath(args, workDir));
   if (!target) return null;
   if (target.error) return target.error;
   const fullPath = target.full;
@@ -822,10 +839,13 @@ async function adaptStrReplace(args, workDir, options) {
   return applyEditNative(edit, oldStr, newStr, editPlan, replaceAll);
 }
 
-async function adaptWrite(args, workDir, options) {
+async function adaptWrite(args, workDir, options, resolvedTarget = null) {
   const contents = args?.contents ?? args?.content ?? args?.file_text;
   if (typeof contents !== 'string') return null;
-  const target = await resolveTargetPath(args, workDir);
+  if (!resolvedTarget) {
+    return withEditTargetLock(args, workDir, options, (target) => adaptWrite(args, workDir, options, target));
+  }
+  const target = resolvedTarget || (await resolveTargetPath(args, workDir));
   if (!target) return null;
   if (target.error) return target.error;
   const fullPath = target.full;
@@ -849,6 +869,180 @@ async function adaptBash(key, args, workDir, options) {
   return executeBashTool(shellArgs, workDir, options);
 }
 
+async function withEditTargetLock(args, workDir, options, run, allowCreate = true) {
+  if (options?.signal?.aborted) throw options.signal.reason || new Error('Edit cancelled');
+  const target = await resolveTargetPath(args, workDir);
+  if (!target || target.error) return target?.error ?? null;
+  if (!allowCreate && !existsSync(target.full)) {
+    return `Error: cannot read ${target.full} (target is missing or inaccessible)`;
+  }
+  const resolveReal = () => {
+    const nearest = realpathNearestExisting(target.full);
+    return nearest ? resolve(nearest.real, relative(nearest.probe, target.full)) : null;
+  };
+  const real = resolveReal();
+  if (!real) return 'Error: cannot resolve edit target for locking';
+  return withBuiltinPathLocks([target.full, real], () =>
+    withAdvisoryLocks([real], async () => {
+      if (options?.signal?.aborted) throw options.signal.reason || new Error('Edit cancelled');
+      if (resolveReal() !== real) return 'Error: edit target changed while acquiring its lock';
+      return run(target);
+    })
+  );
+}
+
+const NATIVE_SNAPSHOT_MAX_BYTES = 1024 * 1024;
+
+// Structured truncation report for a returned read window, taken from the raw
+// source lines of that window with the read display's own clip predicate. A
+// window that cannot be verified is reported clipped (fail closed).
+async function nativeReadWindowReport(fullPath, source) {
+  if (source.startLine == null || source.endLine < source.startLine) return { lineClipped: false };
+  try {
+    const rows = await readSourceWindows(fullPath, [{ start: source.startLine, end: source.endLine }]);
+    return { lineClipped: [...rows.values()].some((row) => isReadLineClipped(row)) };
+  } catch {
+    return { lineClipped: true };
+  }
+}
+
+/** Clip report of an ordinary read result, for a Cursor read the daemon runs
+ * for a remote/proxied provider: `{ lineClipped: true }`, or null when the
+ * result is no source window or none of its lines were clipped. */
+export async function remoteReadWindowReport(args, workDir, result) {
+  const source = readSourceWindow(typeof result === 'string' ? result : '');
+  if (!source) return null;
+  const target = await resolveTargetPath(args, workDir);
+  const report = !target || target.error ? { lineClipped: true } : await nativeReadWindowReport(target.full, source);
+  return report.lineClipped ? report : null;
+}
+
+async function captureNativeRead(context, args, workDir, options, result) {
+  const pending = context.pending;
+  delete pending.nativeSnapshot;
+  delete pending.nativeReadReply;
+  delete pending.nativeReadWindow;
+  const target = await resolveTargetPath(args, workDir);
+  if (!target || target.error) return;
+  let stat;
+  try {
+    stat = statSync(target.full);
+  } catch (error) {
+    if (error.code === 'ENOENT') pending.nativeReadReply = { fileNotFound: { path: pending.native.args.path } };
+    return;
+  }
+  const source = readSourceWindow(typeof result === 'string' ? result : '');
+  if (source) pending.nativeReadWindow = await nativeReadWindowReport(target.full, source);
+  if (
+    !source ||
+    source.truncated ||
+    source.startLine !== 1 ||
+    args.offset ||
+    args.limit ||
+    stat.size > NATIVE_SNAPSHOT_MAX_BYTES ||
+    !stat.isFile()
+  )
+    return;
+  const observed = getReadSnapshot(target.full, options?.readStateScope ?? options?.sessionId ?? null);
+  if (!observed?.bodyDelivered || !sameFileVersion(observed, stat)) return;
+  const cached = rawContentCacheGet(target.full, stat);
+  if (!cached) return;
+  const bytes = Buffer.from(cached);
+  const text = bytes.toString('utf8');
+  if (text.includes('\0') || !Buffer.from(text, 'utf8').equals(bytes)) return;
+  const displayed = text
+    .replace(/^\uFEFF/, '')
+    .replace(/\r\n/g, '\n')
+    .replace(/\n$/, '');
+  if (displayed !== source.content) return;
+  const realPath = canonicalCachePath(realpathSync(target.full));
+  if (!sameFileVersion(stat, statSync(target.full))) return;
+  pending.nativeSnapshot = {
+    bytes,
+    text,
+    version: fileVersion(stat),
+    realPath,
+    path: canonicalCachePath(target.full),
+    delivered: false,
+  };
+  pending.nativeReadReply = {
+    success: {
+      path: pending.native.args.path,
+      content: text,
+      totalLines: source.totalLines,
+      fileSize: bytes.length,
+      truncated: false,
+      rangeApplied: false,
+    },
+  };
+}
+
+async function replaceNativeSnapshot(context, args, workDir, options) {
+  return withEditTargetLock(args, workDir, options, async (target) => {
+    const parent = context.pending.native.args.toolCallId;
+    if (typeof parent !== 'string' || parent.length === 0) {
+      return adaptStrReplace(args, workDir, options, target);
+    }
+    const path = canonicalCachePath(target.full);
+    const reads = [...context.executions.values()].filter(
+      (entry) =>
+        entry.native?.resultType === 'readResult' &&
+        entry.native.args.toolCallId === parent &&
+        entry.nativeSnapshot?.path === path
+    );
+    // Creating a missing/empty file retains the normal create-only contract.
+    if (reads.length === 0) return adaptStrReplace(args, workDir, options, target);
+    if (reads.length !== 1 || !reads[0].nativeSnapshot.delivered) {
+      return 'Error: native edit has no unambiguous, delivered full-file snapshot; use MCP edit with explicit old_string';
+    }
+    const snapshot = reads[0].nativeSnapshot;
+    const read = readEditTarget(target.full);
+    if (read.error) return read.error;
+    if (
+      canonicalCachePath(realpathSync(target.full)) !== snapshot.realPath ||
+      !sameFileVersion(snapshot.version, read.statBefore) ||
+      !read.rawBuf.equals(snapshot.bytes)
+    ) {
+      return 'Error: native edit target changed since its read; no replacement was written';
+    }
+    let after = args.new_string;
+    if (typeof after !== 'string') return 'Error: native replacement requires text';
+    if (read.fileEnc.bomLen && after.startsWith('\uFEFF')) after = after.slice(1);
+    const lineEndings = new Set(read.content.match(/\r\n|\r|\n/g) || []);
+    if (lineEndings.size > 1) {
+      return 'Error: native full-file replacement cannot preserve mixed line endings; use MCP edit with explicit old_string';
+    }
+    if (lineEndings.size === 1) after = convertTextEol(after, lineEndings.values().next().value);
+    const edit = { fullPath: target.full, workDir, options, ...read };
+    const bytes = encodeEditContent(after, read.fileEnc);
+    const stale = await commitEdit(edit, {
+      bytes,
+      after,
+      staleMessage: STALE_DURING_EDIT,
+    });
+    if (!stale) context.pending.nativeWrittenBytes = bytes.length;
+    return stale ?? `Updated ${editDisplayPath(edit)} (conditional native replacement)`;
+  });
+}
+
+// Called only after normal runtime permission checks. The capability is tied to
+// the streamed execution, not to a flag supplied in model arguments.
+export async function executeCursorNativeBuiltin(name, args, workDir, options, execute) {
+  const context = cursorNativeCall(options.sessionId, options.toolCallId, name, args);
+  if (!context) return execute(name, args, workDir, options);
+  if (name === 'read') {
+    const result = await execute(name, args, workDir, { ...options, suppressReadUnchangedStub: true });
+    await captureNativeRead(context, args, workDir, options, result);
+    return result;
+  }
+  releaseCursorNativeCall(context.pending);
+  try {
+    return await replaceNativeSnapshot(context, args, workDir, options);
+  } catch (error) {
+    return `Error: native edit failed (${error?.message || error})`;
+  }
+}
+
 export async function tryExecuteExternalToolAdapter(name, args, workDir, options) {
   if (typeof name !== 'string' || !name) return null;
   if (!args || typeof args !== 'object' || Array.isArray(args)) return null;

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

@@ -74,7 +74,7 @@ export const GIT_TOOL_DEF = {
     compressible: true,
   },
   description:
-    'Run Git here, never through shell. An array (max 10) runs in order and stops on failure; batch read-only commands in one. diff for known changes, status to discover them; history only when needed. git diff or git diff -- <paths> includes untracked files. Set include_stage_ids:true to select changes, then action:stage with diff_id/change_ids. Staging rejects stale or cross-Project diffs and returns selected locations.',
+    'Run Git here, never through shell. An array (max 10) runs in order and stops on failure; batch read-only commands in one. diff for known changes, status to discover them; history only when needed. git diff or git diff -- <paths> includes untracked files. Set include_stage_ids:true to select changes, then action:stage with diff_id/change_ids. Staging rejects stale or cross-Project diffs and returns per-file staged counts.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -142,47 +142,149 @@ function outputLines(value) {
   return String(value || '').match(/[^\n]*\n|[^\n]+$/g) || [];
 }
 
-function capOutput(text, limit) {
+// A line cap alone lets a few very long lines (minified files, lockfiles)
+// through, so each command also gets a character budget, and a command array
+// shares one. A cut always states what was omitted and how to page.
+const COMMAND_CHAR_BUDGET = 12_000;
+const ARRAY_CHAR_BUDGET = 24_000;
+const MIN_COMMAND_CHARS = 1_000;
+const LARGE_DIFF_LINES = 200;
+const LARGE_DIFF_HINT =
+  'hint: large diff - run with --stat first for per-file sizes, add -U1 for less context, and page by file with -- <path>';
+
+// Line-ending warnings are noise the model cannot act on; the content is unchanged.
+const CRLF_WARNING_RE = /^warning: in the working copy of .* (?:CRLF|LF) will be replaced[^\n]*(?:\n|$)/gm;
+// `index abc..def` carries abbreviated object ids the model never uses; mode
+// changes keep their own `old mode`/`new mode`/`new file mode` lines.
+const DIFF_INDEX_LINE_RE = /^index [0-9a-f,]+\.\.[0-9a-f]+(?: [0-7]+)?\r?(?:\n|$)/gm;
+const PATCH_OPERATIONS = new Set(['diff', 'diff-files', 'diff-index', 'diff-tree', 'show', 'log']);
+
+function visibleStderr(value) {
+  return String(value || '').replace(CRLF_WARNING_RE, '');
+}
+
+function presentStdout(plan, value) {
+  const stdout = String(value || '');
+  if (plan.operation === 'merge-tree') return stdout.replace(/^Auto-merging .*(?:\r?\n|$)/gm, '');
+  if (PATCH_OPERATIONS.has(plan.operation) && /^diff --git /m.test(stdout)) {
+    return stdout.replace(DIFF_INDEX_LINE_RE, '');
+  }
+  return stdout;
+}
+
+function normalizeCap(limit) {
+  return typeof limit === 'object' ? limit : { lines: limit, chars: COMMAND_CHAR_BUDGET };
+}
+
+function capOutput(text, cap) {
   const lines = outputLines(text);
-  if (lines.length <= limit) return text;
-  return appendText(
-    lines.slice(0, limit).join(''),
-    `... [${lines.length - limit} more lines omitted; raise output_limit or narrow the command]`
-  );
+  const lineCut = lines.length > cap.lines;
+  const kept = lineCut ? lines.slice(0, cap.lines).join('') : text;
+  if (kept.length <= cap.chars) {
+    return {
+      text: lineCut
+        ? appendText(
+            kept,
+            `... [${lines.length - cap.lines} more lines omitted; raise output_limit or narrow the command]`
+          )
+        : text,
+      truncated: lineCut,
+      totalLines: lines.length,
+    };
+  }
+  const newline = kept.lastIndexOf('\n', cap.chars - 1);
+  const cut = newline > 0 ? newline + 1 : cap.chars;
+  const shown = outputLines(kept.slice(0, cut)).length;
+  return {
+    text: appendText(
+      kept.slice(0, cut),
+      `... [${lines.length - shown} more lines (${text.length - cut} chars) omitted; output limited to ${cap.chars} chars - narrow the command (-- <path>, -n/--skip) to page]`
+    ),
+    truncated: true,
+    totalLines: lines.length,
+  };
 }
 
 function commandResult(plan, result, limit) {
-  const output = capOutput(appendText(String(result.stdout || ''), String(result.stderr || '')), limit);
+  const stdout = presentStdout(plan, result.stdout);
+  const capped = capOutput(appendText(stdout, visibleStderr(result.stderr)), normalizeCap(limit));
+  let output = capped.text;
+  if ((capped.truncated || capped.totalLines > LARGE_DIFF_LINES) && /^diff --git /m.test(stdout)) {
+    output = appendText(output, LARGE_DIFF_HINT);
+  }
   if (succeeded(result)) return { text: output, failed: false };
   const processError = result.error || result.timedOut || result.aborted || result.overflow || result.exitCode == null;
-  // An exit signal is still a non-zero exit, so a command array stops on it;
-  // the outcome line only keeps the card from reporting a failure.
-  const exitHeader = exitSignal(plan, result)
-    ? `exit ${result.exitCode}\n[outcome: no-match]`
-    : `exit ${result.exitCode}`;
+  if (processError) return { text: appendText(fail(gitFailureReason(plan, result)), output), failed: true };
+  const outcome = exitSignal(plan, result);
+  if (outcome === 'conflicts') {
+    // A conflicted merge-tree is its answer, not a failed command: the array continues.
+    return {
+      text: appendText(
+        `exit ${result.exitCode}\n[outcome: conflicts]\nmerge has conflicts (see the CONFLICT lines); this is a result, not a command failure`,
+        output
+      ),
+      failed: false,
+    };
+  }
+  // A no-match signal is still a non-zero exit, so a command array stops on
+  // it; the outcome line only keeps the card from reporting a failure.
   return {
-    text: appendText(processError ? fail(gitFailureReason(plan, result)) : exitHeader, output),
+    text: appendText(outcome ? `exit ${result.exitCode}\n[outcome: ${outcome}]` : `exit ${result.exitCode}`, output),
     failed: true,
   };
 }
 
+// Paths come from git unquoted; only a name that would break the one-line
+// listing (control characters, quotes) is JSON-quoted.
+function listedPath(path) {
+  return [...path].some((char) => char.charCodeAt(0) < 0x20 || char === '"') ? JSON.stringify(path) : path;
+}
+
 function stageableDiffResult(plan, result, snapshot, limit) {
   if (!snapshot.diffId) return commandResult(plan, result, limit);
   const rendered = commandResult(plan, result, limit);
-  rendered.text = appendText(rendered.text, `diff_id: ${snapshot.diffId}`);
-  let previousPath;
+  // The hunk headers are already in the body; one line per file names the id range.
+  const files = [];
   for (const change of snapshot.changes) {
-    if (change.path !== previousPath) {
-      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} @@`;
-    rendered.text = appendText(rendered.text, `change:${change.id} ${location}`);
+    const last = files.at(-1);
+    if (last?.path === change.path && !change.kind && !last.kind) last.end = change.id;
+    else files.push({ path: change.path, start: change.id, end: change.id, kind: change.kind });
   }
+  const listing = files.map(
+    ({ path, start, end, kind }) =>
+      `${listedPath(path)}: ${start === end ? start : `${start}-${end}`}${kind ? ' [whole file]' : ''}`
+  );
+  rendered.text = appendText(
+    rendered.text,
+    [
+      `diff_id: ${snapshot.diffId} (ids number the +/- runs in diff order; [whole file] ids stage the entire file)`,
+      ...listing,
+    ].join('\n')
+  );
   return rendered;
 }
 
+// Per-file staged counts; the paths and ranges the model already holds are not repeated per change.
+function stagedSummary(changes) {
+  const files = new Map();
+  for (const { path, additions = 0, deletions = 0 } of changes) {
+    const entry = files.get(path) || { count: 0, additions: 0, deletions: 0 };
+    entry.count += 1;
+    entry.additions += additions;
+    entry.deletions += deletions;
+    files.set(path, entry);
+  }
+  return {
+    changes: changes.length,
+    additions: [...files.values()].reduce((sum, entry) => sum + entry.additions, 0),
+    deletions: [...files.values()].reduce((sum, entry) => sum + entry.deletions, 0),
+    files: [...files].map(
+      ([path, entry]) =>
+        `${path}: ${entry.count} ${entry.count === 1 ? 'change' : 'changes'} +${entry.additions} -${entry.deletions}`
+    ),
+  };
+}
+
 // A provider sometimes delivers the whole command as one quoted scalar
 // (`"git diff"`). That tokenizes to a single argument, so the git prefix check
 // rejected it and the caller paid a failed call plus a retry for a command it
@@ -351,14 +453,16 @@ function succeeded(result) {
 
 // `git grep` exits 1 for no match and `git diff --exit-code/--quiet/--check`
 // exits 1 to report a difference; the shell tool marks the same exits as
-// signals, so the git tool does too.
+// signals, so the git tool does too. `git merge-tree` exits 1 with its report
+// on stdout when the merge has conflicts. Returns the outcome name or null.
 function exitSignal(plan, result) {
-  if (result.exitCode !== 1 || String(result.stderr || '').trim()) return false;
-  if (plan.operation === 'grep') return true;
-  if (plan.operation !== 'diff') return false;
+  if (result.exitCode !== 1 || visibleStderr(result.stderr).trim()) return null;
+  if (plan.operation === 'grep') return 'no-match';
+  if (plan.operation === 'merge-tree') return String(result.stdout || '').trim() ? 'conflicts' : null;
+  if (plan.operation !== 'diff') return null;
   const separator = plan.args.indexOf('--');
   const options = separator === -1 ? plan.args : plan.args.slice(0, separator);
-  return options.some((arg) => GIT_DIFF_EXIT_SIGNAL_FLAGS.has(arg));
+  return options.some((arg) => GIT_DIFF_EXIT_SIGNAL_FLAGS.has(arg)) ? 'no-match' : null;
 }
 
 // ENOENT from the spawn itself is a capability fact, not a git error: the
@@ -690,10 +794,7 @@ async function executeGitStage(input, workDir, options = {}) {
           if (!succeeded(applied)) return commandFailure(applyPlan, applied, limit);
           deleteDiffSnapshot(request.diffId);
           invalidateAfterGitMutation();
-          return ok({
-            staged: true,
-            changes: built.changes.map(({ id, preview, ...change }) => change),
-          });
+          return ok({ staged: true, ...stagedSummary(built.changes) });
         });
       }),
     { signal }
@@ -703,7 +804,13 @@ async function executeGitStage(input, workDir, options = {}) {
 async function executeSingleGitTool(input, workDir, options = {}) {
   if (!input || typeof input !== 'object' || Array.isArray(input)) return rejected('git requires an arguments object');
   const hasCommand = typeof input.command === 'string' && Boolean(input.command.trim());
-  if (!hasCommand) return rejected('git requires command');
+  if (!hasCommand) {
+    return rejected(
+      input.include_stage_ids === true
+        ? 'git requires command; staging IDs come from command:"git diff" (or "git diff -- <paths>") with include_stage_ids:true'
+        : 'git requires command: a full command starting with git, e.g. command:"git status"'
+    );
+  }
   let plan;
   try {
     plan = localizeConfigPlan(parseCommand(input.command, workDir));
@@ -717,7 +824,10 @@ async function executeSingleGitTool(input, workDir, options = {}) {
     return rejected('git archive requires -o/--output; binary stdout is not returned');
   }
   const limitDefault = plan.operation === 'log' ? 10 : 50;
-  const limit = outputLimit(input.output_limit, limitDefault);
+  const limit = {
+    lines: outputLimit(input.output_limit, limitDefault),
+    chars: options.charBudget ?? COMMAND_CHAR_BUDGET,
+  };
   const signal = abortSignalOf(options);
   if (plan.operation === 'init' || plan.operation === 'clone') {
     const target = creationTarget(plan);
@@ -870,13 +980,14 @@ export async function executeGitTool(rawInput, workDir, options = {}) {
     return fail(`git command array requires 1 to ${GIT_COMMAND_ARRAY_LIMIT} commands`);
   }
 
+  const operations = [];
   for (let index = 0; index < commands.length; index += 1) {
     const command = commands[index];
     if (typeof command !== 'string' || !command.trim()) {
       return fail(`git command ${index + 1} must be a non-empty string`);
     }
     try {
-      localizeConfigPlan(parseCommand(command, workDir));
+      operations.push(localizeConfigPlan(parseCommand(command, workDir)).operation);
     } catch (error) {
       return fail(`git command ${index + 1}: ${error.message}`);
     }
@@ -887,12 +998,22 @@ export async function executeGitTool(rawInput, workDir, options = {}) {
   // not produce. Every command is parsed above before any runs, so a typo in
   // command 3 never leaves commands 1-2 half applied. Each command still
   // acquires its own repository lock inside executeSingleGitTool.
+  // Headers name the position and subcommand only: echoing the argument list
+  // (a 22-path `add`) cost more than the result it labelled.
   const results = [];
-  for (const command of commands) {
-    const result = await executeSingleGitTool({ ...input, command }, workDir, options);
-    results.push(`## ${command}\n${result.text}`);
+  let used = 0;
+  for (let index = 0; index < commands.length; index += 1) {
+    const label = `${index + 1}: git ${operations[index]}`;
+    const charBudget = Math.min(COMMAND_CHAR_BUDGET, Math.max(MIN_COMMAND_CHARS, ARRAY_CHAR_BUDGET - used));
+    const result = await executeSingleGitTool({ ...input, command: commands[index] }, workDir, {
+      ...options,
+      charBudget,
+    });
+    const section = `## ${label}\n${result.text}`;
+    used += section.length;
+    results.push(section);
     if (result.failed) {
-      return appendText(results.join('\n'), `error: command failed: ${command}`);
+      return appendText(results.join('\n'), `error: command failed: ${label}`);
     }
   }
   return results.join('\n');

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

@@ -104,14 +104,19 @@ function parseFiles(raw) {
   return files;
 }
 
+// Change ids are ordinals (c1, c2, …) in diff order. They are only meaningful
+// together with the diff_id they were listed under: staging first verifies the
+// working diff still hashes to that snapshot, so an ordinal can never address a
+// different change than the one the model saw.
 function annotateChanges(files) {
   const changes = [];
+  let ordinal = 0;
   for (const file of files) {
     if (!file.stageable) continue;
     if (file.kind) {
       const entries = file.hunks.flatMap((hunk) => hunk.entries);
       changes.push({
-        id: `chg_${digest(file.lines.join('\n')).slice(0, 16)}`,
+        id: `c${++ordinal}`,
         path: file.path,
         kind: file.kind,
         additions: entries.filter(({ line }) => line.startsWith('+')).length,
@@ -126,9 +131,7 @@ function annotateChanges(files) {
       let group = null;
       const finishGroup = () => {
         if (!group) return;
-        const id = `chg_${digest(
-          [file.path, hunkIndex, group.oldStart, group.newStart, group.lines.join('\n')].join('\0')
-        ).slice(0, 16)}`;
+        const id = `c${++ordinal}`;
         for (const entry of group.entries) entry.changeId = id;
         changes.push({
           id,
@@ -137,7 +140,6 @@ function annotateChanges(files) {
           new_start: group.newStart,
           additions: group.additions,
           deletions: group.deletions,
-          preview: group.lines.slice(0, 4).map((line) => (line.length <= 180 ? line : `${line.slice(0, 180)}…`)),
         });
         group = null;
       };

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

@@ -9,7 +9,7 @@ export function splitGrepLineNumberOnlyPrefix(line) {
   };
 }
 
-export function splitGrepLinePrefix(line) {
+export function splitGrepLinePrefix(line, matchOnly = false) {
   const text = String(line || '');
   if (!text) return null;
   const searchFrom = /^[A-Za-z]:/.test(text) ? 2 : 0;
@@ -19,7 +19,9 @@ export function splitGrepLinePrefix(line) {
   // Caller context decides whether line-number-only output is possible. A
   // relative path may itself start with digits + '-' (e.g. `12-x\path.txt`),
   // so this parser must not reject `^\d+[:\-]` by shape alone.
-  const delim = text.slice(searchFrom).match(/([:-])(\d+)\1/);
+  // `matchOnly`: the caller ran rg without context lines, so only `:N:` is a
+  // delimiter and a `-N-` segment belongs to the filename (`config-12-a.txt`).
+  const delim = text.slice(searchFrom).match(matchOnly ? /(:)(\d+):/ : /([:-])(\d+)\1/);
   if (!delim) return null;
   const pathEnd = searchFrom + delim.index;
   if (pathEnd <= 0) return null;
@@ -68,7 +70,13 @@ export function parseGrepContextHeader(line) {
   };
 }
 
-export function normalizeGrepLine(line, pathOnly = false, outputMode = 'content', filenameOmitted = false) {
+export function normalizeGrepLine(
+  line,
+  pathOnly = false,
+  outputMode = 'content',
+  filenameOmitted = false,
+  matchOnly = false
+) {
   if (process.platform !== 'win32') return line;
   // files_with_matches mode: the WHOLE line is a path, so every separator is
   // a path separator and a full `\`->`/` normalisation is correct.
@@ -79,7 +87,7 @@ export function normalizeGrepLine(line, pathOnly = false, outputMode = 'content'
   // There is no path prefix to normalise; everything after ^\d+[:\-] is
   // source content and must remain byte-exact.
   if (filenameOmitted && splitGrepLineNumberOnlyPrefix(line)) return line;
-  const split = splitGrepLinePrefix(line);
+  const split = splitGrepLinePrefix(line, matchOnly);
   if (split) {
     return line.slice(0, split.pathEnd).replace(/\\/g, '/') + line.slice(split.pathEnd);
   }
@@ -99,7 +107,8 @@ export function normalizeGrepLine(line, pathOnly = false, outputMode = 'content'
 function parseGrepContentLine(line) {
   const text = String(line || '');
   if (!text || text === '--' || text.startsWith('... [')) return null;
-  const split = splitGrepLinePrefix(text);
+  // Grouping only runs on context-free content output.
+  const split = splitGrepLinePrefix(text, true);
   if (split?.delimiter !== ':') return null;
   const content = text.slice(split.markerEnd);
   return { path: split.path, lineNo: split.lineNo, content };