mixdog 1.4.1 → 1.4.2

package/src/runtime/shared/turn-worktree-snapshot.mjs

@@ -104,9 +104,10 @@ async function runGit(
     maxBytes = COMMAND_MAX_BYTES,
     allowFailure = false,
     stdoutEncoding = 'utf8',
+    env = null,
   } = {}
 ) {
-  const result = await runGitOffThread(args, { cwd, input, timeoutMs, maxBytes, stdoutEncoding });
+  const result = await runGitOffThread(args, { cwd, input, env, timeoutMs, maxBytes, stdoutEncoding });
   if (result.code !== 0 && !allowFailure) throw commandError(args, result.stderr, result.code);
   return result;
 }
@@ -142,6 +143,7 @@ function stateForRoot(root) {
     gitDir,
     initialized: false,
     sourceIndexPath: null,
+    sourcePaths: null,
     sourceIndexIdentity: null,
     sourceTracked: new Set(),
     lineEndingArgs: [],
@@ -233,7 +235,7 @@ function assertStateLive(state) {
   throw error;
 }
 
-function shadowArgs(state, args) {
+function shadowArgs(state, args, workTree = state.root) {
   assertStateLive(state);
   return [
     ...state.lineEndingArgs,
@@ -245,7 +247,7 @@ function shadowArgs(state, args) {
     '--git-dir',
     state.gitDir,
     '--work-tree',
-    state.root,
+    workTree,
     ...args,
   ];
 }
@@ -259,21 +261,62 @@ async function sourceGitPath(root, suffix) {
   return result.code === 0 && value ? resolve(root, value) : null;
 }
 
-async function syncSourceExclude(state) {
-  const source = await sourceGitPath(state.root, 'info/exclude');
-  if (!source || !(await exists(source))) return;
-  const target = join(state.gitDir, 'info', 'exclude');
-  await mkdir(dirname(target), { recursive: true });
-  await copyFile(source, target).catch(() => {});
+/** The source repository's info/exclude, index and common directory paths
+ *  from one `rev-parse`, kept for the state's lifetime once answered (the
+ *  index path already was). An unanswered or unexpected reply falls back to
+ *  the per-path reads, uncached, so a failure is retried as before. */
+async function sourceGitPaths(state) {
+  if (state.sourcePaths) return state.sourcePaths;
+  const result = await runGit(
+    [
+      'rev-parse',
+      '--path-format=absolute',
+      '--git-path',
+      'info/exclude',
+      '--git-path',
+      'index',
+      '--git-common-dir',
+    ],
+    { cwd: state.root, allowFailure: true }
+  );
+  const lines = String(result.stdout || '')
+    .split(/\r?\n/)
+    .filter((line) => line !== '');
+  if (result.code === 0 && lines.length === 3 && lines.every((line) => clean(line))) {
+    const [exclude, index, commonDir] = lines.map((line) => clean(line));
+    state.sourcePaths = {
+      exclude: resolve(state.root, exclude),
+      index: resolve(state.root, index),
+      commonDir,
+    };
+    return state.sourcePaths;
+  }
+  const [exclude, index, commonDir] = await Promise.all([
+    sourceGitPath(state.root, 'info/exclude'),
+    sourceGitPath(state.root, 'index'),
+    sourceCommonDir(state.root),
+  ]);
+  return { exclude, index, commonDir };
 }
 
-async function syncAlternates(state) {
+async function sourceCommonDir(root) {
   const result = await runGit(['rev-parse', '--path-format=absolute', '--git-common-dir'], {
-    cwd: state.root,
+    cwd: root,
     allowFailure: true,
   });
   const commonDir = clean(result.stdout);
-  if (result.code !== 0 || !commonDir) return;
+  return result.code === 0 && commonDir ? commonDir : null;
+}
+
+async function syncSourceExclude(state, source) {
+  if (!source || !(await exists(source))) return;
+  const target = join(state.gitDir, 'info', 'exclude');
+  await mkdir(dirname(target), { recursive: true });
+  await copyFile(source, target).catch(() => {});
+}
+
+async function syncAlternates(state, commonDir) {
+  if (!commonDir) return;
   const sourceObjects = join(resolve(state.root, commonDir), 'objects');
   if (!(await exists(sourceObjects))) return;
   const alternates = [sourceObjects];
@@ -294,7 +337,7 @@ async function syncAlternates(state) {
 }
 
 async function sourceIndexIdentity(state) {
-  state.sourceIndexPath ??= await sourceGitPath(state.root, 'index');
+  state.sourceIndexPath ??= (await sourceGitPaths(state)).index;
   if (!state.sourceIndexPath) return 'missing';
   try {
     const stat = await lstat(state.sourceIndexPath);
@@ -349,10 +392,14 @@ async function ensureState(state) {
       'utf8'
     );
   }
+  // One layout read serves both syncs below. Every (re)initialisation reads the
+  // source layout afresh, so a changed `.git` indirection is never served stale.
+  state.sourcePaths = null;
+  const paths = await sourceGitPaths(state);
   const [lineEndingArgs] = await Promise.all([
     sourceLineEndingArgs(state.root),
-    syncSourceExclude(state),
-    syncAlternates(state),
+    syncSourceExclude(state, paths.exclude),
+    syncAlternates(state, paths.commonDir),
   ]);
   state.lineEndingArgs = lineEndingArgs;
   // Seed once per process, then keep this index synchronized with the live
@@ -366,7 +413,7 @@ async function ensureState(state) {
 
 async function resetShadowIndex(state) {
   state.lastCapture = null;
-  state.sourceIndexPath ??= await sourceGitPath(state.root, 'index');
+  state.sourceIndexPath ??= (await sourceGitPaths(state)).index;
   const sourceIndex = state.sourceIndexPath;
   const target = join(state.gitDir, 'index');
   if (sourceIndex && (await exists(sourceIndex))) {
@@ -545,7 +592,9 @@ function withOmittedBaselines(snapshot, review) {
   return { ...review, files, patch, diffTooLarge: reviewDiffTooLarge(files, patch) };
 }
 
-async function applyBaselineFilesUnlocked(state, tree, allEntries) {
+/** `tree` with `allEntries` (recorded first states) applied. `absent`: keys of
+ *  paths known not to be in `tree`, whose removal is a no-op and runs no git. */
+async function applyBaselineFilesUnlocked(state, tree, allEntries, { absent = null } = {}) {
   // Omitted baselines change no tree: they are carried as metadata only.
   const files = allEntries
     .filter((entry) => entry?.omitted === true)
@@ -555,37 +604,257 @@ async function applyBaselineFilesUnlocked(state, tree, allEntries) {
       omitted: true,
       size: Number(entry.size) || 0,
     }));
-  const entries = allEntries.filter((entry) => entry?.omitted !== true);
-  if (entries.length === 0) return { tree, files };
-  const saved = clean((await runGit(shadowArgs(state, ['write-tree']), { cwd: state.root })).stdout);
-  try {
-    await runGit(shadowArgs(state, ['read-tree', tree]), { cwd: state.root });
-    for (const entry of entries) {
+  const entries = allEntries
+    .filter((entry) => entry?.omitted !== true)
+    .map((entry) => {
       const path = safeRelativePath(state.root, entry.path);
-      let oid = entry.oid || null;
-      if (entry.content !== undefined && entry.content !== null) {
-        oid = clean(
-          (
-            await runGit(shadowArgs(state, ['hash-object', '-w', '--stdin', '--path', path]), {
-              cwd: state.root,
-              input: entry.content,
-            })
-          ).stdout
-        );
+      const content = entry.content !== undefined && entry.content !== null ? entry.content : null;
+      const noop = content === null && !entry.oid && Boolean(absent?.has(pathKey(path)));
+      return { path, content, oid: entry.oid || null, noop };
+    });
+  if (entries.every((entry) => entry.noop)) {
+    return { tree, files: [...files, ...entries.map(({ path }) => ({ path, oid: null }))] };
+  }
+  try {
+    return await applyInIndex(state, tree, entries, files, temporaryIndexEnv(state), { batch: true });
+  } catch {
+    // The original sequence in the shadow index: it fails, if at all, as before.
+    return await applyInShadowIndex(state, tree, entries, files);
+  }
+}
+
+let temporaryIndexSeq = 0;
+
+/** An environment whose git index is a fresh file in the shadow repository. */
+function temporaryIndexEnv(state) {
+  const index = join(state.gitDir, `index.baseline-${process.pid}-${++temporaryIndexSeq}`);
+  return { ...process.env, GIT_INDEX_FILE: index };
+}
+
+/** `content` written as a blob, converted as the file at `path` would be. */
+async function hashBlob(state, path, content, env) {
+  const result = await runGit(shadowArgs(state, ['hash-object', '-w', '--stdin', '--path', path]), {
+    cwd: state.root,
+    input: content,
+    env,
+  });
+  return clean(result.stdout);
+}
+
+let blobWorkSeq = 0;
+// A path component a scratch worktree file could not carry unchanged: a
+// character or name the platform rewrites (Windows device names, trailing dots
+// and spaces, 8.3 aliases) or git treats specially (`.git`, `.gitattributes`).
+const UNBATCHABLE_COMPONENT =
+  /[\u0000-\u001f"*:<>?|\\]|[. ]$|~\d|^(?:con|prn|aux|nul|(?:com|lpt)[0-9\u00b9\u00b2\u00b3])(?:\..*)?$|^\.(?:git|gitattributes)$/i;
+// Longest scratch file path written: below the classic Windows MAX_PATH.
+const MAX_BATCH_PATH = 240;
+
+function batchKey(path) {
+  return path.normalize('NFC').toLowerCase();
+}
+
+/** Blob ids of `items` (`{ path, content }`) as `hash-object --stdin --path`
+ *  gives them, in a constant number of git processes. hash-object takes its
+ *  attributes, `core.autocrlf` and eol conversion from the file's path, so the
+ *  contents are written to a scratch worktree at the same relative paths, with
+ *  the real worktree's `.gitattributes` files beside them, and hashed there by
+ *  one `hash-object --stdin-paths`: the same attribute stack, the same
+ *  conversion code. A path with a `filter=` attribute (a clean driver may read
+ *  the worktree) and a path the scratch worktree cannot represent exactly are
+ *  hashed one by one as before. Any failure throws and the caller falls back. */
+async function hashBlobs(state, items, env) {
+  const ids = new Map();
+  const batched = [];
+  const single = [];
+  const keys = new Set();
+  const scratch = join(state.gitDir, `baseline-work-${process.pid}-${++blobWorkSeq}`);
+  for (const item of items) {
+    const key = batchKey(item.path);
+    const fits =
+      !keys.has(key) &&
+      scratch.length + 1 + item.path.length <= MAX_BATCH_PATH &&
+      !item.path.split('/').some((part) => UNBATCHABLE_COMPONENT.test(part));
+    if (fits) {
+      keys.add(key);
+      batched.push(item);
+    } else {
+      single.push(item);
+    }
+  }
+  if (batched.length > 0) {
+    try {
+      const directories = new Set(['']);
+      for (const { path } of batched) {
+        for (let dir = dirname(path); dir !== '.'; dir = dirname(dir)) directories.add(dir);
+      }
+      await mkdir(scratch, { recursive: true });
+      await Promise.all([...directories].map((dir) => mkdir(join(scratch, dir), { recursive: true })));
+      await Promise.all([
+        ...batched.map(({ path, content }) => writeFile(join(scratch, path), content)),
+        // git ignores a symbolic-link .gitattributes, so only a regular file is carried over.
+        ...[...directories].map(async (dir) => {
+          const source = join(state.root, dir, '.gitattributes');
+          if ((await lstat(source).catch(() => null))?.isFile()) await copyFile(source, join(scratch, dir, '.gitattributes'));
+        }),
+      ]);
+      const options = { cwd: scratch, env };
+      const filtered = await runGit(shadowArgs(state, ['check-attr', '-z', '--stdin', 'filter'], scratch), {
+        ...options,
+        input: `${batched.map(({ path }) => path).join('\0')}\0`,
+      });
+      const fields = filtered.stdout.split('\0');
+      const driven = new Set();
+      for (let index = 0; index + 2 < fields.length; index += 3) {
+        if (fields[index + 2] !== 'unspecified') driven.add(fields[index]);
+      }
+      const plain = batched.filter((item) => {
+        if (!driven.has(item.path)) return true;
+        single.push(item);
+        return false;
+      });
+      if (plain.length > 0) {
+        const hashed = await runGit(shadowArgs(state, ['hash-object', '-w', '--stdin-paths'], scratch), {
+          ...options,
+          input: `${plain.map(({ path }) => path).join('\n')}\n`,
+        });
+        const oids = hashed.stdout.split('\n').filter(Boolean);
+        if (oids.length !== plain.length) throw new Error('hash-object answered a different number of blobs');
+        plain.forEach((item, index) => ids.set(item, oids[index].trim()));
+      }
+    } finally {
+      await rm(scratch, { recursive: true, force: true }).catch(() => {});
+    }
+  }
+  for (const item of single) ids.set(item, await hashBlob(state, item.path, item.content, env));
+  return ids;
+}
+
+// Longest ls-tree command line the directory/file probe sends.
+const MAX_PROBE_CHARS = 24_000;
+
+/** Every proper parent directory of `path`, outermost last. */
+function parentDirectories(path) {
+  const parents = [];
+  for (let dir = dirname(path); dir !== '.' && dir !== '/'; dir = dirname(dir)) parents.push(dir);
+  return parents;
+}
+
+/** Could `update-index --index-info` take `addPaths` on top of `tree` without
+ *  replacing anything? Unlike `--cacheinfo`, it replaces a file by a directory
+ *  of the same name and the reverse; the per-file sequence refuses both and
+ *  the caller must see that refusal. False for a pair of added paths where one
+ *  is a directory of the other, or an added path whose parent is a file (or
+ *  submodule) in `tree`, or that is a directory in `tree`. A path the probe
+ *  cannot ask about exactly (a leading ':' is pathspec magic) or too many to
+ *  ask at once counts as unsafe, so the caller runs the per-file sequence. */
+async function addsReplaceNothing(state, tree, addPaths, env) {
+  if (addPaths.length === 0) return true;
+  if (addPaths.some((path) => path.startsWith(':'))) return false;
+  const added = new Set(addPaths);
+  const parents = new Set(addPaths.flatMap(parentDirectories));
+  if ([...parents].some((dir) => added.has(dir))) return false;
+  const asked = [...new Set([...added, ...parents])];
+  if (asked.reduce((total, path) => total + path.length + 1, 0) > MAX_PROBE_CHARS) return false;
+  const listed = await runGit(shadowArgs(state, ['ls-tree', '-z', tree, '--', ...asked]), {
+    cwd: state.root,
+    env,
+  });
+  for (const record of listed.stdout.split('\0')) {
+    const tab = record.indexOf('\t');
+    if (tab < 0) continue;
+    const isTree = record.slice(0, tab).split(' ')[1] === 'tree';
+    const path = record.slice(tab + 1);
+    if (isTree ? added.has(path) : parents.has(path)) return false;
+  }
+  return true;
+}
+
+/** The entries applied on top of `tree` in an index of their own, removed
+ *  afterwards: the shadow index is never touched, so it needs no save and
+ *  restore. Every command (hash-object's attribute lookup included) sees the
+ *  same index content the original sequence does: `tree` plus the entries so
+ *  far. Null `env`: the shadow index itself (the caller saves and restores).
+ *  `batch`: when it spawns fewer git processes and no entry swaps a file for a
+ *  directory (addsReplaceNothing), every blob is hashed together (hashBlobs)
+ *  and every add and removal is one `update-index --index-info`, instead of a
+ *  `hash-object` and an `update-index` per entry. */
+async function applyInIndex(state, tree, entries, baseFiles, env, { batch = false } = {}) {
+  const files = [...baseFiles];
+  try {
+    const live = entries.filter(({ noop }) => !noop);
+    const contents = live.filter(({ content }) => content !== null).length;
+    const adds = live.filter(({ content, oid }) => content !== null || oid).map(({ path }) => path);
+    // Per entry: a hash (content) plus an update-index, or an update-index. In
+    // batch: check-attr and hash-object for all contents, an ls-tree probe
+    // when anything is added, and one update-index.
+    const worthBatching =
+      batch && (contents > 0 ? 2 : 0) + 1 + (adds.length > 0 ? 1 : 0) < 2 * contents + (live.length - contents);
+    const [, replacesNothing] = await Promise.all([
+      runGit(shadowArgs(state, ['read-tree', tree]), { cwd: state.root, env }),
+      worthBatching ? addsReplaceNothing(state, tree, adds, env) : false,
+    ]);
+    if (replacesNothing) {
+      const hashed = await hashBlobs(
+        state,
+        live.filter(({ content }) => content !== null),
+        env
+      );
+      const nullOid = '0'.repeat(tree.length);
+      let info = '';
+      for (const entry of entries) {
+        if (entry.noop) {
+          files.push({ path: entry.path, oid: null });
+          continue;
+        }
+        const oid = entry.content !== null ? hashed.get(entry) : entry.oid;
+        // Mode 0 removes the path, as `update-index --force-remove` did.
+        info += oid ? `100644 ${oid}\t${entry.path}\0` : `0 ${nullOid}\t${entry.path}\0`;
+        files.push({ path: entry.path, oid });
+      }
+      await runGit(shadowArgs(state, ['update-index', '-z', '--index-info']), {
+        cwd: state.root,
+        env,
+        input: info,
+      });
+      entries = [];
+    }
+    for (const { path, content, oid: recorded, noop } of entries) {
+      if (noop) {
+        files.push({ path, oid: null });
+        continue;
+      }
+      let oid = recorded;
+      if (content !== null) {
+        oid = await hashBlob(state, path, content, env);
       }
       if (oid) {
         await runGit(shadowArgs(state, ['update-index', '--add', '--cacheinfo', '100644', oid, path]), {
           cwd: state.root,
+          env,
         });
       } else {
-        await runGit(shadowArgs(state, ['update-index', '--force-remove', '--', path]), { cwd: state.root });
+        await runGit(shadowArgs(state, ['update-index', '--force-remove', '--', path]), { cwd: state.root, env });
       }
       files.push({ path, oid });
     }
     return {
-      tree: clean((await runGit(shadowArgs(state, ['write-tree']), { cwd: state.root })).stdout),
+      tree: clean((await runGit(shadowArgs(state, ['write-tree']), { cwd: state.root, env })).stdout),
       files,
     };
+  } finally {
+    if (env) {
+      await rm(env.GIT_INDEX_FILE, { force: true }).catch(() => {});
+      await rm(`${env.GIT_INDEX_FILE}.lock`, { force: true }).catch(() => {});
+    }
+  }
+}
+
+/** The original sequence: the shadow index saved as a tree, used, restored. */
+async function applyInShadowIndex(state, tree, entries, files) {
+  const saved = clean((await runGit(shadowArgs(state, ['write-tree']), { cwd: state.root })).stdout);
+  try {
+    return await applyInIndex(state, tree, entries, files, null);
   } finally {
     await runGit(shadowArgs(state, ['read-tree', saved]), { cwd: state.root });
   }
@@ -603,13 +872,26 @@ async function materializeToolBaselines(snapshot) {
     }
   );
   const present = new Set(splitNulList(listed.stdout).map(pathKey));
-  const ignoredResult = await runGit(['check-ignore', '--no-index', '-z', '--stdin'], {
-    cwd: state.root,
-    input: `${paths.join('\0')}\0`,
-    allowFailure: true,
-  });
-  if (ignoredResult.code > 1) throw commandError(['check-ignore'], ignoredResult.stderr, ignoredResult.code);
-  const ignored = new Set(splitNulList(ignoredResult.stdout).map(pathKey));
+  // A leading ':' is pathspec magic to ls-tree and check-ignore: such a path
+  // may not have been read literally, so every read below runs as before.
+  const literal = paths.every((path) => !path.startsWith(':'));
+  // The ignore answer is only consulted for bytes kept for a path that is
+  // neither in the baseline tree nor tracked, and small enough to keep.
+  const asksIgnored = ([path, content]) =>
+    Buffer.isBuffer(content) &&
+    !present.has(pathKey(path)) &&
+    !state.sourceTracked.has(pathKey(path)) &&
+    content.length <= MAX_UNTRACKED_FILE_BYTES;
+  let ignored = new Set();
+  if (!literal || pending.some(asksIgnored)) {
+    const ignoredResult = await runGit(['check-ignore', '--no-index', '-z', '--stdin'], {
+      cwd: state.root,
+      input: `${paths.join('\0')}\0`,
+      allowFailure: true,
+    });
+    if (ignoredResult.code > 1) throw commandError(['check-ignore'], ignoredResult.stderr, ignoredResult.code);
+    ignored = new Set(splitNulList(ignoredResult.stdout).map(pathKey));
+  }
   const missing = pending
     .filter(
       ([path, content]) =>
@@ -624,7 +906,9 @@ async function materializeToolBaselines(snapshot) {
     .map(([path, content]) =>
       isOmittedBaseline(content) ? { path, omitted: true, size: content.size } : { path, content }
     );
-  const applied = await applyBaselineFilesUnlocked(state, snapshot.baselineTree, missing);
+  // A path ls-tree read literally and did not list is not in the tree.
+  const absent = literal ? new Set(paths.map(pathKey).filter((key) => !present.has(key))) : null;
+  const applied = await applyBaselineFilesUnlocked(state, snapshot.baselineTree, missing, { absent });
   snapshot.baselineTree = applied.tree;
   for (const entry of applied.files) snapshot.baselineFiles.set(pathKey(entry.path), entry);
   for (const [path] of pending) snapshot.pendingBaselines.delete(path);
@@ -710,14 +994,68 @@ async function patchSectionsByPath(state, baselineTree, currentTree, pathspec, m
     if (error?.code === 'EMAXBUFFER') return null;
     throw error;
   }
+  return sectionsByPath(result.stdout);
+}
+
+function sectionsByPath(patchText) {
   const sections = new Map();
-  for (const section of splitPatchSections(Buffer.from(result.stdout, 'utf8'))) {
+  for (const section of splitPatchSections(Buffer.from(patchText, 'utf8'))) {
     const path = section.newPath ?? section.oldPath;
     if (path) sections.set(pathKey(path), section.patch);
   }
   return sections;
 }
 
+/** A range's name-status, numstat and whole patch from one `git diff`
+ *  (`--raw --numstat --patch -z`: raw records, numstat records, a NUL, then
+ *  the same patch bytes a patch-only read prints). Null when that read fails
+ *  or passes the patch read's byte cap, or its output is not that shape: the
+ *  caller then takes the separate reads, which fail or bound exactly as
+ *  before. */
+async function combinedTreeDiff(state, rangeArgs) {
+  let result;
+  try {
+    result = await runGit(
+      shadowArgs(state, ['diff', '--raw', '--numstat', '--patch', '--no-ext-diff', '--unified=3', '-z', ...rangeArgs]),
+      { cwd: state.root, maxBytes: COMMAND_MAX_BYTES + PATCH_OUTPUT_SLACK_BYTES, allowFailure: true }
+    );
+  } catch (error) {
+    if (error?.code === 'EMAXBUFFER') return null;
+    throw error;
+  }
+  if (result.code !== 0) return null;
+  const text = String(result.stdout || '');
+  if (!text) return { statuses: new Map(), stats: new Map(), sections: new Map() };
+  // Raw records (each starts with ':') re-shaped as name-status tokens.
+  const nameStatus = [];
+  let cursor = 0;
+  const token = () => {
+    const end = text.indexOf('\0', cursor);
+    if (end < 0) return null;
+    const value = text.slice(cursor, end);
+    cursor = end + 1;
+    return value;
+  };
+  while (text[cursor] === ':') {
+    const header = token();
+    const status = header?.slice(header.lastIndexOf(' ') + 1);
+    if (!status) return null;
+    const paths = [token()];
+    if (status[0] === 'R' || status[0] === 'C') paths.push(token());
+    if (paths.some((path) => !path)) return null;
+    nameStatus.push(status, ...paths);
+  }
+  // Numstat records never hold an empty token after a NUL, so the first NUL
+  // pair ends them; the separator NUL follows.
+  const numstatEnd = text[cursor] === '\0' ? cursor : text.indexOf('\0\0', cursor) + 1;
+  if (numstatEnd <= 0) return null;
+  return {
+    statuses: parseNameStatus(`${nameStatus.join('\0')}\0`),
+    stats: parseNumstat(text.slice(cursor, numstatEnd)),
+    sections: sectionsByPath(text.slice(numstatEnd + 1)),
+  };
+}
+
 /** After the whole range overflowed: patches read in path batches, the
  *  smallest changes first, until the reply's total is spent. A batch that
  *  overflows is halved; a single file that does is too large. */
@@ -761,6 +1099,12 @@ async function boundedTreePatch(state, baselineTree, currentTree, pathspec, file
     sections = new Map();
     await batchedPatchSections(state, baselineTree, currentTree, files, sections);
   }
+  return boundedTreePatchFromSections(files, sections, whole);
+}
+
+/** `files` with the patch `sections` that fit the reply caps; `whole`: the
+ *  sections are a complete read, so a file without one has no patch. */
+function boundedTreePatchFromSections(files, sections, whole) {
   const budget = createReviewPatchBudget();
   const kept = [];
   const bounded = files.map((file) => {
@@ -783,12 +1127,35 @@ async function diffTreesUnlocked(state, baselineTree, currentTree, paths = null)
   // baseline describes the whole worktree, concurrent sessions included.
   const pathspec = Array.isArray(paths) && paths.length > 0 ? paths : ['.'];
   const rangeArgs = ['--find-renames', baselineTree, currentTree, '--', ...pathspec];
+  const combined = await combinedTreeDiff(state, rangeArgs);
+  if (combined) {
+    const files = reviewFiles(combined.statuses, combined.stats);
+    const bounded = boundedTreePatchFromSections(files, combined.sections, true);
+    return {
+      patch: bounded.patch,
+      files: bounded.files,
+      patchTruncated: false,
+      diffTooLarge: reviewDiffTooLarge(bounded.files, bounded.patch),
+      currentTree,
+    };
+  }
   const [nameStatus, numstat] = await Promise.all([
     runGit(shadowArgs(state, ['diff', '--name-status', '-z', ...rangeArgs]), { cwd: state.root }),
     runGit(shadowArgs(state, ['diff', '--numstat', '-z', ...rangeArgs]), { cwd: state.root }),
   ]);
-  const statuses = parseNameStatus(nameStatus.stdout);
-  const stats = parseNumstat(numstat.stdout);
+  const files = reviewFiles(parseNameStatus(nameStatus.stdout), parseNumstat(numstat.stdout));
+  const bounded = await boundedTreePatch(state, baselineTree, currentTree, pathspec, files);
+  return {
+    patch: bounded.patch,
+    files: bounded.files,
+    patchTruncated: false,
+    diffTooLarge: reviewDiffTooLarge(bounded.files, bounded.patch),
+    currentTree,
+  };
+}
+
+/** Review rows from the name-status and numstat reads of one range. */
+function reviewFiles(statuses, stats) {
   const keys = [...new Set([...statuses.keys(), ...stats.keys()])];
   const files = keys
     .map((key) => {
@@ -804,14 +1171,7 @@ async function diffTreesUnlocked(state, baselineTree, currentTree, paths = null)
       };
     })
     .sort((left, right) => left.path.localeCompare(right.path));
-  const bounded = await boundedTreePatch(state, baselineTree, currentTree, pathspec, files);
-  return {
-    patch: bounded.patch,
-    files: bounded.files,
-    patchTruncated: false,
-    diffTooLarge: reviewDiffTooLarge(bounded.files, bounded.patch),
-    currentTree,
-  };
+  return files;
 }
 
 /** One file's patch between two trees (a rename read with its old path), up