mixdog 1.2.1 → 1.2.3

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

@@ -1,54 +1,80 @@
-import { createTwoFilesPatch } from 'diff';
-import { lstat, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { isAbsolute, relative, resolve } from 'node:path';
 import {
   _resetTurnWorktreeSnapshotsForTest,
+  canonicalPath,
   createTurnWorktreeSnapshot,
-  freezeTurnWorktreeChanges,
   noteTurnWorktreeChange,
   refreshTurnWorktreeSnapshot,
   recordTurnWorktreeFileChange,
+  resumeTurnWorktreeFilePatch,
   resumeTurnWorktreeSnapshot,
-  revertTurnWorktreeFile,
-  revertTurnWorktreePaths,
-  revertTurnWorktreeSnapshot,
 } from './turn-worktree-snapshot.mjs';
 import {
+  clearSessionChangeHistory as clearStoredChangeHistory,
   loadSessionSnapshotRecords,
   loadTurnChangeRecord,
   loadTurnChangeRecords,
   loadTurnSnapshotRecord,
   saveTurnSnapshotRecord,
+  sessionChangeHistoryCleared,
   updateTurnChangeRecord,
   upsertTurnChangeRecord,
 } from './turn-snapshot-store.mjs';
 import {
   applyTurnChangeFiles,
+  changeDisplayPatch,
   changePathKey,
   findChangeFile,
+  isBinaryChangeContent,
   measureLegacyChangeFile,
-  mergeRecordedSessionChanges,
   namedChangePatch,
+  repositoryObjectFormat,
+  sessionChangeReview,
+  splitPatchSections,
   storedChangeFile,
   trackedChangeFile,
   turnChangesReply,
   unknownStateChangeFile,
 } from './turn-changes.mjs';
-import { boundReviewPatch } from './review-diff.mjs';
+import {
+  _resetSessionBaselinesForTest,
+  captureSessionBaselines,
+  clearSessionBaselines,
+  loadSessionBaselines,
+  primeReviewOwner,
+  recordReviewOwner,
+} from './session-baseline-store.mjs';
+import {
+  boundReviewPatch,
+  createReviewPatchBudget,
+  filePatchReply,
+  patchOmittedFile,
+  REVIEW_FILE_PATCH_SHOW_MAX_BYTES,
+  reviewDiffTooLarge,
+  reviewSectionTruncated,
+} from './review-diff.mjs';
 import { PATCH_EDIT_MAX_BYTES } from './bounded-file-read.mjs';
 import { cleanString as clean } from './clean.mjs';
+import { createLineDiffBudget, lineDiffHunks, unifiedHunksBody } from './bounded-line-diff.mjs';
 
 // Turn-scoped review registry.
 //
-// A Git worktree gets a shadow-index snapshot at turn start,
-// then compares that immutable tree with the latest worktree state. This makes
-// the headline authoritative for apply_patch, shell, and external edits while
-// preserving changes that already existed before the turn. Non-Git worktrees
-// retain the exact apply_patch tracker below.
+// Every file tool write folds its exact before/after bytes into the session's
+// tracker as ordered own segments per file: a write that starts from the
+// bytes the file's last segment ended with extends that segment, any other
+// opens a new one, so whatever changed the file in between (a foreign edit)
+// is in no segment. The turn review, its change record and every Undo/
+// Reapply/latest-turn revert work from those segments only, reverse-applied
+// newest first against the current disk with conflict detection: a foreign
+// edit outside the turn's hunks survives an Undo, and one overlapping them
+// fails it instead of being overwritten. Each file counts the summed line
+// deltas of its own writes.
 //
-// Worker apply_patch trackers remain separate and are frozen into the owning
-// Lead turn as attribution metadata. Their stats are never added a second time
-// to a worktree snapshot's authoritative totals.
+// A Git worktree also gets a shadow-index snapshot at turn start: the durable
+// baseline of the session-wide review.
+//
+// Worker trackers remain separate until the worker completes: then its
+// segments, owned paths and counts join the owning Lead turn's.
 
 const DISABLED = /^(0|false|off)$/i.test(String(process.env.MIXDOG_TURN_SNAPSHOT || ''));
 const TURN_CACHE_MAX = 32;
@@ -61,6 +87,9 @@ const MAX_AGENT_REVIEW_BYTES_PER_TURN = 4 * 1024 * 1024;
 const _turnsBySession = new Map();
 const _diffTrackersBySession = new Map();
 let _agentTurnSeq = 0;
+// Orders every tracked write across trackers, so a worker's segments merge into
+// its Lead's in the order the writes happened.
+let _writeSeq = 0;
 // `${sessionId}\0${checkpointId}` → seals in flight. A sealing turn's change
 // record is `pending` and its session refuses Undo/Reapply until it lands.
 const _pendingFreezes = new Map();
@@ -130,28 +159,58 @@ function ownedPathsUnder(root, owned) {
   return out;
 }
 
-/** Paths the turn's checkpoint diff itself observed. Only an uncontended
- *  worktree can attribute them to this session; a contended one falls back to
- *  the exact tool-owned list. */
-function checkpointObservedPaths(tracker) {
-  if (!worktreeSnapshotUsable(tracker)) return [];
-  const out = [];
-  for (const file of tracker.worktreeSnapshot.files || []) {
-    if (file?.path) out.push(String(file.path).replace(/\\/g, '/'));
-    if (file?.oldPath) out.push(String(file.oldPath).replace(/\\/g, '/'));
-  }
-  return out;
+/** Fold one write's line counts into `stats` (owned entry key → summed
+ *  counts). A rename moves the source's counts to its destination; a change
+ *  that reports no counts (an Undo/Reapply fold) adds nothing. */
+function foldOwnStats(stats, raw, source, destination) {
+  const measured = Number.isFinite(raw?.additions) || Number.isFinite(raw?.deletions);
+  const prior = stats.get(source.key);
+  if (destination) stats.delete(source.key);
+  const target = destination || source;
+  const existing = destination ? stats.get(destination.key) : null;
+  if (!prior && !existing && !measured) return;
+  stats.set(target.key, {
+    path: target.path,
+    display: target.display,
+    additions: (prior?.additions || 0) + (existing?.additions || 0) + (Number(raw?.additions) || 0),
+    deletions: (prior?.deletions || 0) + (existing?.deletions || 0) + (Number(raw?.deletions) || 0),
+  });
 }
 
-/** Everything this session changed under `root`: the files its own tools
- *  wrote plus every file its checkpoint diffs observed. This is the
- *  attribution the session-wide Diff and the recorded revert scope share. */
-function sessionAttributedPaths(root, tracker) {
-  const paths = ownedPathsUnder(root, tracker?.ownedPaths);
-  if (tracker?.worktreeSnapshot && pathKey(tracker.worktreeSnapshot.root) === pathKey(root)) {
-    for (const path of checkpointObservedPaths(tracker)) paths.add(path);
+function mergeOwnStats(target, source) {
+  for (const [key, entry] of source) {
+    const prior = target.get(key);
+    target.set(
+      key,
+      prior
+        ? { ...prior, additions: prior.additions + entry.additions, deletions: prior.deletions + entry.deletions }
+        : { ...entry }
+    );
   }
-  return paths;
+}
+
+/** Lookup of the tracker's own-write counts by a reviewed file path: relative
+ *  to `root`, or (`display`) the tools' display path a tracked patch shows. */
+function ownCountIndex(tracker, root, { display = false } = {}) {
+  const keyOf = (path) => pathKey(display ? path : resolve(root, path));
+  const index = new Map();
+  for (const entry of tracker?.ownStats?.values() || []) index.set(keyOf(display ? entry.display : entry.path), entry);
+  return (path) => (path ? index.get(keyOf(path)) : undefined);
+}
+
+/** Files counted by the summed per-call deltas of their own writes (a
+ *  rename's old path included). A file no own write reported counts for
+ *  keeps the counts it has. */
+function withOwnCounts(files, find) {
+  return files.map((file) => {
+    const hits = [find(file.path), file.oldPath ? find(file.oldPath) : undefined].filter(Boolean);
+    if (hits.length === 0) return file;
+    return {
+      ...file,
+      additions: hits.reduce((sum, hit) => sum + hit.additions, 0),
+      deletions: hits.reduce((sum, hit) => sum + hit.deletions, 0),
+    };
+  });
 }
 
 // A change whose bytes were never captured (binary/oversized) carries
@@ -206,23 +265,30 @@ function createDiffTracker(meta = {}) {
     // The seal (refresh, record, freeze) in flight, if any.
     freezing: null,
     revision: 0,
-    baselineByPath: new Map(),
-    currentByPath: new Map(),
-    originByCurrentPath: new Map(),
-    unifiedDiff: '',
-    patchTruncated: false,
+    // Current path key → { segments }: the file's own segments in write
+    // order, each `{ before, after, firstSeq, lastSeq }` whose sides are
+    // `{ path, displayPath, content }` (content null = absent).
+    chains: new Map(),
+    // Current path key → { chain, owned, stats } of a chain an Undo restored,
+    // kept so a Reapply puts it back.
+    undoneChains: new Map(),
+    // The review rendered for one revision (trackerView).
+    view: null,
     worktreeSnapshot: null,
     // Session-owned relative paths. These outlive the before/after buffers on
     // purpose: they are what scopes a revert once the exact content is gone.
     ownedPaths: new Set(),
+    // Owned entry key → { path, display, additions, deletions }: the summed
+    // line deltas of every own write of the file. Outlives the buffers too.
+    ownStats: new Map(),
   };
 }
 
 function releaseDiffTrackerContent(tracker) {
   if (!tracker) return;
-  tracker.baselineByPath.clear();
-  tracker.currentByPath.clear();
-  tracker.originByCurrentPath.clear();
+  tracker.chains.clear();
+  tracker.undoneChains.clear();
+  tracker.view = null;
 }
 
 function resetDiffTracker(sessionId, meta = {}) {
@@ -235,254 +301,307 @@ function resetDiffTracker(sessionId, meta = {}) {
 
 function trackedContentBytes(tracker) {
   let total = 0;
-  for (const entry of tracker.baselineByPath.values()) total += entry.content?.length || 0;
-  for (const entry of tracker.currentByPath.values()) total += entry.content?.length || 0;
+  for (const chain of tracker.chains.values()) {
+    for (const { before, after } of chain.segments) {
+      total += contentByteLength(before.content) + contentByteLength(after.content);
+    }
+  }
   return total;
 }
 
-const utf8Decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
-function decodeTrackedContent(content) {
-  if (content === null) return '';
-  try {
-    return utf8Decoder.decode(content);
-  } catch {
-    return null;
+/** A segment that leaves its file where and as it found it. */
+function noopSegment({ before, after }) {
+  return pathKey(before.path) === pathKey(after.path) && sameContent(before.content, after.content);
+}
+
+/** Join one own segment to the chain of the file it starts at. It extends the
+ *  chain's last segment when it starts from that segment's exact after bytes;
+ *  otherwise something else changed the file in between, and it opens a new
+ *  segment so that change stays out of both. A move onto a path another chain
+ *  holds lands as a delete of its source and a write of its destination. */
+function appendSegment(tracker, segment) {
+  const startKey = pathKey(segment.before.path);
+  const endKey = pathKey(segment.after.path);
+  if (startKey !== endKey && tracker.chains.has(endKey)) {
+    appendSegment(tracker, { ...segment, after: { ...segment.before, content: null } });
+    appendSegment(tracker, { ...segment, before: { ...segment.after, content: null } });
+    return;
   }
+  const chain = tracker.chains.get(startKey) || { segments: [] };
+  tracker.chains.delete(startKey);
+  const last = chain.segments.at(-1);
+  if (last && sameContent(last.after.content, segment.before.content)) {
+    last.after = segment.after;
+    last.lastSeq = segment.lastSeq;
+  } else {
+    chain.segments.push({ ...segment });
+  }
+  tracker.chains.set(endKey, chain);
+}
+
+const isBinarySide = (content) => isOmittedContent(content) || isBinaryChangeContent(content);
+
+/** What a chain records, relative to `root`: its segments that change
+ *  something — of a binary file only the last, since bytes from before a
+ *  foreign rewrite cannot be restored around it — as steps with the
+ *  root-relative paths of their sides ('' outside the root). `start`/`end`
+ *  are the sides the change begins and ends at (a created file has no old
+ *  side, a deleted one no new side). Null when the chain changes nothing. */
+function chainEdit(chain, root) {
+  let segments = chain.segments.filter((segment) => !noopSegment(segment));
+  if (segments.length === 0) return null;
+  const binary = segments.some(({ before, after }) => [before.content, after.content].some(isBinarySide));
+  if (binary) segments = segments.slice(-1);
+  const steps = segments.map(({ before, after }) => ({
+    before,
+    after,
+    oldPath: trackedRelativePath(root, before),
+    newPath: trackedRelativePath(root, after),
+  }));
+  const first = steps[0];
+  const last = steps.at(-1);
+  const start = first.before.content === null ? first.after : first.before;
+  const end = last.after.content === null ? last.before : last.after;
+  let status = 'M';
+  if (first.before.content === null && last.after.content !== null) status = 'A';
+  else if (last.after.content === null && first.before.content !== null) status = 'D';
+  else if (pathKey(start.path) !== pathKey(end.path)) status = 'R';
+  return {
+    steps,
+    start,
+    end,
+    status,
+    binary,
+    inside: steps.every((step) => step.oldPath && step.newPath),
+    omitted: steps.some(({ before, after }) => [before.content, after.content].some(isOmittedContent)),
+  };
 }
 
-function renderTrackedPair(before, after) {
-  const oldDisplay = before?.displayPath || after?.displayPath || 'unknown file';
-  const newDisplay = after?.displayPath || before?.displayPath || 'unknown file';
-  const oldGit = `a/${oldDisplay}`;
-  const newGit = `b/${newDisplay}`;
-  const oldHeader = before?.content === null ? '/dev/null' : oldGit;
-  const newHeader = after?.content === null ? '/dev/null' : newGit;
+/** A side's name in the review: relative to `root` inside it, else the
+ *  tool's display path. */
+const viewPath = (root, entry) => trackedRelativePath(root, entry) || displayPath(entry.displayPath || entry.path);
+
+/** One step's display section, named as the review shows it, with its line
+ *  counts: hunks, a `Binary files … differ` line, or the not-captured note. */
+function renderStep({ before, after }, root, budget) {
+  const oldGit = `a/${viewPath(root, before)}`;
+  const newGit = `b/${viewPath(root, after)}`;
+  const oldHeader = before.content === null ? '/dev/null' : oldGit;
+  const newHeader = after.content === null ? '/dev/null' : newGit;
   let head = `diff --git ${oldGit} ${newGit}\n`;
-  if (before?.content === null && after?.content !== null) head += 'new file mode 100644\n';
-  else if (before?.content !== null && after?.content === null) head += 'deleted file mode 100644\n';
-  const omitted = [before?.content, after?.content].find(isOmittedContent);
+  if (before.content === null) head += 'new file mode 100644\n';
+  else if (after.content === null) head += 'deleted file mode 100644\n';
+  const binaryLine = `Binary files ${oldHeader} and ${newHeader} differ\n`;
+  const omitted = [before.content, after.content].find(isOmittedContent);
   if (omitted) {
     let change = 'changed';
-    if (after?.content === null) change = 'deleted';
-    else if (before?.content === null) change = 'added';
-    return `${head}binary/large file ${change} (${omitted.size} bytes; content not captured)\nBinary files ${oldHeader} and ${newHeader} differ\n`;
+    if (after.content === null) change = 'deleted';
+    else if (before.content === null) change = 'added';
+    const note = `binary/large file ${change} (${omitted.size} bytes; content not captured)\n`;
+    return { text: `${head}${note}${binaryLine}`, additions: 0, deletions: 0 };
   }
-  const oldText = decodeTrackedContent(before?.content ?? null);
-  const newText = decodeTrackedContent(after?.content ?? null);
-  if (oldText === null || newText === null) {
-    return `${head}Binary files ${oldHeader} and ${newHeader} differ\n`;
+  if ([before.content, after.content].some(isBinaryChangeContent)) {
+    return { text: `${head}${binaryLine}`, additions: 0, deletions: 0 };
   }
-  try {
-    const generated = createTwoFilesPatch(oldHeader, newHeader, oldText, newText, '', '', { context: 3, timeout: 100 });
-    const headerStart = generated.search(/^--- /m);
-    if (headerStart >= 0) return `${head}${generated.slice(headerStart).replace(/\n*$/, '\n')}`;
-  } catch {
-    // A pathological diff timing out must not stall tool completion. Preserve
-    // the changed-file identity even when a textual hunk cannot be rendered.
+  const text = (content) => (content === null ? '' : content.toString('utf8'));
+  const { hunks } = lineDiffHunks(text(before.content), text(after.content), budget, [before.content, after.content]);
+  let additions = 0;
+  let deletions = 0;
+  for (const line of hunks.flatMap((hunk) => hunk.lines)) {
+    if (line.startsWith('+')) additions += 1;
+    else if (line.startsWith('-')) deletions += 1;
   }
-  if (before?.content === null || after?.content === null) return head;
-  if (oldDisplay !== newDisplay) {
-    return `${head}similarity index 100%\nrename from ${oldDisplay}\nrename to ${newDisplay}\n`;
-  }
-  return `${head}Binary files ${oldGit} and ${newGit} differ\n`;
-}
-
-function refreshUnifiedDiff(tracker) {
+  return { text: `${head}${unifiedHunksBody(oldHeader, newHeader, hunks)}`, additions, deletions };
+}
+
+/** The tracker's own changes as the review shows them: a row per file with
+ *  its own counts, and the display patch of its segments, named relative to
+ *  the tracker's patch root (a worker without one: the tools' display
+ *  paths). Beside a Git root a file outside it is left out, as from the
+ *  record's undoable files. Cached per revision; `budget` bounds a render. */
+function trackerView(tracker, budget = createLineDiffBudget()) {
+  const { root, kind } = trackerPatchRoot(tracker);
+  if (tracker.view?.revision === tracker.revision && tracker.view.root === root) return tracker.view;
+  const rows = [];
   if (!tracker.valid) {
-    tracker.unifiedDiff = '';
-    return;
-  }
-  const renamePairs = new Map();
-  const pairedDestinations = new Set();
-  for (const [destinationKey, originKey] of tracker.originByCurrentPath) {
-    if (
-      destinationKey === originKey ||
-      tracker.currentByPath.has(originKey) ||
-      !tracker.currentByPath.has(destinationKey) ||
-      !tracker.baselineByPath.has(originKey) ||
-      tracker.baselineByPath.has(destinationKey)
-    ) {
-      continue;
+    // The content is gone: which files changed is known, their diff is not.
+    for (const path of ownedPathsUnder(root, tracker.ownedPaths)) {
+      rows.push({ path, status: 'M', additions: 0, deletions: 0, text: '' });
     }
-    renamePairs.set(originKey, destinationKey);
-    pairedDestinations.add(destinationKey);
   }
-  const handled = new Set();
-  const allKeys = [...new Set([...tracker.baselineByPath.keys(), ...tracker.currentByPath.keys()])].sort(
-    (left, right) => {
-      const leftEntry = tracker.currentByPath.get(left) || tracker.baselineByPath.get(left);
-      const rightEntry = tracker.currentByPath.get(right) || tracker.baselineByPath.get(right);
-      return String(leftEntry?.displayPath || left).localeCompare(String(rightEntry?.displayPath || right));
-    }
-  );
-  const pairs = [];
-  for (const key of allKeys) {
-    if (!handled.add(key) || pairedDestinations.has(key)) continue;
-    const destinationKey = renamePairs.get(key);
-    if (destinationKey) handled.add(destinationKey);
-    const before = tracker.baselineByPath.get(key);
-    const after = tracker.currentByPath.get(destinationKey || key);
-    if (!before && !after) continue;
-    pairs.push([before || null, after || null]);
-  }
-  let unifiedDiff = '';
-  for (const [before, after] of pairs) {
-    const beforeContent = before?.content ?? null;
-    const afterContent = after?.content ?? null;
-    const samePath = before?.displayPath === after?.displayPath;
-    if (samePath && sameContent(beforeContent, afterContent)) continue;
-    const rendered = renderTrackedPair(
-      before || { displayPath: after?.displayPath, content: null },
-      after || { displayPath: before?.displayPath, content: null }
-    );
-    unifiedDiff += rendered;
-  }
-  const bounded = boundReviewPatch(unifiedDiff, MAX_PATCH_BYTES);
-  tracker.unifiedDiff = bounded.patch;
-  tracker.patchTruncated = bounded.truncated;
-}
-
-function trackedPairs(tracker) {
-  const pairs = [];
-  const handledOrigins = new Set();
-  for (const [destinationKey, after] of tracker.currentByPath) {
-    const originKey = tracker.originByCurrentPath.get(destinationKey) || destinationKey;
-    handledOrigins.add(originKey);
-    pairs.push({
-      originKey,
-      destinationKey,
-      before: tracker.baselineByPath.get(originKey) || null,
-      after,
+  for (const chain of tracker.chains.values()) {
+    const edit = chainEdit(chain, root);
+    if (!edit || (kind === 'git' && !edit.inside)) continue;
+    const rendered = edit.steps.map((step) => renderStep(step, root, budget));
+    const path = viewPath(root, edit.end);
+    const oldPath = viewPath(root, edit.start);
+    const omitted = edit.steps.flatMap(({ before, after }) => [before.content, after.content]).find(isOmittedContent);
+    rows.push({
+      path,
+      ...(oldPath !== path ? { oldPath } : {}),
+      status: edit.status,
+      additions: rendered.reduce((sum, step) => sum + step.additions, 0),
+      deletions: rendered.reduce((sum, step) => sum + step.deletions, 0),
+      ...(edit.binary ? { binary: true } : {}),
+      // Its bytes were never captured: listed, never diffed or undone.
+      ...(omitted ? { omitted: true, size: omitted.size } : {}),
+      text: rendered.map((step) => step.text).join(''),
     });
   }
-  for (const [originKey, before] of tracker.baselineByPath) {
-    if (handledOrigins.has(originKey)) continue;
-    pairs.push({ originKey, destinationKey: originKey, before, after: null });
-  }
-  return pairs;
-}
-
-function safeTrackedTarget(worktree, value) {
-  const root = resolve(clean(worktree));
-  const target = isAbsolute(clean(value)) ? resolve(clean(value)) : resolve(root, clean(value));
-  const rel = relative(root, target);
-  if (!rel || rel === '.' || rel.startsWith('..') || isAbsolute(rel)) {
-    throw new Error('turn review file path is outside the worktree');
-  }
-  return target;
-}
-
-function pairMatchesFile(pair, worktree, file) {
-  const requested = safeTrackedTarget(worktree, file);
-  return [pair.before, pair.after].some((entry) => {
-    if (!entry) return false;
-    const values = [entry.path, entry.displayPath].filter(Boolean);
-    return values.some((value) => safeTrackedTarget(worktree, value) === requested);
-  });
-}
-
-async function currentTrackedContent(path) {
-  try {
-    const stat = await lstat(path);
-    if (!stat.isFile() || stat.isSymbolicLink()) {
-      throw new Error('turn review revert only supports regular files');
-    }
-    return await readFile(path);
-  } catch (error) {
-    if (error?.code === 'ENOENT') return null;
-    throw error;
-  }
+  rows.sort((left, right) => left.path.localeCompare(right.path));
+  const bounded = boundReviewPatch(rows.map((row) => row.text).join(''), MAX_PATCH_BYTES);
+  const counted = root ? ownCountIndex(tracker, root) : ownCountIndex(tracker, '', { display: true });
+  tracker.view = {
+    revision: tracker.revision,
+    root,
+    files: withOwnCounts(
+      rows.map(({ text, ...row }) => row),
+      counted
+    ),
+    patch: bounded.patch,
+    truncated: bounded.truncated,
+  };
+  return tracker.view;
 }
 
-async function validateTrackedPair(pair, worktree) {
-  const omitted = [pair.before?.content, pair.after?.content].find(isOmittedContent);
-  if (omitted) {
-    const display = pair.before?.displayPath || pair.after?.displayPath || 'unknown file';
-    throw new Error(
-      `turn review revert is unavailable for ${display}: binary/large file content was not captured (${omitted.size} bytes)`
-    );
-  }
-  const beforePath = safeTrackedTarget(
-    worktree,
-    pair.before?.path || pair.before?.displayPath || pair.after?.path || pair.after?.displayPath
-  );
-  const afterPath = safeTrackedTarget(
-    worktree,
-    pair.after?.path || pair.after?.displayPath || pair.before?.path || pair.before?.displayPath
+/** True when `value` (absolute, or relative to `root`) names a path the chain
+ *  touched. */
+function chainMatchesPath(chain, root, value) {
+  const target = clean(value);
+  if (!target) return false;
+  const key = changePathKey(relative(root, isAbsolute(target) ? resolve(target) : resolve(root, target)));
+  return chain.segments.some((segment) =>
+    [segment.before, segment.after].some((entry) => {
+      const path = trackedRelativePath(root, entry);
+      return Boolean(path) && changePathKey(path) === key;
+    })
   );
-  const expectedAfter = pair.after?.content ?? null;
-  const actualAfter = await currentTrackedContent(afterPath);
-  if (!sameContent(actualAfter, expectedAfter)) {
-    throw new Error('turn review revert refused because the file changed after this session edit');
-  }
-  if (beforePath !== afterPath && (await currentTrackedContent(beforePath)) !== null) {
-    throw new Error('turn review revert refused because the original path changed after this session edit');
-  }
-  return { beforePath, afterPath };
 }
 
-async function restoreTrackedPair(pair, paths) {
-  if (paths.afterPath !== paths.beforePath) await rm(paths.afterPath, { force: true });
-  if (pair.before?.content == null) {
-    await rm(paths.beforePath, { force: true });
-  } else {
-    await mkdir(dirname(paths.beforePath), { recursive: true });
-    await writeFile(paths.beforePath, pair.before.content);
+/** The owned entries (and their counts) of every path a chain touched. */
+function chainOwnership(tracker, chain) {
+  const owned = [
+    ...new Set(
+      chain.segments
+        .flatMap((segment) => [segment.before, segment.after])
+        .map((entry) => ownedPathEntry(entry.path, displayPath(entry.displayPath || entry.path)))
+    ),
+  ].filter((entry) => tracker.ownedPaths.has(entry));
+  const stats = owned
+    .map((entry) => [pathKey(entry), tracker.ownStats.get(pathKey(entry))])
+    .filter(([, entry]) => entry);
+  return { owned, stats };
+}
+
+/** An Undo reverse-applied these chains: the turn no longer changes them, so
+ *  they leave its review. Each is kept for a Reapply. */
+function undoTrackedChains(tracker, chains) {
+  for (const [key, chain] of tracker.chains) {
+    if (!chains.includes(chain)) continue;
+    const ownership = chainOwnership(tracker, chain);
+    tracker.undoneChains.set(key, { chain, ...ownership });
+    for (const entry of ownership.owned) tracker.ownedPaths.delete(entry);
+    for (const [statKey] of ownership.stats) tracker.ownStats.delete(statKey);
+    tracker.chains.delete(key);
   }
+  tracker.revision += 1;
 }
 
-function commitTrackedPairRestore(tracker, pair) {
-  tracker.currentByPath.delete(pair.destinationKey);
-  tracker.currentByPath.delete(pair.originKey);
-  tracker.originByCurrentPath.delete(pair.destinationKey);
-  tracker.originByCurrentPath.delete(pair.originKey);
-  if (pair.before) tracker.currentByPath.set(pair.originKey, { ...pair.before });
-}
-
-async function revertTrackedPairs(tracker, worktree, pairs) {
-  if (!tracker?.valid || pairs.length === 0) {
-    throw new Error('turn review tracked file snapshot is unavailable');
-  }
-  // Validate every current file before the first write so an external edit
-  // cannot leave a turn-wide revert half-applied.
-  const validated = [];
-  for (const pair of pairs) validated.push(await validateTrackedPair(pair, worktree));
-  for (let index = 0; index < pairs.length; index += 1) {
-    await restoreTrackedPair(pairs[index], validated[index]);
-    commitTrackedPairRestore(tracker, pairs[index]);
+/** A Reapply forward-applied the undone chains matching `files` again. */
+function redoTrackedChains(tracker, root, files) {
+  for (const [key, undone] of tracker.undoneChains) {
+    const matches = files.some((file) =>
+      [file.path, file.oldPath].some((path) => chainMatchesPath(undone.chain, root, path))
+    );
+    if (!matches) continue;
+    tracker.undoneChains.delete(key);
+    tracker.chains.set(key, undone.chain);
+    for (const entry of undone.owned) tracker.ownedPaths.add(entry);
+    for (const [statKey, entry] of undone.stats) tracker.ownStats.set(statKey, entry);
   }
   tracker.revision += 1;
-  refreshUnifiedDiff(tracker);
-  if (!tracker.unifiedDiff) releaseDiffTrackerContent(tracker);
-  // The absolute paths now back at their turn-start bytes.
-  return [...new Set(validated.flatMap(({ beforePath, afterPath }) => [beforePath, afterPath]))];
 }
 
-/** A path's first observed state is its baseline; later changes never replace it. */
-function recordFirstBaseline(tracker, key, entry) {
-  if (!tracker.currentByPath.has(key) && !tracker.baselineByPath.has(key)) tracker.baselineByPath.set(key, entry);
+/** A new write supersedes whatever an Undo set aside for the paths it
+ *  touches (`keys`). */
+function dropUndoneChains(tracker, keys) {
+  for (const [key, undone] of tracker.undoneChains) {
+    const touched = undone.chain.segments.some(
+      (segment) => keys.has(pathKey(segment.before.path)) || keys.has(pathKey(segment.after.path))
+    );
+    if (touched) tracker.undoneChains.delete(key);
+  }
 }
 
 /**
  * Fold exact committed before/after file states into a session's current turn.
  * A change is `{ path, displayPath, before, after }`; a rename additionally
- * carries `{ newPath, newDisplayPath }`.
+ * carries `{ newPath, newDisplayPath }`. `budget` is the line-diff budget of
+ * the tool call the changes come from. Returns the turn's review patch.
  */
-export function recordTurnDiffChanges(sessionId, changes = []) {
+export function recordTurnDiffChanges(sessionId, changes = [], budget = createLineDiffBudget()) {
   if (DISABLED) return '';
   const id = clean(sessionId);
   if (!id) return '';
   const tracker = _diffTrackersBySession.get(id) || resetDiffTracker(id);
-  if (!tracker?.valid || tracker.sealed) return tracker?.unifiedDiff || '';
-  const snapshot = (tracker.ownerSessionId ? _diffTrackersBySession.get(tracker.ownerSessionId) : tracker)
-    ?.worktreeSnapshot;
-  foldTrackedChanges(tracker, Array.isArray(changes) ? changes : [], snapshot);
-  return tracker.unifiedDiff;
+  const ownerTracker = tracker?.ownerSessionId ? _diffTrackersBySession.get(tracker.ownerSessionId) : tracker;
+  const snapshot = ownerTracker?.worktreeSnapshot;
+  const raws = Array.isArray(changes) ? changes : [];
+  // Git reports the turn's root canonically (macOS /var -> /private/var):
+  // each written path is spelled the same way, or it never relates to it.
+  const list = snapshot?.root ? raws.map(canonicalChangePaths) : raws;
+  // Independent of this tracker's validity: the session review needs every
+  // write's first-seen state even once the turn's buffers are gone.
+  captureReviewBaselines(id, tracker, ownerTracker, list, snapshot);
+  if (!tracker) return '';
+  if (tracker.valid && !tracker.sealed) foldTrackedChanges(tracker, list, snapshot);
+  return trackerView(tracker, budget).patch;
+}
+
+function canonicalChangePaths(raw) {
+  const path = clean(raw?.path);
+  const newPath = clean(raw?.newPath);
+  return {
+    ...raw,
+    ...(isAbsolute(path) ? { path: canonicalPath(path) } : {}),
+    ...(isAbsolute(newPath) ? { newPath: canonicalPath(newPath) } : {}),
+  };
 }
 
-/** Fold exact before/after states into `tracker`. `snapshot` — the owning
- *  Lead turn's Git baseline, when tools are writing — learns each written
- *  path's first-before bytes. */
+const insidePath = (root, path) => {
+  const rel = relative(root, path);
+  return Boolean(rel) && !isAbsolute(rel) && rel.split(/[\\/]+/)[0] !== '..';
+};
+
+/** Hand each change's first-seen state to the session baselines of `sessionId`
+ *  and the Lead it works for. A path inside the turn's Git root is skipped: the
+ *  shadow baseline tree already vouches for it. */
+function captureReviewBaselines(sessionId, tracker, ownerTracker, list, snapshot) {
+  const gitRoot = clean(snapshot?.root);
+  const root = clean(tracker?.worktreeRoot) || clean(ownerTracker?.worktreeRoot);
+  const changes = [];
+  for (const raw of list) {
+    const path = clean(raw?.path);
+    if (!path || !isAbsolute(path)) continue;
+    const newPath = isAbsolute(clean(raw?.newPath)) ? resolve(clean(raw.newPath)) : '';
+    if (gitRoot && insidePath(gitRoot, path) && (!newPath || insidePath(gitRoot, newPath))) continue;
+    const before = raw?.before ?? null;
+    const after = raw?.after ?? null;
+    if (!newPath && before === null && after === null) continue;
+    changes.push({
+      path: resolve(path),
+      root,
+      before,
+      ...(newPath ? { newPath } : {}),
+      replaced: (before === null) !== (after === null),
+    });
+  }
+  captureSessionBaselines(sessionId, changes, { owner: tracker?.ownerSessionId || '' });
+}
+
+/** Fold exact before/after states into `tracker` as own segments (see
+ *  appendSegment). `snapshot` — the owning Lead turn's Git baseline, when
+ *  tools are writing — learns each written path's first-before bytes. */
 function foldTrackedChanges(tracker, list, snapshot) {
   // The content ceiling is enforced BEFORE anything is stored: an over-budget
   // batch invalidates the tracker up front instead of retaining its buffers.
@@ -511,63 +630,67 @@ function foldTrackedChanges(tracker, list, snapshot) {
     // attribution a shared worktree cannot otherwise reconstruct. It keeps the
     // ABSOLUTE file: the display path is relative to the session cwd, which
     // is not necessarily the repository root the scoped diff runs from.
-    tracker.ownedPaths.add(ownedPathEntry(sourcePath, sourceDisplay));
+    const sourceEntry = ownedPathEntry(sourcePath, sourceDisplay);
+    tracker.ownedPaths.add(sourceEntry);
+    let destination = null;
     if (destinationPath) {
-      tracker.ownedPaths.add(ownedPathEntry(destinationPath, displayPath(raw?.newDisplayPath || destinationPath)));
+      const display = displayPath(raw?.newDisplayPath || destinationPath);
+      const entry = ownedPathEntry(destinationPath, display);
+      tracker.ownedPaths.add(entry);
+      destination = { key: pathKey(entry), path: entry, display };
     }
+    foldOwnStats(
+      tracker.ownStats,
+      raw,
+      { key: pathKey(sourceEntry), path: sourceEntry, display: sourceDisplay },
+      destination
+    );
     if (!storeContent) continue;
     const after = contentBuffer(raw?.after);
-    if (!destinationPath) {
-      if (before === null && after !== null) {
-        tracker.originByCurrentPath.delete(sourceKey);
-        tracker.currentByPath.set(sourceKey, {
-          path: sourcePath,
-          displayPath: sourceDisplay,
-          content: after,
-        });
-        continue;
-      }
-      if (before !== null && after === null) {
-        if (!tracker.currentByPath.delete(sourceKey) && !tracker.baselineByPath.has(sourceKey)) {
-          tracker.baselineByPath.set(sourceKey, {
-            path: sourcePath,
-            displayPath: sourceDisplay,
-            content: before,
-          });
-        }
-        tracker.originByCurrentPath.delete(sourceKey);
-        continue;
-      }
-      if (before === null && after === null) continue;
-      recordFirstBaseline(tracker, sourceKey, { path: sourcePath, displayPath: sourceDisplay, content: before });
-      tracker.currentByPath.set(sourceKey, {
-        path: sourcePath,
-        displayPath: sourceDisplay,
-        content: after,
-      });
-      continue;
-    }
-
-    const destinationKey = pathKey(destinationPath);
-    const destinationDisplay = displayPath(raw?.newDisplayPath || destinationPath);
-    recordFirstBaseline(tracker, sourceKey, { path: sourcePath, displayPath: sourceDisplay, content: before });
-    const originKey = tracker.originByCurrentPath.get(sourceKey) || sourceKey;
-    tracker.currentByPath.delete(sourceKey);
-    tracker.originByCurrentPath.delete(sourceKey);
-    tracker.currentByPath.set(destinationKey, {
-      path: destinationPath,
-      displayPath: destinationDisplay,
-      content: after,
+    if (!destinationPath && before === null && after === null) continue;
+    dropUndoneChains(tracker, new Set([sourceKey, ...(destination ? [pathKey(destinationPath)] : [])]));
+    const seq = (_writeSeq += 1);
+    appendSegment(tracker, {
+      before: { path: sourcePath, displayPath: sourceDisplay, content: before },
+      after: destination
+        ? { path: destinationPath, displayPath: destination.display, content: after }
+        : { path: sourcePath, displayPath: sourceDisplay, content: after },
+      firstSeq: seq,
+      lastSeq: seq,
     });
-    tracker.originByCurrentPath.delete(destinationKey);
-    if (destinationKey !== originKey) tracker.originByCurrentPath.set(destinationKey, originKey);
   }
   tracker.revision += 1;
   if (trackedContentBytes(tracker) > MAX_TRACKED_CONTENT_BYTES) {
     tracker.valid = false;
     releaseDiffTrackerContent(tracker);
   }
-  refreshUnifiedDiff(tracker);
+}
+
+/** Join a completed worker's own segments to its Lead's tracker: both sets
+ *  replay in write order, so a worker write between two Lead writes of one
+ *  file continues their segment instead of reading as a foreign gap. A
+ *  worker whose content was dropped drops the Lead's exact content too. */
+function mergeTrackedContent(target, source) {
+  // The worker's owned paths and counts joined as well: any view is stale.
+  target.revision += 1;
+  if (!target.valid) return;
+  if (!source.valid) {
+    target.valid = false;
+    releaseDiffTrackerContent(target);
+    return;
+  }
+  const segmentsOf = (tracker) => [...tracker.chains.values()].flatMap((chain) => chain.segments);
+  const written = new Set(
+    segmentsOf(source).flatMap((segment) => [pathKey(segment.before.path), pathKey(segment.after.path)])
+  );
+  const segments = [...segmentsOf(target), ...segmentsOf(source)].sort((left, right) => left.firstSeq - right.firstSeq);
+  target.chains = new Map();
+  for (const segment of segments) appendSegment(target, segment);
+  dropUndoneChains(target, written);
+  if (trackedContentBytes(target) > MAX_TRACKED_CONTENT_BYTES) {
+    target.valid = false;
+    releaseDiffTrackerContent(target);
+  }
 }
 
 function trimAgentReviews(turn) {
@@ -626,16 +749,20 @@ function continueTurnSnapshot(ownerSessionId) {
 export async function beginTurnSnapshot(worktree, sessionId, options = {}) {
   const ownerSessionId = clean(sessionId);
   if (DISABLED || !ownerSessionId) return undefined;
+  // A worker resumed after a restart still credits its Lead's review (a
+  // capture racing this lookup waits for it).
+  void primeReviewOwner(ownerSessionId);
   // Turn start and Undo/Reapply share the per-session lock: a start waits for
   // an in-flight mutation, and a mutation queued after this start re-checks
   // under the lock and finds the turn running.
-  // A late-worker re-seal still queued for the previous turn runs first, in
-  // this same step: the worker's edit stays in that turn's record and nothing
-  // the new turn writes can reach it. (A queued re-seal implies a chain.)
+  // Late-worker re-seals still queued for the previous turn run first, in
+  // this same step — including one a worker queued while an earlier one ran —
+  // so the workers' edits stay in that turn's record and nothing the new turn
+  // writes can reach it. (A queued re-seal implies a chain.)
   const { token, tracker } = _changeMutations.has(ownerSessionId)
     ? await serializeChangeMutation(ownerSessionId, async () => {
         const previous = _diffTrackersBySession.get(ownerSessionId);
-        if (previous?.resealQueued) await runQueuedReseal(ownerSessionId, previous).catch(() => {});
+        while (previous?.resealQueued) await runQueuedReseal(ownerSessionId, previous).catch(() => {});
         return openTurnSnapshot(worktree, ownerSessionId, options);
       })
     : openTurnSnapshot(worktree, ownerSessionId, options);
@@ -701,6 +828,9 @@ export function beginAgentTurnReview(ownerSessionId, childSessionId, meta = {})
   if (DISABLED) return null;
   const owner = clean(ownerSessionId);
   const child = clean(childSessionId);
+  // Durable: the worker's edits join the Lead's session review even when it
+  // runs its own session turn, and whatever the turn's agent list keeps.
+  recordReviewOwner(child, owner);
   const turn = _turnsBySession.get(owner);
   if (!owner || !child || !turn) return null;
   const existingTracker = _diffTrackersBySession.get(child);
@@ -726,20 +856,29 @@ export function beginAgentTurnReview(ownerSessionId, childSessionId, meta = {})
   };
 }
 
-/** Freeze successful worker apply_patch diffs into their owning Lead turn. */
+/** Freeze successful worker apply_patch diffs into their owning Lead turn.
+ *  Everything a seal reads — the agent entry, the worker's owned paths and a
+ *  late re-seal — is published before this returns, so a seal started right
+ *  after it already includes the worker. */
 export function completeAgentTurnReview(handle, patches = []) {
   if (!handle || handle.completed === true) return false;
   handle.completed = true;
-  const turn = _turnsBySession.get(clean(handle.ownerSessionId));
+  const ownerSessionId = clean(handle.ownerSessionId);
   const key = clean(handle.sessionId) || handle.id;
+  const turn = _turnsBySession.get(ownerSessionId);
   const tracker = _diffTrackersBySession.get(key);
   const matchingTracker =
-    tracker && tracker.ownerSessionId === clean(handle.ownerSessionId) && tracker.ownerGeneration === handle.generation;
+    tracker && tracker.ownerSessionId === ownerSessionId && tracker.ownerGeneration === handle.generation;
+  // A worker that runs its own session turn replaces the bound tracker with
+  // its turn's own one (no owner). beginAgentTurnReview reset any older
+  // tracker, so an unowned one here holds this execution's edits.
+  const source = matchingTracker || (tracker && !tracker.ownerSessionId) ? tracker : null;
+  const ownerTracker = _diffTrackersBySession.get(ownerSessionId);
   try {
     if (!turn || turn.generation !== handle.generation) return false;
     const prior = turn.agents.get(key);
-    const tracked = matchingTracker && tracker.revision > 0;
-    const patch = tracked ? tracker.unifiedDiff : mergePatches(patches);
+    const tracked = Boolean(source) && source.revision > 0;
+    const patch = tracked ? trackerView(source).patch : mergePatches(patches);
     if (!patch) {
       if (tracked && prior) {
         turn.agents.delete(key);
@@ -754,15 +893,17 @@ export function completeAgentTurnReview(handle, patches = []) {
       tag: handle.tag || prior?.tag || null,
       patch: tracked ? patch : mergePatches([prior?.patch, patch]),
     });
-    const ownerTracker = _diffTrackersBySession.get(clean(handle.ownerSessionId));
-    if (matchingTracker && ownerTracker && ownerTracker !== tracker) {
-      for (const path of tracker.ownedPaths) ownerTracker.ownedPaths.add(path);
+    if (source && ownerTracker && ownerTracker !== source) {
+      for (const path of source.ownedPaths) ownerTracker.ownedPaths.add(path);
+      mergeOwnStats(ownerTracker.ownStats, source.ownStats);
+      mergeTrackedContent(ownerTracker, source);
     }
     trimAgentReviews(turn);
-    // A worker that finishes after its Lead turn sealed re-seals that turn's
-    // change record (its edits are part of the turn's net worktree diff).
+    // A worker that finishes after its Lead turn sealed (or while it seals)
+    // re-seals that turn's change record (its edits are part of the turn's net
+    // worktree diff).
     if (ownerTracker && ownerTracker !== tracker && ownerTracker.ownerGeneration === handle.generation) {
-      resealTurn(clean(handle.ownerSessionId), ownerTracker);
+      resealTurn(ownerSessionId, ownerTracker);
     }
     return true;
   } finally {
@@ -780,8 +921,8 @@ export function completeAgentTurnReview(handle, patches = []) {
  *  are precisely the attribution that contention destroys. */
 async function persistTurnSnapshotRecord(ownerSessionId, tracker) {
   const snapshot = tracker?.worktreeSnapshot;
-  if (!ownerSessionId || !snapshot?.baselineTree || !snapshot.root) return;
-  const owned = [...sessionAttributedPaths(snapshot.root, tracker)];
+  if (!ownerSessionId || tracker.discarded || !snapshot?.baselineTree || !snapshot.root) return;
+  const owned = [...ownedPathsUnder(snapshot.root, tracker.ownedPaths)];
   if (owned.length === 0) return;
   try {
     await saveTurnSnapshotRecord(ownerSessionId, {
@@ -810,10 +951,11 @@ function attributedAgents(ownerSessionId, tracker) {
   }));
 }
 
-/** Path of a tracked entry relative to `root`, or '' outside it. */
+/** Path of a tracked entry relative to `root`, or '' outside it (or without
+ *  a root). */
 function trackedRelativePath(root, entry) {
   const value = clean(entry?.path) || clean(entry?.displayPath);
-  if (!value) return '';
+  if (!root || !value) return '';
   const rel = relative(root, isAbsolute(value) ? resolve(value) : resolve(root, value));
   if (!rel || isAbsolute(rel) || rel.split(/[\\/]+/).includes('..')) return '';
   return rel.replace(/\\/g, '/');
@@ -821,42 +963,79 @@ function trackedRelativePath(root, entry) {
 
 /** A record file for an edit the worktree root cannot replay: outside it, or
  *  too large/binary to capture. Display-only (`viewPatch`), never undone. */
-function untrackableRecordFile(pair, { before, after, oldPath, newPath, omitted }) {
-  let status = 'M';
-  if (before === null) status = 'A';
-  else if (after === null) status = 'D';
-  else if (oldPath !== newPath) status = 'R';
-  const shownPath =
-    (status === 'D' ? oldPath : newPath) || displayPath(pair.after?.displayPath || pair.before?.displayPath);
-  const named = omitted ? null : namedChangePatch({ before, after, oldName: shownPath, newName: shownPath });
+function untrackableRecordFile(edit, root, budget) {
+  const path = viewPath(root, edit.end);
+  const oldPath = viewPath(root, edit.start);
+  const named = edit.omitted
+    ? []
+    : edit.steps.map(({ before, after }) =>
+        namedChangePatch({ before: before.content, after: after.content, oldName: path, newName: path, budget })
+      );
+  const viewPatch = named.map((step) => step.patch).join('');
   return {
-    path: shownPath,
-    ...(status === 'R' && oldPath ? { oldPath } : {}),
-    status,
-    additions: named?.additions || 0,
-    deletions: named?.deletions || 0,
-    ...(named?.patch ? { viewPatch: named.patch } : {}),
-    ...(omitted ? { binary: true } : {}),
+    path,
+    ...(oldPath !== path ? { oldPath } : {}),
+    status: edit.status,
+    additions: named.reduce((sum, step) => sum + step.additions, 0),
+    deletions: named.reduce((sum, step) => sum + step.deletions, 0),
+    ...(viewPatch ? { viewPatch } : {}),
+    ...(edit.omitted ? { binary: true } : {}),
     revertable: false,
-    reason: omitted ? 'binary/large file content was not captured' : 'file is outside the recorded root',
+    reason: edit.omitted ? 'binary/large file content was not captured' : 'file is outside the recorded root',
+  };
+}
+
+/** The root a tracker's own patches are relative to, and a getter for the
+ *  object format `git apply` hashes their binary content with there (one Git
+ *  call, made only when asked). */
+function trackerPatchRoot(tracker, fallback = '') {
+  const git = Boolean(clean(tracker?.worktreeSnapshot?.root));
+  const root = git ? tracker.worktreeSnapshot.root : clean(tracker?.worktreeRoot) || clean(fallback);
+  let format = null;
+  const objectFormat = () => {
+    format ||= git ? repositoryObjectFormat(root) : Promise.resolve('sha1');
+    return format;
+  };
+  return { root: root ? resolve(root) : '', kind: git ? 'git' : 'tracked', objectFormat };
+}
+
+/** One chain's edit (chainEdit) as a record file: one replayable patch
+ *  section per own segment, oldest first, or a view-only entry when it lies
+ *  outside the root or its bytes were never captured. `objectFormat` hashes a
+ *  binary patch, `budget` bounds the line diff. */
+function editChangeFile(edit, root, objectFormat, budget) {
+  if (edit.omitted || !edit.inside) return untrackableRecordFile(edit, root, budget);
+  const sections = edit.steps.map(({ before, after, oldPath, newPath }) =>
+    trackedChangeFile({ oldPath, newPath, before: before.content, after: after.content, objectFormat, budget })
+  );
+  if (sections.length === 1) return sections[0];
+  const path = trackedRelativePath(root, edit.end);
+  const oldPath = trackedRelativePath(root, edit.start);
+  const base = {
+    path,
+    ...(oldPath !== path ? { oldPath } : {}),
+    status: edit.status,
+    additions: sections.reduce((sum, section) => sum + section.additions, 0),
+    deletions: sections.reduce((sum, section) => sum + section.deletions, 0),
   };
+  const blocked = sections.find((section) => section.revertable !== true);
+  if (blocked) return { ...base, revertable: false, reason: blocked.reason };
+  return { ...base, revertable: true, patch: Buffer.concat(sections.map((section) => section.patch)) };
 }
 
-/** The exact before/after pair of a tracked entry, or null when it changed nothing. */
-function recordedPair(pair, root) {
-  const before = pair.before?.content ?? null;
-  const after = pair.after?.content ?? null;
-  if (before === null && after === null) return null;
-  const oldPath = trackedRelativePath(root, pair.before || pair.after);
-  const newPath = trackedRelativePath(root, pair.after || pair.before);
-  if (oldPath === newPath && sameContent(before, after)) return null;
-  return { before, after, oldPath, newPath, omitted: [before, after].some(isOmittedContent) };
+/** The object format the binary patches of `edits` hash with: resolved (one
+ *  Git call) only when one of them replays binary content. */
+async function editsObjectFormat(edits, patchRoot) {
+  const binary = edits.some((edit) => edit.binary && edit.inside && !edit.omitted);
+  return binary ? await patchRoot.objectFormat() : 'sha1';
 }
 
-/** Record files of a non-Git turn, from the exact apply_patch buffers. */
-function trackedRecordFiles(tracker, root) {
+/** Record files of the tracker's own changes. `outside` are those beyond the
+ *  root (view-only beside a Git turn's files). */
+async function ownRecordFiles(tracker, patchRoot) {
+  const { root } = patchRoot;
   if (!tracker.valid) {
-    return [...ownedPathsUnder(root, tracker.ownedPaths)].map((path) => ({
+    const files = [...ownedPathsUnder(root, tracker.ownedPaths)].map((path) => ({
       path,
       status: 'M',
       additions: 0,
@@ -864,63 +1043,41 @@ function trackedRecordFiles(tracker, root) {
       revertable: false,
       reason: 'file content exceeded the undo tracking limit',
     }));
+    return { files, outside: [] };
   }
+  const edits = [...tracker.chains.values()].map((chain) => chainEdit(chain, root)).filter(Boolean);
+  const objectFormat = await editsObjectFormat(edits, patchRoot);
+  // One line-diff budget for the whole seal pass.
+  const budget = createLineDiffBudget();
   const files = [];
-  for (const pair of trackedPairs(tracker)) {
-    const edit = recordedPair(pair, root);
-    if (!edit) continue;
-    if (edit.omitted || !edit.oldPath || !edit.newPath) {
-      files.push(untrackableRecordFile(pair, edit));
-      continue;
-    }
-    files.push(
-      trackedChangeFile({ oldPath: edit.oldPath, newPath: edit.newPath, before: edit.before, after: edit.after })
-    );
-  }
-  return files;
+  const outside = [];
+  for (const edit of edits) (edit.inside ? files : outside).push(editChangeFile(edit, root, objectFormat, budget));
+  return { files, outside };
 }
 
-/** Edits of a Git turn that lie outside its worktree root: the baseline diff
- *  never sees them, so they are recorded view-only beside the Git files. */
-function outsideRecordFiles(tracker, root) {
-  if (!tracker.valid) return [];
-  const files = [];
-  for (const pair of trackedPairs(tracker)) {
-    const edit = recordedPair(pair, root);
-    if (edit && (!edit.oldPath || !edit.newPath)) {
-      files.push(untrackableRecordFile(pair, edit));
-    }
-  }
-  return files;
-}
-
-/** Freeze the turn's net diff into its durable change record. A Git turn
- *  records the baseline→end worktree diff (workers' edits included, scoped to
- *  session-owned paths when the worktree is shared); a non-Git turn records
- *  the Lead's exact apply_patch pairs. */
+/** Freeze the turn's own changes into its durable change record: per file,
+ *  the session's own segments (its completed workers' included) as one
+ *  replayable patch, never the worktree's net diff, counted by the summed
+ *  deltas of those writes (`counts: 'own'`; older records without the marker
+ *  carry net worktree patches and counts). */
 async function freezeTurnChanges(ownerSessionId, tracker, agents) {
   const checkpointId = clean(tracker.checkpointId);
   if (!checkpointId) return null;
-  let frozen = null;
-  if (tracker.worktreeSnapshot) {
-    const scope = worktreeSnapshotUsable(tracker)
-      ? null
-      : [...ownedPathsUnder(tracker.worktreeSnapshot.root, tracker.ownedPaths)];
-    const result = await freezeTurnWorktreeChanges(tracker.worktreeSnapshot, scope);
-    if (result) {
-      frozen = { kind: 'git', ...result, outside: outsideRecordFiles(tracker, tracker.worktreeSnapshot.root) };
-    }
-  } else if (tracker.worktreeRoot) {
-    frozen = { kind: 'tracked', root: tracker.worktreeRoot, files: trackedRecordFiles(tracker, tracker.worktreeRoot) };
-  }
-  if (!frozen) return null;
+  const patchRoot = trackerPatchRoot(tracker);
+  if (!patchRoot.root) return null;
+  const { files, outside } = await ownRecordFiles(tracker, patchRoot);
+  const git = patchRoot.kind === 'git';
+  const counted = ownCountIndex(tracker, patchRoot.root);
   const record = await upsertTurnChangeRecord(ownerSessionId, {
     checkpointId,
-    kind: frozen.kind,
-    root: frozen.root,
+    kind: patchRoot.kind,
+    root: patchRoot.root,
     agents,
-    files: frozen.files.map(storedChangeFile),
-    outside: (frozen.outside || []).map(storedChangeFile),
+    counts: 'own',
+    // A non-Git turn has no view-only side list: an edit it cannot replay
+    // blocks its Undo like before.
+    files: withOwnCounts(git ? files : [...files, ...outside], counted).map(storedChangeFile),
+    outside: git ? withOwnCounts(outside, counted).map(storedChangeFile) : [],
   });
   // A fresh freeze measured the disk itself; nothing about it is unknown.
   _unknownChangeStates.delete(pendingFreezeKey(ownerSessionId, checkpointId));
@@ -934,11 +1091,14 @@ const pendingFreezeKey = (ownerSessionId, checkpointId) => `${ownerSessionId}\0$
  * baseline and freeze the change record. Single-flight per tracker; a seal
  * requested while another runs waits for it and then seals again only if a
  * completion wake reopened the turn meanwhile. `reseal` (a late worker) only
- * re-freezes a turn that is still sealed.
+ * re-freezes a turn that is still sealed, after any seal in flight: that one
+ * captured its agents before the worker was attributed.
  */
 function sealTurn(ownerSessionId, tracker, { reseal = false } = {}) {
+  // Its history was deleted (clearSessionChangeHistory): never written again.
+  if (tracker.discarded) return Promise.resolve();
   if (tracker.freezing) {
-    if (reseal) return tracker.freezing;
+    if (reseal) return tracker.freezing.then(() => sealTurn(ownerSessionId, tracker, { reseal: true }));
     return tracker.freezing.then(() => (tracker.sealed ? undefined : sealTurn(ownerSessionId, tracker)));
   }
   const epoch = tracker.sealEpoch;
@@ -953,19 +1113,18 @@ function sealTurn(ownerSessionId, tracker, { reseal = false } = {}) {
         // Best-effort refresh: seal with the last captured worktree state.
       }
     }
-    if (tracker.sealEpoch !== epoch || (reseal && !tracker.sealed)) return;
+    if (tracker.discarded || tracker.sealEpoch !== epoch || (reseal && !tracker.sealed)) return;
+    // A re-seal never rewrites a turn once the next one opened.
+    if (reseal && turnSuperseded(ownerSessionId, tracker)) return;
     tracker.sealed = true;
     await persistTurnSnapshotRecord(ownerSessionId, tracker);
     try {
-      await freezeTurnChanges(ownerSessionId, tracker, agents);
+      if (!tracker.discarded) await freezeTurnChanges(ownerSessionId, tracker, agents);
     } catch {
       /* the change record adds Undo history; it never fails a turn */
     }
-    // Only a usable Git baseline can replace the exact apply_patch buffers. A
-    // contended worktree — and a worktree with no Git baseline at all — retains
-    // this session's bounded before/after content so Review can still undo its
-    // own files after the turn completes.
-    if (worktreeSnapshotUsable(tracker)) releaseDiffTrackerContent(tracker);
+    // The bounded own before/after content stays until the next turn: a late
+    // worker's re-seal and an Undo/Reapply of this turn fold into it.
   })().finally(() => {
     if (tracker.freezing === run) tracker.freezing = null;
     const count = (_pendingFreezes.get(key) || 1) - 1;
@@ -977,7 +1136,9 @@ function sealTurn(ownerSessionId, tracker, { reseal = false } = {}) {
 }
 
 function resealTurn(ownerSessionId, tracker) {
-  if (!tracker.sealed || tracker.freezing || !clean(tracker.checkpointId) || tracker.resealQueued) return;
+  // A turn still running seals with every published agent; one sealed or
+  // sealing queues its re-seal (sealTurn runs it after a seal in flight).
+  if (!(tracker.sealed || tracker.freezing) || !clean(tracker.checkpointId) || tracker.resealQueued) return;
   // On the session lock: an in-flight Undo/Reapply lands before the re-freeze
   // reads the worktree. A turn start queued ahead of it runs it before opening
   // (beginTurnSnapshot), so one queued re-seal covers every late worker.
@@ -985,10 +1146,17 @@ function resealTurn(ownerSessionId, tracker) {
   void serializeChangeMutation(ownerSessionId, () => runQueuedReseal(ownerSessionId, tracker)).catch(() => {});
 }
 
+/** True once a newer turn of the session opened over `tracker`'s. */
+function turnSuperseded(ownerSessionId, tracker) {
+  const turn = _turnsBySession.get(ownerSessionId);
+  return Boolean(turn) && turn.generation !== tracker.ownerGeneration;
+}
+
 /** Run `tracker`'s queued re-seal once, whichever lock step reaches it first. */
 function runQueuedReseal(ownerSessionId, tracker) {
   if (!tracker.resealQueued) return undefined;
   tracker.resealQueued = false;
+  if (turnSuperseded(ownerSessionId, tracker)) return undefined;
   return sealTurn(ownerSessionId, tracker, { reseal: true });
 }
 
@@ -1005,71 +1173,126 @@ export async function completeTurnSnapshot(sessionId, expected = null) {
   return true;
 }
 
-/**
- * Can this turn's Git baseline own the review and its revert? A contended
- * worktree cannot attribute concurrent mutations to one session, and a
- * non-Git worktree never had a baseline to begin with. In both cases the
- * exact apply_patch buffers are the only safe revert source.
- */
+/** Is this turn's review labelled with its uncontended Git baseline? (The
+ *  review itself is always the tracker's own segments.) */
 function worktreeSnapshotUsable(tracker) {
   return Boolean(tracker && !tracker.worktreeContended && tracker.worktreeSnapshot);
 }
 
-/** Match a user-supplied file against a recorded session-owned path. */
-function recordedPathMatchesFile(owned, root, file) {
-  const target = clean(file);
-  if (!target) return false;
-  const normalizedRoot = pathKey(root);
-  const normalizedTarget = pathKey(target);
-  const relativeTarget =
-    normalizedRoot && normalizedTarget.startsWith(`${normalizedRoot}/`)
-      ? normalizedTarget.slice(normalizedRoot.length + 1)
-      : normalizedTarget;
-  const normalizedOwned = pathKey(owned);
-  return normalizedOwned === relativeTarget || normalizedOwned === normalizedTarget;
-}
-
-/** Re-open the recorded baseline for a session whose tracker is gone. Returns
- *  null when the record is missing or its tree object has been collected. */
-async function resumeRecordedSnapshot(ownerSessionId, { omitPatch = false } = {}) {
-  if (!ownerSessionId) return null;
-  let record = null;
-  try {
-    record = await loadTurnSnapshotRecord(ownerSessionId);
-  } catch {
-    return null;
-  }
+/** The latest turn's review once its tracker is gone (the next turn replaced
+ *  it, the cache evicted it, the runtime restarted): its change record's
+ *  files still applied, with their own counts and recorded patches — never a
+ *  worktree diff, so a foreign edit inside an own file stays out. */
+async function recordedTurnReview(ownerSessionId, { omitPatch }) {
+  const record = await latestTurnRecord(ownerSessionId);
   if (!record) return null;
-  const snapshot = await resumeTurnWorktreeSnapshot(record.root, record.baselineTree, {
-    paths: record.toolFiles,
-    baselineFiles: record.baselineFiles,
-    omitPatch,
-  }).catch(() => null);
-  if (!snapshot) return null;
-  return { record, snapshot };
-}
-
-/** A review rebuilt from the durable record. Same shape as the live one, but
- *  scoped to the recording session's own paths so a worktree shared with other
- *  sessions stays attributable instead of losing its revert entirely. */
-async function scopedReviewFromRecord(ownerSessionId, { omitPatch = false } = {}) {
-  const resumed = await resumeRecordedSnapshot(ownerSessionId, { omitPatch });
-  if (!resumed) return null;
+  const files = (record.files || []).filter((file) => fileState(file) === 'applied');
+  const patches = files.map(changeDisplayPatch);
+  const rows = files.map((file, index) => {
+    const row = {
+      path: file.path,
+      ...(file.oldPath ? { oldPath: file.oldPath } : {}),
+      status: file.status,
+      additions: Number(file.additions) || 0,
+      deletions: Number(file.deletions) || 0,
+      ...(file.binary ? { binary: true } : {}),
+    };
+    // The record dropped its patch for size: still listed too large.
+    return recordPatchOmitted(file, patches[index]) ? patchOmittedFile(row) : row;
+  });
+  const shaped = omitPatch ? { files: rows, patch: '' } : perFileReview(rows, patches.join(''));
   return {
     supported: true,
-    files: resumed.snapshot.files || [],
-    patch: resumed.snapshot.patch || '',
-    ...(resumed.snapshot.patchOmitted ? { patchOmitted: true } : {}),
+    files: shaped.files,
+    patch: shaped.patch,
+    ...(omitPatch ? { patchOmitted: true } : {}),
+    ...(shaped.diffTooLarge ? { diffTooLarge: true } : {}),
     snapshotKind: 'scoped',
     revertMode: 'scoped',
-    checkpointId: clean(resumed.record.checkpointId),
-    patchTruncated: resumed.snapshot.patchTruncated === true,
+    checkpointId: clean(record.checkpointId),
+    patchTruncated: false,
     authoritative: true,
     agents: publicAgentReviews(ownerSessionId),
     reason: 'recorded',
   };
 }
 
+/** A record file kept without its patch for size. */
+const recordPatchOmitted = (file, patch) => file?.patchOmitted === true && !patch;
+
+/** A review reply's files and patch under the per-file caps: a file whose
+ *  sections were cut for display, or pass the per-file cap or the total left,
+ *  is listed with its counts but without its patch (read on its own when it
+ *  is opened). `diffTooLarge` once nothing fit. */
+function perFileReview(files, patch) {
+  const sections = new Map();
+  for (const section of splitPatchSections(Buffer.from(patch || '', 'utf8'))) {
+    const key = pathKey(section.newPath ?? section.oldPath ?? '');
+    const entry = sections.get(key) || { parts: [], bytes: 0, cut: false };
+    entry.parts.push(section.patch);
+    entry.bytes += section.patch.length;
+    entry.cut ||= reviewSectionTruncated(section.patch);
+    sections.set(key, entry);
+  }
+  const budget = createReviewPatchBudget();
+  const omitted = new Set();
+  const kept = [];
+  for (const [key, entry] of sections) {
+    if (!entry.cut && budget.admit(entry.bytes)) kept.push(...entry.parts);
+    else omitted.add(key);
+  }
+  const shaped = files.map((file) => (omitted.has(pathKey(file.path)) ? patchOmittedFile(file) : file));
+  const text = Buffer.concat(kept).toString('utf8');
+  return { files: shaped, patch: text, diffTooLarge: reviewDiffTooLarge(shaped, text) };
+}
+
+/** The latest turn's change record, its unrecordable file states applied. */
+async function latestTurnRecord(ownerSessionId) {
+  const checkpointId = await latestRecordedCheckpoint(ownerSessionId);
+  const stored = checkpointId ? await loadTurnChangeRecord(ownerSessionId, checkpointId).catch(() => null) : null;
+  return withUnknownChangeStates(ownerSessionId, stored);
+}
+
+/** One file's whole display patch in the tracker's view, rendered on its own
+ *  instead of within the reply's caps; '' when the view lists no such file. */
+function trackerFilePatch(tracker, path) {
+  const { root, kind } = trackerPatchRoot(tracker);
+  const key = pathKey(path);
+  const budget = createLineDiffBudget();
+  for (const chain of tracker.chains.values()) {
+    const edit = chainEdit(chain, root);
+    if (!edit || (kind === 'git' && !edit.inside) || pathKey(viewPath(root, edit.end)) !== key) continue;
+    return edit.steps.map((step) => renderStep(step, root, budget).text).join('');
+  }
+  return '';
+}
+
+/** One file of the latest turn's review with its whole patch, up to the
+ *  file-patch read's cap: the file a reply listed `patchOmitted`. */
+export async function getTurnReviewFilePatch(_worktree, sessionId, file) {
+  const path = clean(file).replace(/\\/g, '/');
+  if (DISABLED) return { supported: false, path, patch: '' };
+  const ownerSessionId = clean(sessionId);
+  if (!ownerSessionId || !path) return { supported: true, path, patch: '' };
+  const tracker = _diffTrackersBySession.get(ownerSessionId);
+  if (tracker) return filePatchReply(path, trackerFilePatch(tracker, path));
+  // Only a file the recorded review lists, by its own path.
+  const record = await latestTurnRecord(ownerSessionId);
+  const match = record ? findChangeFile(record, path) : null;
+  if (!match || fileState(match) !== 'applied' || changePathKey(match.path) !== changePathKey(relativeRecordPath(record, path))) {
+    return filePatchReply(path, '');
+  }
+  const patch = changeDisplayPatch(match);
+  if (recordPatchOmitted(match, patch)) return { ...filePatchReply(path, ''), ...patchOmittedFile({}) };
+  return filePatchReply(path, patch);
+}
+
+/** `value` as findChangeFile reads it: relative to the record's root. */
+function relativeRecordPath(record, value) {
+  const target = clean(value).replace(/\\/g, '/');
+  return isAbsolute(target) && record?.root ? relative(record.root, resolve(target)).replace(/\\/g, '/') : target;
+}
+
 function assertCheckpointMatches(expectedCheckpointId, actualCheckpointId) {
   const expected = clean(expectedCheckpointId);
   if (!expected) return;
@@ -1080,63 +1303,38 @@ function assertCheckpointMatches(expectedCheckpointId, actualCheckpointId) {
   }
 }
 
-/** Restore recorded paths — every one of them, or just the file the user picked. */
-async function revertFromRecord(ownerSessionId, file, expectedCheckpointId) {
-  const resumed = await resumeRecordedSnapshot(ownerSessionId);
-  if (!resumed) return null;
-  assertCheckpointMatches(expectedCheckpointId, resumed.record.checkpointId);
-  const owned = resumed.record.toolFiles;
-  const targets = file ? owned.filter((path) => recordedPathMatchesFile(path, resumed.record.root, file)) : owned;
-  if (targets.length === 0) {
-    throw new Error('turn review revert cannot attribute this file to the session');
-  }
-  const paths = await revertTurnWorktreePaths(resumed.snapshot, targets);
-  return { checkpointId: clean(resumed.record.checkpointId), paths };
-}
-
-/** Return the authoritative Lead net diff plus attributed child reviews. */
+/** Return the Lead turn's own-file diff plus attributed child reviews, and
+ *  `historyTurns`: the retained turn records clearSessionChangeHistory deletes. */
 export async function getTurnReviewDiff(_worktree, sessionId, options = {}) {
-  if (DISABLED) return { supported: false, files: [], patch: '', agents: [] };
+  if (DISABLED) return { supported: false, files: [], patch: '', agents: [], historyTurns: 0 };
   const ownerSessionId = clean(sessionId);
+  const review = await readTurnReview(ownerSessionId, options);
+  const records = await loadTurnChangeRecords(ownerSessionId).catch(() => []);
+  return { ...review, historyTurns: records.length };
+}
+
+async function readTurnReview(ownerSessionId, options) {
   const turn = _turnsBySession.get(ownerSessionId);
   const tracker = _diffTrackersBySession.get(ownerSessionId);
-  const isolatedWorktreeSnapshot = worktreeSnapshotUsable(tracker) ? tracker.worktreeSnapshot : null;
-  if (isolatedWorktreeSnapshot && !tracker.sealed && options.refresh !== false) {
-    // Only the review bar's interval timer sends `poll: 'background'`; an
-    // open review (asking for its patch, no `summary`) keeps a short gap.
-    // Every other read (opening the review, a manual or tool-boundary
-    // refresh, a client that sends no `poll`) captures the worktree now.
-    const refreshOptions = options.poll === 'background' ? { visible: options.summary !== true } : { force: true };
-    try {
-      await refreshTurnWorktreeSnapshot(isolatedWorktreeSnapshot, refreshOptions);
-    } catch {
-      // Best-effort refresh: the review reads the last captured state.
-    }
-  }
-  const snapshot = isolatedWorktreeSnapshot;
-  // Without a usable baseline the review falls back to this session's own
-  // mutations — including a worktree that has no Git repository at all, which
-  // used to leave the bar with no revert mode whatsoever.
-  const trackedRevertAvailable = !snapshot && tracker?.valid === true && trackedPairs(tracker).length > 0;
-  if (!snapshot && !trackedRevertAvailable) {
-    // Both in-memory sources are gone: the next turn replaced the tracker, the
-    // turn cache evicted it, or the runtime restarted. The recorded baseline is
-    // still on disk and still exact. Rebuilt per read and then discarded, so a
-    // summary read skips its patch text instead of dropping it afterwards.
-    const recorded = await scopedReviewFromRecord(ownerSessionId, { omitPatch: options.summary === true });
+  if (!tracker) {
+    const recorded = await recordedTurnReview(ownerSessionId, { omitPatch: options.summary === true });
     if (recorded) return recorded;
   }
+  const view = tracker ? trackerView(tracker) : null;
+  const worktree = worktreeSnapshotUsable(tracker);
   let revertMode = '';
-  if (snapshot) revertMode = 'worktree';
-  else if (trackedRevertAvailable) revertMode = 'tracked';
+  if (worktree) revertMode = 'worktree';
+  else if (tracker?.valid && view.files.length) revertMode = 'tracked';
+  const shaped = perFileReview(view?.files || [], view?.patch || '');
   return {
     supported: true,
-    files: snapshot?.files || [],
-    patch: snapshot?.patch ?? tracker?.unifiedDiff ?? '',
-    snapshotKind: snapshot ? 'worktree' : 'tool',
+    files: shaped.files,
+    patch: shaped.patch,
+    ...(shaped.diffTooLarge ? { diffTooLarge: true } : {}),
+    snapshotKind: worktree ? 'worktree' : 'tool',
     revertMode,
     checkpointId: clean(turn?.checkpointId || tracker?.checkpointId),
-    patchTruncated: (snapshot || tracker)?.patchTruncated === true,
+    patchTruncated: false,
     authoritative: Boolean(turn && tracker),
     agents: publicAgentReviews(ownerSessionId),
     ...(turn ? { generation: turn.generation } : { reason: 'no-turn' }),
@@ -1152,51 +1350,101 @@ function scopeMatchesWorktree(scope, worktree, tracker) {
   return requested === root || requested.startsWith(`${root}${process.platform === 'win32' ? '\\' : '/'}`);
 }
 
-/** Return the net diff from this session's earliest retained baseline to the
- * current worktree, scoped only to paths its own tools changed. Unlike
- * getTurnReviewDiff this survives user-turn boundaries and has no revert
- * contract; the composer keeps owning latest-turn Undo. */
+/** Return the session's net change: inside a Git root, the diff from its
+ * earliest retained baseline tree to the worktree, scoped to the paths it
+ * changed; everywhere else (a non-Git root, files outside the Git root) each
+ * file's FIRST state observed in the session — by the Lead or a worker
+ * attributed to it — against the disk now. Unlike getTurnReviewDiff this
+ * survives user-turn boundaries and has no revert contract; the composer
+ * keeps owning latest-turn Undo. */
 export async function getSessionReviewDiff(worktree, sessionId) {
   if (DISABLED) return { supported: false, files: [], patch: '' };
   const ownerSessionId = clean(sessionId);
   if (!ownerSessionId) return { supported: true, files: [], patch: '', authoritative: true };
-  const review = await baselineSessionReviewDiff(worktree, ownerSessionId);
-  // The same recorded changes the turn-changes cards list: a non-Git session
-  // and files outside the worktree have no baseline above, but do have these.
-  // A Git session whose baseline vouches for its files has nothing to add but
-  // edits outside the root, so its records are read only through the
-  // mtime-keyed cache.
-  const records = await loadTurnChangeRecords(ownerSessionId).catch(() => []);
-  const live = review.source === 'git' ? null : liveTrackedRecord(_diffTrackersBySession.get(ownerSessionId));
-  return mergeRecordedSessionChanges(review, records, live);
+  const [review, baselines, records] = await Promise.all([
+    baselineSessionReviewDiff(worktree, ownerSessionId),
+    loadSessionBaselines(ownerSessionId).catch(() => null),
+    // Read through the mtime-keyed cache: only files no baseline knows (a
+    // session recorded before baselines existed) come from them.
+    loadTurnChangeRecords(ownerSessionId).catch(() => []),
+  ]);
+  return await sessionChangeReview(review, { baselines, records });
+}
+
+/** What the session review diffs inside a Git root: the stored scope (or
+ *  live tracker) of this worktree, the paths the session owns there, and its
+ *  earliest baseline tree with the recorded first states that complete it. */
+async function sessionReviewScope(worktree, ownerSessionId) {
+  const tracker = _diffTrackersBySession.get(ownerSessionId);
+  const scopes = await loadSessionSnapshotRecords(ownerSessionId).catch(() => []);
+  const stored = scopes.find((scope) => scopeMatchesWorktree(scope, worktree, tracker));
+  const root = stored?.root || tracker?.worktreeSnapshot?.root || clean(worktree);
+  const ownedPaths = new Set(stored?.toolFiles || []);
+  for (const path of ownedPathsUnder(root, tracker?.ownedPaths)) ownedPaths.add(path);
+  const baselineTree = stored?.baselineTree || tracker?.worktreeSnapshot?.baselineTree;
+  const baselineFiles = new Map((stored?.baselineFiles || []).map((entry) => [pathKey(entry.path), entry]));
+  const storedPaths = new Set((stored?.toolFiles || []).map(pathKey));
+  for (const entry of tracker?.worktreeSnapshot?.baselineFiles.values() || []) {
+    if (!storedPaths.has(pathKey(entry.path))) baselineFiles.set(pathKey(entry.path), entry);
+  }
+  return { tracker, stored, root, ownedPaths, baselineTree, baselineFiles: [...baselineFiles.values()] };
 }
 
-const LIVE_RECORD_TTL_MS = 1000;
-const _liveRecords = new WeakMap();
+/** `value` (absolute, or relative to `root`) as a path relative to `root`;
+ *  null outside it. */
+function relativeInside(root, value) {
+  const target = clean(value);
+  if (!root || !target) return null;
+  const rel = relative(resolve(root), isAbsolute(target) ? resolve(target) : resolve(root, target));
+  if (!rel || isAbsolute(rel) || rel.split(/[\\/]+/).includes('..')) return null;
+  return rel.replace(/\\/g, '/');
+}
 
-/** The running non-Git turn as a record, so its edits join the net review
- *  before the turn seals. Rebuilt at most once a second. */
-function liveTrackedRecord(tracker) {
-  if (!tracker || tracker.worktreeSnapshot || !tracker.worktreeRoot || !clean(tracker.checkpointId)) return null;
-  const cached = _liveRecords.get(tracker);
-  if (cached && Date.now() - cached.at < LIVE_RECORD_TTL_MS && cached.checkpointId === tracker.checkpointId) {
-    return cached.record;
+/** One file of the session review with its whole patch, up to the file-patch
+ *  read's cap: the file a reply listed `patchOmitted`. `file` is the listed
+ *  file's `id` or path, `oldPath` a rename's source. Inside the Git root it is
+ *  the session's baseline tree against the worktree now for that path alone;
+ *  elsewhere its first-seen state measured against the disk now. */
+export async function getSessionReviewFilePatch(worktree, sessionId, file, oldPath = '') {
+  const path = clean(file).replace(/\\/g, '/');
+  if (DISABLED) return { supported: false, path, patch: '' };
+  const ownerSessionId = clean(sessionId);
+  if (!ownerSessionId || !path) return { supported: true, path, patch: '' };
+  const scope = await sessionReviewScope(worktree, ownerSessionId);
+  const rel = scope.baselineTree ? relativeInside(scope.root, path) : null;
+  if (rel !== null) {
+    // Each target is authorized on its own: an unowned file is never read,
+    // an unowned rename source never joins its diff.
+    const owned = new Set([...scope.ownedPaths].map(pathKey));
+    if (!owned.has(pathKey(rel))) return { supported: true, path, patch: '' };
+    const source = relativeInside(scope.root, oldPath) || '';
+    const oldRel = source && owned.has(pathKey(source)) ? source : '';
+    const result = await resumeTurnWorktreeFilePatch(scope.root, scope.baselineTree, {
+      paths: [...scope.ownedPaths],
+      baselineFiles: scope.baselineFiles,
+      path: rel,
+      oldPath: oldRel,
+      maxBytes: REVIEW_FILE_PATCH_SHOW_MAX_BYTES,
+    }).catch(() => null);
+    if (result) return { supported: true, path, ...result };
   }
-  const record = {
-    checkpointId: clean(tracker.checkpointId),
-    kind: 'tracked',
-    root: tracker.worktreeRoot,
-    files: trackedRecordFiles(tracker, tracker.worktreeRoot).map(storedChangeFile),
-  };
-  _liveRecords.set(tracker, { at: Date.now(), checkpointId: record.checkpointId, record });
-  return record;
+  const [base, baselines, records] = await Promise.all([
+    // Beside a Git baseline a file outside its root is measured from its
+    // first state; the Git side's own files need no diff for that.
+    rel === null && scope.baselineTree && scope.root
+      ? { supported: true, root: scope.root, files: [], patch: '', source: 'git' }
+      : baselineSessionReviewDiff(worktree, ownerSessionId),
+    loadSessionBaselines(ownerSessionId).catch(() => null),
+    loadTurnChangeRecords(ownerSessionId).catch(() => []),
+  ]);
+  return await sessionChangeReview(base, { baselines, records, file: path });
 }
 
 async function baselineSessionReviewDiff(worktree, ownerSessionId) {
-  const tracker = _diffTrackersBySession.get(ownerSessionId);
-  const scopes = await loadSessionSnapshotRecords(ownerSessionId).catch(() => []);
-  const stored = scopes.find((scope) => scopeMatchesWorktree(scope, worktree, tracker));
-  const root = stored?.root || tracker?.worktreeSnapshot?.root || clean(worktree);
+  const { tracker, stored, root, ownedPaths, baselineTree, baselineFiles } = await sessionReviewScope(
+    worktree,
+    ownerSessionId
+  );
   // A running turn is still mutating the worktree: shell, office and script
   // edits only reach the checkpoint diff once it is refreshed, exactly as the
   // turn review bar does.
@@ -1207,12 +1455,11 @@ async function baselineSessionReviewDiff(worktree, ownerSessionId) {
       // Best-effort refresh: the checkpoint diff uses the last captured state.
     }
   }
-  const ownedPaths = new Set(stored?.toolFiles || []);
-  for (const path of sessionAttributedPaths(root, tracker)) ownedPaths.add(path);
   if (ownedPaths.size === 0) {
     // Authoritatively empty only when the session left ownership metadata
-    // behind (a stored scope or a live tracker); with neither, the retained
-    // change records are the only memory of what it changed.
+    // behind (a stored scope, a live tracker, or a deleted history); with
+    // none, the retained change records are the only memory of what it changed.
+    const known = Boolean(stored || tracker) || (await sessionChangeHistoryCleared(ownerSessionId).catch(() => false));
     return {
       supported: true,
       root,
@@ -1220,19 +1467,13 @@ async function baselineSessionReviewDiff(worktree, ownerSessionId) {
       patch: '',
       snapshotKind: 'session',
       authoritative: true,
-      source: stored || tracker ? 'empty' : 'absent',
+      source: known ? 'empty' : 'absent',
     };
   }
-  const baselineTree = stored?.baselineTree || tracker?.worktreeSnapshot?.baselineTree;
   if (root && baselineTree) {
-    const baselineFiles = new Map((stored?.baselineFiles || []).map((entry) => [pathKey(entry.path), entry]));
-    const storedPaths = new Set((stored?.toolFiles || []).map(pathKey));
-    for (const entry of tracker?.worktreeSnapshot?.baselineFiles.values() || []) {
-      if (!storedPaths.has(pathKey(entry.path))) baselineFiles.set(pathKey(entry.path), entry);
-    }
     const snapshot = await resumeTurnWorktreeSnapshot(root, baselineTree, {
       paths: [...ownedPaths],
-      baselineFiles: [...baselineFiles.values()],
+      baselineFiles,
     }).catch(() => null);
     if (snapshot) {
       return {
@@ -1250,74 +1491,131 @@ async function baselineSessionReviewDiff(worktree, ownerSessionId) {
   // A non-Git first turn still has an exact apply_patch tracker. It cannot
   // cross a runtime restart, but remains preferable to widening into unrelated
   // files from the surrounding directory.
+  // `owned` lets the session review flag an owned file no other source knows.
   if (tracker?.valid) {
     return {
       supported: true,
+      root,
       files: [],
-      patch: tracker.unifiedDiff || '',
-      patchTruncated: tracker.patchTruncated === true,
+      patch: '',
       snapshotKind: 'session-tool',
       authoritative: true,
       source: 'tool',
+      owned: [...ownedPaths],
     };
   }
   return {
     supported: false,
+    root,
     files: [],
     patch: '',
     snapshotKind: 'session',
     authoritative: false,
     reason: 'session baseline is unavailable',
     source: 'unavailable',
+    owned: [...ownedPaths],
   };
 }
 
-/** Why this turn cannot revert through its exact apply_patch buffers. */
-function unavailableTrackedRevertReason(tracker) {
-  return tracker.worktreeContended
-    ? 'turn review revert is unavailable while sessions share a worktree'
-    : 'turn review tracked file snapshot is unavailable';
-}
+const UNATTRIBUTED_FILE = 'turn review revert cannot attribute this file to the session';
 
-/** Restore the latest turn — every file it can attribute (`whole`) or the one
- *  the user picked — to its turn-start state. Resolves to the restored turn's
- *  checkpoint and the absolute paths actually restored: a contended worktree
- *  restores only the Lead's own tracked files, never its workers'. */
-async function revertLatestTurnUnlocked(worktree, ownerSessionId, file, whole, expectedCheckpointId) {
+/** Reverse-apply the latest turn's own changes — every file its own tools
+ *  wrote (`file` null) or the own file the user picked. A sealed turn undoes
+ *  its change record (state included); a running one its tracker's own
+ *  segments. Resolves to the turn's checkpoint, the absolute paths touched and
+ *  whether the record already carries the new state. */
+async function revertLatestTurnUnlocked(worktree, ownerSessionId, file, expectedCheckpointId) {
   const tracker = _diffTrackersBySession.get(ownerSessionId);
   if (tracker) assertCheckpointMatches(expectedCheckpointId, tracker.checkpointId);
-  const restored = (paths) => ({ checkpointId: clean(tracker.checkpointId), paths });
-  const recordFile = whole ? null : file;
-  if (tracker && !worktreeSnapshotUsable(tracker)) {
-    const pairs = trackedPairs(tracker);
-    if (pairs.length > 0) {
-      let selected = pairs;
-      if (!whole) {
-        const pair = pairs.find((entry) => pairMatchesFile(entry, worktree, file));
-        if (!pair) throw new Error('turn review tracked file snapshot is unavailable');
-        selected = [pair];
-      }
-      return restored(await revertTrackedPairs(tracker, worktree, selected));
-    }
-    const recorded = await revertFromRecord(ownerSessionId, recordFile, expectedCheckpointId);
-    if (recorded) return recorded;
-    throw new Error(unavailableTrackedRevertReason(tracker));
+  if (!tracker || tracker.sealed) {
+    const checkpointId = clean(tracker?.checkpointId) || (await latestRecordedCheckpoint(ownerSessionId));
+    if (!tracker) assertCheckpointMatches(expectedCheckpointId, checkpointId);
+    const record = checkpointId ? await loadTurnChangeRecord(ownerSessionId, checkpointId) : null;
+    if (record) return await revertRecordedTurn(ownerSessionId, withUnknownChangeStates(ownerSessionId, record), file);
+    if (!tracker) throw new Error('turn worktree snapshot is unavailable');
   }
-  if (tracker?.worktreeSnapshot) {
-    return restored(
-      whole
-        ? await revertTurnWorktreeSnapshot(tracker.worktreeSnapshot)
-        : await revertTurnWorktreeFile(tracker.worktreeSnapshot, file)
+  const paths = await revertTrackedTurn(tracker, worktree, file);
+  return { checkpointId: clean(tracker.checkpointId), paths, recorded: false };
+}
+
+/** The latest turn on record: the stored Git review's, else the newest change record's. */
+async function latestRecordedCheckpoint(ownerSessionId) {
+  const snapshot = await loadTurnSnapshotRecord(ownerSessionId).catch(() => null);
+  if (clean(snapshot?.checkpointId)) return clean(snapshot.checkpointId);
+  const records = await loadTurnChangeRecords(ownerSessionId).catch(() => []);
+  return clean(records.at(-1)?.checkpointId);
+}
+
+const recordFilePaths = (root, files) =>
+  files.flatMap((entry) => [entry.path, entry.oldPath]).filter(Boolean).map((path) => resolve(root, path));
+
+/** Undo a sealed turn's applied record files (all, or the one named). */
+async function revertRecordedTurn(ownerSessionId, record, file) {
+  let targets;
+  if (file) {
+    const match = findChangeFile(record, file);
+    if (!match) throw new Error(UNATTRIBUTED_FILE);
+    if (fileState(match) !== 'applied') throw new Error(`${match.path} is already undone`);
+    targets = [match];
+  } else {
+    targets = (record.files || []).filter((entry) => fileState(entry) === 'applied');
+  }
+  if (targets.length > 0) await mutateRecordFiles(ownerSessionId, record, targets, true);
+  return { checkpointId: clean(record.checkpointId), paths: recordFilePaths(record.root, targets), recorded: true };
+}
+
+/** Undo a running turn's own segments (every file, or the one matching
+ *  `file`), newest first. */
+async function revertTrackedTurn(tracker, worktree, file) {
+  if (!tracker.valid) throw new Error('turn review tracked file snapshot is unavailable');
+  const patchRoot = trackerPatchRoot(tracker, resolve(clean(worktree) || '.'));
+  const git = patchRoot.kind === 'git';
+  let targets = [...tracker.chains.values()]
+    .map((chain) => ({ chain, edit: chainEdit(chain, patchRoot.root) }))
+    // Beside a Git root, an edit outside it is view-only, never undone.
+    .filter(({ edit }) => edit && (!git || edit.inside));
+  if (file) {
+    const target = targets.find(({ chain }) => chainMatchesPath(chain, patchRoot.root, file));
+    if (!target) throw new Error(UNATTRIBUTED_FILE);
+    targets = [target];
+  }
+  if (targets.length === 0) return [];
+  for (const { edit } of targets) {
+    const omitted = edit.steps.flatMap(({ before, after }) => [before.content, after.content]).find(isOmittedContent);
+    if (!omitted) continue;
+    throw new Error(
+      `turn review revert is unavailable for ${edit.start.displayPath}: binary/large file content was not captured (${omitted.size} bytes)`
     );
   }
-  const recorded = await revertFromRecord(ownerSessionId, recordFile, expectedCheckpointId);
-  if (recorded) return recorded;
-  throw new Error('turn worktree snapshot is unavailable');
+  const edits = targets.map(({ edit }) => edit);
+  const objectFormat = await editsObjectFormat(edits, patchRoot);
+  const budget = createLineDiffBudget();
+  const files = edits.map((edit) => storedChangeFile(editChangeFile(edit, patchRoot.root, objectFormat, budget)));
+  const blocked = files.find((entry) => entry.revertable !== true);
+  if (blocked) throw new Error(`turn review revert is unavailable for ${blocked.path}: ${blocked.reason}`);
+  await applyTurnChangeFiles({ root: patchRoot.root, kind: patchRoot.kind, counts: 'own' }, files, {
+    reverse: true,
+  });
+  undoTrackedChains(
+    tracker,
+    targets.map(({ chain }) => chain)
+  );
+  const paths = recordFilePaths(patchRoot.root, files);
+  noteTurnWorktreeChange(paths);
+  if (tracker.worktreeSnapshot) {
+    try {
+      await refreshTurnWorktreeSnapshot(tracker.worktreeSnapshot, { force: true });
+    } catch {
+      // Best-effort refresh: the next review read captures afresh.
+    }
+  }
+  return paths;
 }
 
-/** Record a composer restore in the turn's change record: a record file whose
- *  every side (a rename's old path too) was restored is back at its
- *  turn-start bytes, i.e. `reverted`; every other file keeps its state. */
+/** Record a running turn's composer Undo in the record an earlier seal of the
+ *  same turn left (a completion wake reopened it): a record file whose every
+ *  side (a rename's old path too) was undone is `reverted`; every other file
+ *  keeps its state. */
 async function recordComposerRevert(ownerSessionId, { checkpointId, paths }) {
   if (!ownerSessionId || !checkpointId) return;
   const record = await loadTurnChangeRecord(ownerSessionId, checkpointId);
@@ -1343,26 +1641,28 @@ async function recordComposerRevert(ownerSessionId, { checkpointId, paths }) {
 /** Composer Undo of the latest turn, on the per-session change lock shared
  *  with historical Undo/Reapply, recorded in the turn's change record so the
  *  historical view offers Reapply rather than a second Undo. */
-function revertLatestTurn(worktree, sessionId, file, whole, expectedCheckpointId) {
+function revertLatestTurn(worktree, sessionId, file, expectedCheckpointId) {
   const ownerSessionId = clean(sessionId);
   return serializeChangeMutation(ownerSessionId, async () => {
-    // A seal still freezing would record the pre-restore disk after this.
+    // A seal still freezing would record the pre-restore state after this.
     const freezing = _diffTrackersBySession.get(ownerSessionId)?.freezing;
     if (freezing) await freezing.catch(() => {});
-    const restored = await revertLatestTurnUnlocked(worktree, ownerSessionId, file, whole, expectedCheckpointId);
-    await recordComposerRevert(ownerSessionId, restored);
+    const restored = await revertLatestTurnUnlocked(worktree, ownerSessionId, file, expectedCheckpointId);
+    if (!restored.recorded) await recordComposerRevert(ownerSessionId, restored);
     return await getTurnReviewDiff(worktree, ownerSessionId);
   });
 }
 
-/** Restore one reviewed file to this turn's worktree baseline, never to HEAD. */
+/** Undo this turn's own changes to one reviewed file (never a restore to HEAD
+ *  or to the turn-start bytes: foreign edits outside its hunks stay). */
 export function revertTurnReviewFile(worktree, sessionId, file, expectedCheckpointId = '') {
-  return revertLatestTurn(worktree, sessionId, file, false, expectedCheckpointId);
+  if (!clean(file)) return Promise.reject(new TypeError('turn review file path is required'));
+  return revertLatestTurn(worktree, sessionId, file, expectedCheckpointId);
 }
 
-/** Restore every file in the reviewed turn to its turn-start state. */
+/** Undo this turn's own changes to every file its tools wrote. */
 export function revertTurnReview(worktree, sessionId, expectedCheckpointId = '') {
-  return revertLatestTurn(worktree, sessionId, null, true, expectedCheckpointId);
+  return revertLatestTurn(worktree, sessionId, null, expectedCheckpointId);
 }
 
 // ── Historical turn changes (per-turn Undo/Reapply) ─────────────────────────
@@ -1401,9 +1701,10 @@ export async function getTurnChanges(sessionId, options = {}) {
   // An old record's outside-root file kept no counts: measure it so the card
   // agrees with the session review and the island.
   if (record?.files?.length) {
+    const budget = createLineDiffBudget();
     record = {
       ...record,
-      files: await Promise.all(record.files.map((file) => measureLegacyChangeFile(file, record.root))),
+      files: await Promise.all(record.files.map((file) => measureLegacyChangeFile(file, record.root, budget))),
     };
   }
   let status = 'missing';
@@ -1471,88 +1772,68 @@ function withUnknownChangeStates(ownerSessionId, record) {
   return keys ? { ...record, files: markUnknownStates(record.files, keys) } : record;
 }
 
-/** The exact-buffer review tracker (non-Git or contended worktree) an
- *  Undo/Reapply must fold into, with the pre-mutation bytes of every moved
- *  file under the tracker's root. Null when the review has a usable Git
- *  baseline (it re-captures instead) or nothing to fold. */
-async function trackedReviewFold(ownerSessionId, root, targets, reverse) {
+/** Bring the latest-turn review (composer bar, session Diff) in line with an
+ *  Undo/Reapply that just landed: signal the moved paths, fold the record's
+ *  own chains out of (or back into) the turn's tracker when it is that turn,
+ *  re-capture the Git snapshot (sealed ones too) and persist its
+ *  attribution. Best-effort: the mutation itself already landed. */
+async function refreshLatestTurnReview(ownerSessionId, record, targets, reverse) {
+  noteTurnWorktreeChange(recordFilePaths(record.root, targets));
   const tracker = _diffTrackersBySession.get(ownerSessionId);
-  if (!tracker?.valid || worktreeSnapshotUsable(tracker) || !tracker.worktreeRoot) return null;
-  const inside = (path) => {
-    const rel = relative(tracker.worktreeRoot, path);
-    return Boolean(rel) && !rel.startsWith('..') && !isAbsolute(rel);
-  };
-  const moves = [];
-  for (const entry of targets) {
-    const path = resolve(root, entry.path);
-    const oldPath = entry.oldPath ? resolve(root, entry.oldPath) : path;
-    const move = reverse ? { source: path, destination: oldPath } : { source: oldPath, destination: path };
-    if (inside(move.source) && inside(move.destination)) moves.push(move);
+  if (!tracker) return;
+  if (tracker.valid && clean(tracker.checkpointId) === clean(record.checkpointId)) {
+    const root = resolve(record.root);
+    if (reverse) {
+      const matches = (chain) =>
+        targets.some((file) => [file.path, file.oldPath].some((path) => chainMatchesPath(chain, root, path)));
+      undoTrackedChains(tracker, [...tracker.chains.values()].filter(matches));
+    } else {
+      redoTrackedChains(tracker, root, targets);
+    }
   }
-  if (moves.length === 0) return null;
+  if (!tracker.worktreeSnapshot) return;
   try {
-    for (const move of moves) move.before = await currentTrackedContent(move.source);
+    await refreshTurnWorktreeSnapshot(tracker.worktreeSnapshot, { force: true });
   } catch {
-    return { tracker, moves, unreadable: true };
+    // Best-effort refresh: persist the last captured state.
   }
-  return { tracker, moves };
-}
-
-/** One moved file as a tracked change: its pre-mutation bytes and what the
- *  mutation left at its destination. */
-async function movedFileChange(root, move) {
-  const change = {
-    path: move.source,
-    displayPath: trackedRelativePath(root, { path: move.source }),
-    before: move.before,
-    after: await currentTrackedContent(move.destination),
-  };
-  if (move.destination === move.source) return change;
-  return {
-    ...change,
-    newPath: move.destination,
-    newDisplayPath: trackedRelativePath(root, { path: move.destination }),
-  };
+  if (tracker.sealed) await persistTurnSnapshotRecord(ownerSessionId, tracker);
 }
 
-/** Fold an applied Undo/Reapply into the exact tracker. A file the tracker
- *  cannot read back exactly drops the tracked review rather than leaving it
- *  describing the old disk. */
-async function foldReviewMutation({ tracker, moves, unreadable }) {
-  try {
-    if (unreadable) throw new Error('unreadable');
-    const changes = [];
-    for (const move of moves) changes.push(await movedFileChange(tracker.worktreeRoot, move));
-    foldTrackedChanges(tracker, changes, null);
-    if (!tracker.unifiedDiff) releaseDiffTrackerContent(tracker);
-  } catch {
-    tracker.valid = false;
-    releaseDiffTrackerContent(tracker);
-    refreshUnifiedDiff(tracker);
+/** Reverse-apply (`reverse`) or forward-apply the record files `targets`
+ *  against the current disk, all-or-nothing: `git apply` checks every hunk
+ *  (every binary file's exact bytes) before it writes, so an overlapping
+ *  foreign edit fails the whole call and nothing is overwritten. Then their
+ *  state is recorded. Resolves to the updated record. */
+async function mutateRecordFiles(ownerSessionId, record, targets, reverse) {
+  const verb = reverse ? 'undone' : 'reapplied';
+  const checkpointId = clean(record.checkpointId);
+  const blocked = targets.find((entry) => entry.revertable !== true);
+  if (blocked) {
+    throw new Error(`${blocked.path} cannot be ${verb}: ${blocked.reason || 'no replayable patch was recorded'}`);
   }
-}
-
-/** Bring the latest-turn review (composer bar, session Diff) in line with
- *  the disk an Undo/Reapply just changed: signal the moved paths, fold the
- *  mutation into the exact tracker, re-capture the Git snapshot (sealed ones
- *  too) and persist its attribution. Best-effort: the mutation itself
- *  already landed. */
-async function refreshLatestTurnReview(ownerSessionId, root, targets, fold) {
-  noteTurnWorktreeChange(
-    targets
-      .flatMap((entry) => [entry.path, entry.oldPath])
-      .filter(Boolean)
-      .map((path) => resolve(root, path))
-  );
-  if (fold?.tracker.valid) await foldReviewMutation(fold);
-  const tracker = _diffTrackersBySession.get(ownerSessionId);
-  if (!tracker?.worktreeSnapshot) return;
+  await applyTurnChangeFiles(record, targets, { reverse });
+  // State lands only after git applied every target; a state that cannot
+  // land takes the worktree change back with it.
+  const keys = new Set(targets.map((entry) => changePathKey(entry.path)));
+  let updated;
   try {
-    await refreshTurnWorktreeSnapshot(tracker.worktreeSnapshot, { force: true });
-  } catch {
-    // Best-effort refresh: persist the last captured state.
+    updated = await writeTurnChangeState(ownerSessionId, checkpointId, keys, reverse ? 'reverted' : 'applied');
+  } catch (error) {
+    try {
+      await applyTurnChangeFiles(record, targets, { reverse: !reverse });
+    } catch (rollbackError) {
+      await markTurnChangeStateUnknown(ownerSessionId, checkpointId, keys);
+      await refreshLatestTurnReview(ownerSessionId, record, targets, reverse);
+      throw new Error(
+        `turn changes were ${verb} but could not be recorded (${error.message}), and restoring the worktree failed (${rollbackError.message}); Undo/Reapply of those files is disabled`,
+        { cause: error }
+      );
+    }
+    throw error;
   }
-  if (tracker.sealed) await persistTurnSnapshotRecord(ownerSessionId, tracker);
+  await refreshLatestTurnReview(ownerSessionId, record, targets, reverse);
+  return updated;
 }
 
 /** Undo (`reverse`) or Reapply one file or the whole turn, all-or-nothing. */
@@ -1581,32 +1862,7 @@ async function mutateTurnChanges(sessionId, checkpointIdValue, fileValue, revisi
       targets = (record.files || []).filter((entry) => fileState(entry) === from);
       if (targets.length === 0) throw new Error(`this turn has no changes to be ${verb}`);
     }
-    const blocked = targets.find((entry) => entry.revertable !== true);
-    if (blocked) {
-      throw new Error(`${blocked.path} cannot be ${verb}: ${blocked.reason || 'no replayable patch was recorded'}`);
-    }
-    const fold = await trackedReviewFold(ownerSessionId, record.root, targets, reverse);
-    const root = await applyTurnChangeFiles(record, targets, { reverse });
-    // State lands only after git applied every target; a state that cannot
-    // land takes the worktree change back with it.
-    const keys = new Set(targets.map((entry) => changePathKey(entry.path)));
-    let updated;
-    try {
-      updated = await writeTurnChangeState(ownerSessionId, checkpointId, keys, reverse ? 'reverted' : 'applied');
-    } catch (error) {
-      try {
-        await applyTurnChangeFiles(record, targets, { reverse: !reverse });
-      } catch (rollbackError) {
-        await markTurnChangeStateUnknown(ownerSessionId, checkpointId, keys);
-        await refreshLatestTurnReview(ownerSessionId, root, targets, fold);
-        throw new Error(
-          `turn changes were ${verb} but could not be recorded (${error.message}), and restoring the worktree failed (${rollbackError.message}); Undo/Reapply of those files is disabled`,
-          { cause: error }
-        );
-      }
-      throw error;
-    }
-    await refreshLatestTurnReview(ownerSessionId, root, targets, fold);
+    const updated = await mutateRecordFiles(ownerSessionId, record, targets, reverse);
     return turnChangesReply({
       status: updated ? 'ready' : 'missing',
       checkpointId,
@@ -1625,6 +1881,45 @@ export function reapplyTurnChanges(sessionId, checkpointId, file, revision) {
   return mutateTurnChanges(sessionId, checkpointId, file, revision, false);
 }
 
+/** Permanently delete this session's retained change history — every turn's
+ *  change record (patches, file metadata, applied/reverted state), its stored
+ *  Git baselines, and the live and latest-turn trackers that would resurface
+ *  them — so its reviews answer empty, across a restart too. Edits from the
+ *  next turn on are tracked again. Refused while a turn runs or seals; on the
+ *  per-session lock, behind any Undo/Reapply. Files, the Git index, commits
+ *  and the conversation are never touched. Resolves to `{ turns }`, the
+ *  number of turn records deleted. */
+export async function clearSessionChangeHistory(sessionId) {
+  const ownerSessionId = clean(sessionId);
+  if (!ownerSessionId) throw new Error('change history is unavailable without a session');
+  return await serializeChangeMutation(ownerSessionId, async () => {
+    if (sessionTurnBusy(ownerSessionId)) {
+      throw new Error('change history cannot be deleted while this session is running a turn');
+    }
+    // Invalidate every producer of the old history BEFORE the awaited
+    // deletion: a worker finishing meanwhile finds no turn to fold into, and
+    // a re-seal it (or anything earlier) already queued finds its tracker
+    // discarded, so nothing begun before the delete can write it back.
+    for (const [trackedSessionId, tracker] of _diffTrackersBySession) {
+      if (trackedSessionId !== ownerSessionId && tracker.ownerSessionId !== ownerSessionId) continue;
+      tracker.discarded = true;
+      tracker.resealQueued = false;
+      releaseDiffTrackerContent(tracker);
+      _diffTrackersBySession.delete(trackedSessionId);
+    }
+    _turnsBySession.delete(ownerSessionId);
+    for (const key of _unknownChangeStates.keys()) {
+      if (key.startsWith(`${ownerSessionId}\0`)) _unknownChangeStates.delete(key);
+    }
+    // The session's first-seen baselines go too: later edits start fresh ones.
+    const [turns] = await Promise.all([
+      clearStoredChangeHistory(ownerSessionId),
+      clearSessionBaselines(ownerSessionId),
+    ]);
+    return { turns };
+  });
+}
+
 export function _resetTurnSnapshotForTest() {
   _turnsBySession.clear();
   _diffTrackersBySession.clear();
@@ -1634,4 +1929,5 @@ export function _resetTurnSnapshotForTest() {
   _turnOpenedHookForTest = null;
   _agentTurnSeq = 0;
   _resetTurnWorktreeSnapshotsForTest();
+  _resetSessionBaselinesForTest();
 }