@fern-api/replay 0.14.0 → 0.15.0

package/dist/index.js

@@ -395,6 +395,63 @@ var init_HybridReconstruction = __esm({
   }
 });
 
+// src/PatchApplyTheirs.ts
+var PatchApplyTheirs_exports = {};
+__export(PatchApplyTheirs_exports, {
+  applyPatchToContent: () => applyPatchToContent
+});
+import { mkdtemp as mkdtemp3, mkdir as mkdir2, writeFile as writeFile3, readFile as readFile2, rm as rm3 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { dirname as dirname3, join as join4 } from "path";
+async function applyPatchToContent(base, patchContent, filePath) {
+  const fileDiff = extractFileDiff(patchContent, filePath);
+  if (!fileDiff) return null;
+  const tempDir = await mkdtemp3(join4(tmpdir3(), "replay-migrate-"));
+  const tempGit = new GitClient(tempDir);
+  try {
+    await tempGit.exec(["init"]);
+    await tempGit.exec(["config", "user.email", "migrate@fern.com"]);
+    await tempGit.exec(["config", "user.name", "Fern Replay Migration"]);
+    await tempGit.exec(["config", "commit.gpgSign", "false"]);
+    const tempFilePath = join4(tempDir, filePath);
+    await mkdir2(dirname3(tempFilePath), { recursive: true });
+    await writeFile3(tempFilePath, base);
+    await tempGit.exec(["add", filePath]);
+    await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
+    await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
+    return await readFile2(tempFilePath, "utf-8");
+  } catch {
+    return null;
+  } finally {
+    await rm3(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+function extractFileDiff(patchContent, filePath) {
+  const lines = patchContent.split("\n");
+  const out = [];
+  let inTarget = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      if (inTarget) break;
+      const match = line.match(/^diff --git a\/.+ b\/(.+)$/);
+      if (match && match[1] === filePath) {
+        inTarget = true;
+        out.push(line);
+      }
+      continue;
+    }
+    if (inTarget) out.push(line);
+  }
+  return out.length > 0 ? out.join("\n") + "\n" : null;
+}
+var init_PatchApplyTheirs = __esm({
+  "src/PatchApplyTheirs.ts"() {
+    "use strict";
+    init_GitClient();
+  }
+});
+
 // src/credentials.ts
 var CREDENTIAL_PATTERNS = [
   { name: "PRIVATE KEY block", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
@@ -526,7 +583,17 @@ var LockfileManager = class {
     this.warnings.length = 0;
     const cleanPatches = [];
     for (const patch of this.lock.patches) {
-      const credentialMatches = scanForCredentials(patch.patch_content);
+      const diffMatches = scanForCredentials(patch.patch_content);
+      const snapshotMatches = [];
+      if (patch.theirs_snapshot) {
+        for (const content2 of Object.values(patch.theirs_snapshot)) {
+          const m = scanForCredentials(content2);
+          for (const x of m) {
+            if (!snapshotMatches.includes(x)) snapshotMatches.push(x);
+          }
+        }
+      }
+      const credentialMatches = [...diffMatches, ...snapshotMatches.filter((m) => !diffMatches.includes(m))];
       const sensitiveFiles = patch.files.filter((f) => isSensitiveFile(f));
       if (credentialMatches.length > 0 || sensitiveFiles.length > 0) {
         const reasons = [];
@@ -647,1520 +714,1593 @@ var LockfileManager = class {
 
 // src/ReplayDetector.ts
 import { createHash } from "crypto";
-var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
-function parsePatchFileHeaders(patchContent) {
-  const results = [];
-  let currentPath = null;
-  let currentIsCreate = false;
-  let currentIsDelete = false;
-  const flush = () => {
-    if (currentPath !== null) {
-      results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
-    }
-  };
-  for (const line of patchContent.split("\n")) {
-    if (line.startsWith("diff --git ")) {
-      flush();
-      currentPath = null;
-      currentIsCreate = false;
-      currentIsDelete = false;
-      const match = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
-      if (match) {
-        currentPath = match[2] ?? null;
+
+// src/ReplayApplicator.ts
+import { mkdir, mkdtemp, readFile, rm, unlink, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname2, extname, join as join2 } from "path";
+import { minimatch } from "minimatch";
+
+// src/conflict-utils.ts
+var CONFLICT_OPENER = "<<<<<<< Generated";
+var CONFLICT_SEPARATOR = "=======";
+var CONFLICT_CLOSER = ">>>>>>> Your customization";
+function trimCR(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function findConflictRanges(lines) {
+  const ranges = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (trimCR(lines[i]) === CONFLICT_OPENER) {
+      let separatorIdx = -1;
+      let j = i + 1;
+      let found = false;
+      while (j < lines.length) {
+        const trimmed = trimCR(lines[j]);
+        if (trimmed === CONFLICT_OPENER) {
+          break;
+        }
+        if (separatorIdx === -1 && trimmed === CONFLICT_SEPARATOR) {
+          separatorIdx = j;
+        } else if (separatorIdx !== -1 && trimmed === CONFLICT_CLOSER) {
+          ranges.push({ start: i, separator: separatorIdx, end: j });
+          i = j;
+          found = true;
+          break;
+        }
+        j++;
       }
-    } else if (currentPath !== null) {
-      if (line.startsWith("new file mode ")) {
-        currentIsCreate = true;
-      } else if (line.startsWith("deleted file mode ")) {
-        currentIsDelete = true;
+      if (!found) {
+        i++;
+        continue;
       }
     }
+    i++;
   }
-  flush();
-  return results;
+  return ranges;
 }
-var ReplayDetector = class {
-  git;
-  lockManager;
-  sdkOutputDir;
-  warnings = [];
-  constructor(git, lockManager, sdkOutputDir) {
-    this.git = git;
-    this.lockManager = lockManager;
-    this.sdkOutputDir = sdkOutputDir;
-  }
-  async detectNewPatches() {
-    const lock = this.lockManager.read();
-    const lastGen = this.getLastGeneration(lock);
-    if (!lastGen) {
-      return { patches: [], revertedPatchIds: [] };
-    }
-    const exists = await this.git.commitExists(lastGen.commit_sha);
-    if (!exists) {
-      this.warnings.push(
-        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
-      );
-      return this.detectPatchesViaTreeDiff(
-        lastGen,
-        /* commitKnownMissing */
-        true
-      );
-    }
-    const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
-    if (!isAncestor) {
-      return this.detectPatchesViaMergeBase(lastGen, lock);
-    }
-    return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
-  }
-  /**
-   * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
-   *
-   * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
-   * `[fern-generated]`) is orphaned but still in git's object database. The
-   * merge-base is the commit on main from which the bot's branch was created —
-   * a reachable ancestor of HEAD. Walking that range and classifying each
-   * commit via `isGenerationCommit` mirrors the linear path and eliminates
-   * the bug class where pipeline-driven changes (autoversion, replay,
-   * generation) get bundled as customer customizations.
-   *
-   * Falls through to the legacy composite path when no common ancestor exists
-   * (truly disjoint history — orphan branches with no shared root).
-   */
-  async detectPatchesViaMergeBase(lastGen, lock) {
-    let mergeBase = "";
-    try {
-      mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
-    } catch {
-    }
-    if (!mergeBase) {
-      this.warnings.push(
-        `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
-      );
-      return this.detectPatchesViaTreeDiff(
-        lastGen,
-        /* commitKnownMissing */
-        false
-      );
-    }
-    return this.detectPatchesInRange(mergeBase, lastGen, lock);
+function stripConflictMarkers(content) {
+  const lines = content.split(/\r?\n/);
+  const ranges = findConflictRanges(lines);
+  if (ranges.length === 0) {
+    return content;
   }
-  /**
-   * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
-   * `StoredPatch` per customer commit. Body shared by the linear path
-   * (rangeStart = lastGen.commit_sha) and the merge-base path.
-   *
-   * Patch `base_generation` is always `lastGen.commit_sha` — the
-   * lockfile-tracked reference the applicator uses to fetch base file
-   * content, regardless of where the walk actually started.
-   */
-  async detectPatchesInRange(rangeStart, lastGen, lock) {
-    const log = await this.git.exec([
-      "log",
-      "--first-parent",
-      "--format=%H%x00%an%x00%ae%x00%s",
-      `${rangeStart}..HEAD`,
-      "--",
-      this.sdkOutputDir
-    ]);
-    if (!log.trim()) {
-      return { patches: [], revertedPatchIds: [] };
-    }
-    const commits = this.parseGitLog(log);
-    const newPatches = [];
-    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
-    for (const commit of commits) {
-      if (isGenerationCommit(commit)) {
-        continue;
-      }
-      if (lock.patches.find((p) => p.original_commit === commit.sha)) {
+  const result = [];
+  let rangeIdx = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (rangeIdx < ranges.length) {
+      const range = ranges[rangeIdx];
+      if (i === range.start) {
         continue;
       }
-      const parents = await this.git.getCommitParents(commit.sha);
-      if (parents.length > 1) {
-        const compositePatch = await this.createMergeCompositePatch({
-          mergeCommit: commit,
-          firstParent: parents[0],
-          lastGen,
-          lock
-        });
-        if (compositePatch) {
-          newPatches.push(compositePatch);
-        }
+      if (i > range.start && i < range.separator) {
+        result.push(lines[i]);
         continue;
       }
-      let patchContent;
-      try {
-        patchContent = await this.git.formatPatch(commit.sha);
-      } catch {
-        this.warnings.push(
-          `Could not generate patch for commit ${commit.sha.slice(0, 7)} \u2014 it may be unreachable in a shallow clone. Skipping.`
-        );
+      if (i === range.separator) {
         continue;
       }
-      let contentHash = this.computeContentHash(patchContent);
-      if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
+      if (i > range.separator && i < range.end) {
         continue;
       }
-      const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-      const allFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-      const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
-      const files = allFiles.filter((f) => !isSensitiveFile(f));
-      if (sensitiveFiles.length > 0) {
-        this.warnings.push(
-          `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
-        );
-        if (files.length > 0) {
-          const parentSha = parents[0];
-          if (parentSha) {
-            try {
-              patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
-            } catch {
-              continue;
-            }
-            if (!patchContent.trim()) continue;
-            contentHash = this.computeContentHash(patchContent);
-          }
-        }
-      }
-      if (files.length === 0) {
+      if (i === range.end) {
+        rangeIdx++;
         continue;
       }
-      newPatches.push({
-        id: `patch-${commit.sha.slice(0, 8)}`,
-        content_hash: contentHash,
-        original_commit: commit.sha,
-        original_message: commit.message,
-        original_author: `${commit.authorName} <${commit.authorEmail}>`,
-        base_generation: lastGen.commit_sha,
-        files,
-        patch_content: patchContent,
-        ...this.isCreationOnlyPatch(patchContent) ? { user_owned: true } : {}
-      });
     }
-    const survivingPatches = await this.collapseNetZeroFiles(newPatches);
-    survivingPatches.reverse();
-    const revertedPatchIdSet = /* @__PURE__ */ new Set();
-    const revertIndicesToRemove = /* @__PURE__ */ new Set();
-    for (let i = 0; i < survivingPatches.length; i++) {
-      const patch = survivingPatches[i];
-      if (!isRevertCommit(patch.original_message)) continue;
-      let body = "";
-      try {
-        body = await this.git.getCommitBody(patch.original_commit);
-      } catch {
-      }
-      const revertedSha = parseRevertedSha(body);
-      const revertedMessage = parseRevertedMessage(patch.original_message);
-      let matchedExisting = false;
-      if (revertedSha) {
-        const existing = lock.patches.find((p) => p.original_commit === revertedSha);
-        if (existing) {
-          revertedPatchIdSet.add(existing.id);
-          revertIndicesToRemove.add(i);
-          matchedExisting = true;
-        }
-      }
-      if (!matchedExisting && revertedMessage) {
-        const existing = lock.patches.find((p) => p.original_message === revertedMessage);
-        if (existing) {
-          revertedPatchIdSet.add(existing.id);
-          revertIndicesToRemove.add(i);
-          matchedExisting = true;
-        }
-      }
-      if (matchedExisting) continue;
-      let matchedNew = false;
-      if (revertedSha) {
-        const idx = survivingPatches.findIndex(
-          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_commit === revertedSha
-        );
-        if (idx !== -1) {
-          revertIndicesToRemove.add(i);
-          revertIndicesToRemove.add(idx);
-          matchedNew = true;
-        }
-      }
-      if (!matchedNew && revertedMessage) {
-        const idx = survivingPatches.findIndex(
-          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_message === revertedMessage
-        );
-        if (idx !== -1) {
-          revertIndicesToRemove.add(i);
-          revertIndicesToRemove.add(idx);
-        }
-      }
-      if (!matchedExisting && !matchedNew) {
-        revertIndicesToRemove.add(i);
+    result.push(lines[i]);
+  }
+  return result.join("\n");
+}
+
+// src/ThreeWayMerge.ts
+import { diff3Merge, diffPatch } from "node-diff3";
+function threeWayMerge(base, ours, theirs) {
+  const baseLines = base.split("\n");
+  const oursLines = ours.split("\n");
+  const theirsLines = theirs.split("\n");
+  const regions = diff3Merge(oursLines, baseLines, theirsLines);
+  const outputLines = [];
+  const conflicts = [];
+  let currentLine = 1;
+  for (const region of regions) {
+    if (region.ok) {
+      outputLines.push(...region.ok);
+      currentLine += region.ok.length;
+    } else if (region.conflict) {
+      const resolved = tryResolveConflict(
+        region.conflict.a,
+        // ours (generator)
+        region.conflict.o,
+        // base
+        region.conflict.b
+        // theirs (user)
+      );
+      if (resolved !== null) {
+        outputLines.push(...resolved);
+        currentLine += resolved.length;
+      } else {
+        const startLine = currentLine;
+        outputLines.push("<<<<<<< Generated");
+        outputLines.push(...region.conflict.a);
+        outputLines.push("=======");
+        outputLines.push(...region.conflict.b);
+        outputLines.push(">>>>>>> Your customization");
+        const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
+        conflicts.push({
+          startLine,
+          endLine: startLine + conflictLines - 1,
+          ours: region.conflict.a,
+          theirs: region.conflict.b
+        });
+        currentLine += conflictLines;
       }
     }
-    const filteredPatches = survivingPatches.filter((_, i) => !revertIndicesToRemove.has(i));
-    return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
   }
-  /**
-   * Compute content hash for deduplication.
-   *
-   * Produces a format-agnostic hash so both `git format-patch` output
-   * (email-wrapped) and plain `git diff` output hash to the same value
-   * when the underlying diff hunks are identical.
-   *
-   * Normalization:
-   *   1. Strip email wrapper: everything before the first `diff --git` line
-   *      (From:, Subject:, Date:, diffstat, blank separators).
-   *   2. Strip `index` lines (blob SHA pairs change across rebases).
-   *   3. Strip trailing git version marker (`-- \n<version>`).
-   *
-   * This ensures content hashes match across the no-patches and normal-
-   * regeneration flows, which store formatPatch and git-diff formats
-   * respectively (FER-9850, D5-D9).
-   */
-  computeContentHash(patchContent) {
-    const lines = patchContent.split("\n");
-    const diffStart = lines.findIndex((l) => l.startsWith("diff --git "));
-    const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
-    const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
-    return `sha256:${createHash("sha256").update(normalized).digest("hex")}`;
+  const result = {
+    content: outputLines.join("\n"),
+    hasConflicts: conflicts.length > 0,
+    conflicts
+  };
+  if (conflicts.length === 0) {
+    const dropped = computeDroppedContextLines(baseLines, theirsLines, outputLines);
+    if (dropped.length > 0) {
+      result.droppedContextLines = dropped;
+    }
   }
-  /**
-   * FER-9805 — Drop patches whose files were transiently created and then
-   * deleted within the current linear detection window, and are absent from
-   * HEAD at the end of the window.
-   *
-   * Rationale: on a merge commit, createMergeCompositePatch already diffs
-   * firstParent..mergeCommit so net-zero files never enter the composite. On
-   * linear history each commit becomes its own patch, so a file that was
-   * briefly added and later removed survives as a create+delete pair whose
-   * cumulative diff is empty. We drop such patches before they reach the
-   * lockfile.
-   *
-   * A file is "transient" when:
-   *   1. some patch in the window sets `new file mode` for it (a creation), AND
-   *   2. some patch in the window sets `deleted file mode` for it (a deletion), AND
-   *   3. it is absent from HEAD's tree.
-   *
-   * The HEAD guard (#3) prevents false positives when a file is deleted
-   * and then recreated with different content — the cumulative diff of
-   * such a pair is non-empty and must be preserved.
-   *
-   * This only drops patches whose `files` are a subset of the transient
-   * set. A partial-transient patch (one that touches a transient file
-   * alongside a persistent one) is left unmodified; surgical stripping of
-   * single files from a multi-file patch would require a follow-up that
-   * regenerates the patch content via `git format-patch -- <files>`. No
-   * current failing test exercises this, and leaving the patch intact
-   * preserves today's behaviour. TODO(FER-9805): revisit if a future
-   * adversarial test demands per-file stripping.
-   */
-  async collapseNetZeroFiles(patches) {
-    if (patches.length === 0) return patches;
-    const stateByFile = /* @__PURE__ */ new Map();
-    for (const patch of patches) {
-      for (const header of parsePatchFileHeaders(patch.patch_content)) {
-        if (!header.isCreate && !header.isDelete) continue;
-        const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
-        if (header.isCreate) prior.created = true;
-        if (header.isDelete) prior.deleted = true;
-        stateByFile.set(header.path, prior);
-      }
+  return result;
+}
+function computeDroppedContextLines(baseLines, theirsLines, mergedLines) {
+  const baseCounts = countLines(baseLines);
+  const theirsCounts = countLines(theirsLines);
+  const mergedCounts = countLines(mergedLines);
+  const dropped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of baseLines) {
+    if (seen.has(line)) continue;
+    const inBase = baseCounts.get(line) ?? 0;
+    const inTheirs = theirsCounts.get(line) ?? 0;
+    const inMerged = mergedCounts.get(line) ?? 0;
+    if (inBase > 0 && inTheirs > 0 && inMerged < Math.min(inBase, inTheirs)) {
+      dropped.push(line);
+      seen.add(line);
     }
-    let anyCandidate = false;
-    for (const state of stateByFile.values()) {
-      if (state.created && state.deleted) {
-        anyCandidate = true;
-        break;
+  }
+  return dropped;
+}
+function countLines(lines) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    counts.set(line, (counts.get(line) ?? 0) + 1);
+  }
+  return counts;
+}
+function tryResolveConflict(oursLines, baseLines, theirsLines) {
+  if (baseLines.length === 0) {
+    return null;
+  }
+  const oursPatches = diffPatch(baseLines, oursLines);
+  const theirsPatches = diffPatch(baseLines, theirsLines);
+  if (oursPatches.length === 0) return theirsLines;
+  if (theirsPatches.length === 0) return oursLines;
+  if (patchesOverlap(oursPatches, theirsPatches)) {
+    return null;
+  }
+  return applyBothPatches(baseLines, oursPatches, theirsPatches);
+}
+function patchesOverlap(oursPatches, theirsPatches) {
+  for (const op of oursPatches) {
+    const oStart = op.buffer1.offset;
+    const oEnd = oStart + op.buffer1.length;
+    for (const tp of theirsPatches) {
+      const tStart = tp.buffer1.offset;
+      const tEnd = tStart + tp.buffer1.length;
+      if (op.buffer1.length === 0 && tp.buffer1.length === 0 && oStart === tStart) {
+        return true;
       }
-    }
-    if (!anyCandidate) return patches;
-    const headFiles = await this.listHeadFiles();
-    const transient = /* @__PURE__ */ new Set();
-    for (const [file, state] of stateByFile) {
-      if (state.created && state.deleted && !headFiles.has(file)) {
-        transient.add(file);
+      if (tp.buffer1.length === 0 && tStart === oEnd) {
+        return true;
+      }
+      if (op.buffer1.length === 0 && oStart === tEnd) {
+        return true;
+      }
+      if (oStart < tEnd && tStart < oEnd) {
+        return true;
       }
     }
-    if (transient.size === 0) return patches;
-    return patches.filter((patch) => !patch.files.every((f) => transient.has(f)));
   }
-  /**
-   * List every tracked path at HEAD (one `git ls-tree -r` invocation).
-   * Returns an empty Set if HEAD is unborn or the invocation fails — the
-   * caller then treats every candidate as "not in HEAD" and may collapse
-   * more aggressively. On typical SDK repos this is a single sub-10ms call.
+  return false;
+}
+function applyBothPatches(baseLines, oursPatches, theirsPatches) {
+  const allPatches = [
+    ...oursPatches.map((p) => ({
+      offset: p.buffer1.offset,
+      length: p.buffer1.length,
+      replacement: p.buffer2.chunk
+    })),
+    ...theirsPatches.map((p) => ({
+      offset: p.buffer1.offset,
+      length: p.buffer1.length,
+      replacement: p.buffer2.chunk
+    }))
+  ];
+  allPatches.sort((a, b) => b.offset - a.offset);
+  const result = [...baseLines];
+  for (const p of allPatches) {
+    result.splice(p.offset, p.length, ...p.replacement);
+  }
+  return result;
+}
+
+// src/ReplayApplicator.ts
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".svg",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".jar",
+  ".war",
+  ".ear",
+  ".class",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".o",
+  ".a",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".wav",
+  ".flac",
+  ".sqlite",
+  ".db",
+  ".pyc",
+  ".pyo",
+  ".DS_Store"
+]);
+var ReplayApplicator = class {
+  git;
+  lockManager;
+  outputDir;
+  renameCache = /* @__PURE__ */ new Map();
+  treeExistsCache = /* @__PURE__ */ new Map();
+  fileTheirsAccumulator = /* @__PURE__ */ new Map();
+  /**
+   * Apply mode for the current `applyPatches` invocation. Set at the start
+   * of `applyPatches`, read by `mergeFile` to decide:
+   *   - whether to skip the intra-loop marker strip (kept in `applyPatches`)
+   *   - whether to populate the accumulator after a conflicted merge
+   *     (resolve mode populates so subsequent patches on the same file
+   *     can use patch A's THEIRS as a structurally-correct merge base
+   *     when their diff was authored against post-A structure)
+   *   - whether to retry THEIRS reconstruction against the accumulator
+   *     when the BASE-relative reconstruction produced markers from a
+   *     cross-patch context mismatch
    */
-  async listHeadFiles() {
-    try {
-      const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
-      return new Set(out.split("\n").map((l) => l.trim()).filter(Boolean));
-    } catch {
-      return /* @__PURE__ */ new Set();
-    }
+  currentApplyMode = "replay";
+  /**
+   * Set of files that appear in 2+ patches in the current `applyPatches`
+   * invocation. Computed at the top of `applyPatches`. Read by `mergeFile`
+   * and `populateAccumulatorForPatch` to decide whether to use the patch's
+   * `theirs_snapshot` directly as THEIRS (snapshot-as-primary) or fall
+   * back to line-anchored reconstruction (FER-9525 cross-patch isolation).
+   *
+   * Snapshot-as-primary is correct when the patch owns its file (no other
+   * patch in this run touches it): the snapshot is what the customer
+   * intends for that file post-regen, regardless of generator structural
+   * changes that would invalidate the diff's line anchors.
+   *
+   * When a file IS shared, snapshots are CUMULATIVE across the patches
+   * touching it (each one's snapshot includes prior patches' contributions).
+   * Using a later patch's cumulative snapshot as its individual THEIRS
+   * would propagate prior patches' edits into the merge — surfacing nested
+   * conflicts at regions the patch alone never touched. Reconstruction
+   * via `applyPatchToContent` is required there.
+   */
+  sharedFiles = /* @__PURE__ */ new Set();
+  constructor(git, lockManager, outputDir) {
+    this.git = git;
+    this.lockManager = lockManager;
+    this.outputDir = outputDir;
   }
   /**
-   * Create a single composite patch for a merge commit by diffing the merge
-   * commit against its first parent. This captures the net change of the
-   * entire merged branch as one patch, eliminating accumulator chaining and
-   * zero-net-change ghost conflicts.
+   * Resolve the GenerationRecord for a patch's base_generation.
+   * Falls back to constructing an ad-hoc record from the commit's tree
+   * when base_generation isn't a tracked generation (commit-scan patches).
    */
-  async createMergeCompositePatch(input) {
-    const { mergeCommit, firstParent, lastGen, lock } = input;
-    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
-    const filesOutput = await this.git.exec([
-      "diff",
-      "--name-only",
-      firstParent,
-      mergeCommit.sha
-    ]);
-    const allMergeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-    const sensitiveMergeFiles = allMergeFiles.filter((f) => isSensitiveFile(f));
-    const files = allMergeFiles.filter((f) => !isSensitiveFile(f));
-    if (sensitiveMergeFiles.length > 0) {
-      this.warnings.push(
-        `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveMergeFiles.join(", ")}. These files will not be tracked by replay.`
-      );
-    }
-    if (files.length === 0) return null;
-    const diff = await this.git.exec([
-      "diff",
-      firstParent,
-      mergeCommit.sha,
-      "--",
-      ...files
-    ]);
-    if (!diff.trim()) return null;
-    const contentHash = this.computeContentHash(diff);
-    if (lock.patches.some((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
-      return null;
+  async resolveBaseGeneration(baseGeneration) {
+    const gen = this.lockManager.getGeneration(baseGeneration);
+    if (gen) return gen;
+    try {
+      const treeHash = await this.git.getTreeHash(baseGeneration);
+      return {
+        commit_sha: baseGeneration,
+        tree_hash: treeHash,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        cli_version: "unknown",
+        generator_versions: {}
+      };
+    } catch {
+      return void 0;
     }
-    return {
-      id: `patch-merge-${mergeCommit.sha.slice(0, 8)}`,
-      content_hash: contentHash,
-      original_commit: mergeCommit.sha,
-      original_message: mergeCommit.message,
-      original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
-      base_generation: lastGen.commit_sha,
-      files,
-      patch_content: diff,
-      ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
-    };
+  }
+  /** Reset inter-patch accumulator for a new cycle. */
+  resetAccumulator() {
+    this.fileTheirsAccumulator.clear();
   }
   /**
-   * Detect patches via tree diff for non-linear history. Returns a composite patch.
-   * Revert reconciliation is skipped here because tree-diff produces a single composite
-   * patch from the aggregate diff — individual revert commits are not distinguishable.
+   * @internal Test-only.
+   * Returns a defensive copy of the inter-patch accumulator. Used by the
+   * adversarial test suite (FER-9791) to assert invariant I2: after every
+   * applied patch, the accumulator has an entry for each file the patch
+   * touched, and the entry's content matches on-disk.
    */
-  async detectPatchesViaTreeDiff(lastGen, commitKnownMissing) {
-    const diffBase = await this.resolveDiffBase(lastGen, commitKnownMissing);
-    if (!diffBase) {
-      return this.detectPatchesViaCommitScan();
-    }
-    const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
-    const allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-    const sensitiveTreeFiles = allTreeFiles.filter((f) => isSensitiveFile(f));
-    const files = allTreeFiles.filter((f) => !isSensitiveFile(f));
-    if (sensitiveTreeFiles.length > 0) {
-      this.warnings.push(
-        `Sensitive file(s) excluded from composite patch: ${sensitiveTreeFiles.join(", ")}. These files will not be tracked by replay.`
-      );
-    }
-    if (files.length === 0) return { patches: [], revertedPatchIds: [] };
-    const diff = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
-    if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
-    const contentHash = this.computeContentHash(diff);
-    const lock = this.lockManager.read();
-    if (lock.patches.some((p) => p.content_hash === contentHash) || (lock.forgotten_hashes ?? []).includes(contentHash)) {
-      return { patches: [], revertedPatchIds: [] };
+  getAccumulatorSnapshot() {
+    const snapshot = /* @__PURE__ */ new Map();
+    for (const [path, entry] of this.fileTheirsAccumulator) {
+      snapshot.set(path, { content: entry.content, baseGeneration: entry.baseGeneration });
     }
-    const headSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
-    const compositePatch = {
-      id: `patch-composite-${headSha.slice(0, 8)}`,
-      content_hash: contentHash,
-      original_commit: headSha,
-      original_message: "Customer customizations (composite)",
-      original_author: "composite",
-      // Use diffBase when commit is unreachable — the applicator needs a reachable
-      // reference to find base file content. diffBase may be the tree_hash.
-      base_generation: commitKnownMissing ? diffBase : lastGen.commit_sha,
-      files,
-      patch_content: diff,
-      ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
-    };
-    return { patches: [compositePatch], revertedPatchIds: [] };
+    return snapshot;
   }
   /**
-   * Last-resort detection when both generation commit and tree are unreachable.
-   * Scans all commits from HEAD, filters against known lockfile patches, and
-   * skips creation-only commits (squashed history after force push).
+   * Apply all patches, returning results for each.
+   * Skips patches that match exclude patterns in replay.yml
    *
-   * Detected patches use the commit's parent as base_generation so the applicator
-   * can find base file content from the parent's tree (which IS reachable).
+   * `applyMode` controls the post-conflict marker strategy:
+   *   - `"replay"` (default): strip conflict markers from disk between
+   *     iterations whenever a later patch touches the same file. Lets the
+   *     follow-up patch's `git apply --3way` see clean OURS content,
+   *     which is what the silent-loss fix (PR #73) relies on. The replay
+   *     pipeline calls `revertConflictingFiles` after the loop to clean
+   *     any markers that survive.
+   *   - `"resolve"`: keep markers on disk. The resolve command needs the
+   *     customer to see them. Slow-path 3-way merge naturally preserves
+   *     A's markers and B's clean writes when their regions don't overlap;
+   *     when they do overlap, the customer gets nested markers and
+   *     resolves manually. Either way they aren't silently dropped.
    */
-  async detectPatchesViaCommitScan() {
-    const lock = this.lockManager.read();
-    const log = await this.git.exec([
-      "log",
-      "--max-count=200",
-      "--format=%H%x00%an%x00%ae%x00%s",
-      "HEAD",
-      "--",
-      this.sdkOutputDir
-    ]);
-    if (!log.trim()) {
-      return { patches: [], revertedPatchIds: [] };
-    }
-    const commits = this.parseGitLog(log);
-    const newPatches = [];
-    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
-    const existingHashes = new Set(lock.patches.map((p) => p.content_hash));
-    const existingCommits = new Set(lock.patches.map((p) => p.original_commit));
-    for (const commit of commits) {
-      if (isGenerationCommit(commit)) {
-        continue;
-      }
-      const parents = await this.git.getCommitParents(commit.sha);
-      if (parents.length > 1) {
-        continue;
-      }
-      if (existingCommits.has(commit.sha)) {
-        continue;
-      }
-      let patchContent;
-      try {
-        patchContent = await this.git.formatPatch(commit.sha);
-      } catch {
-        continue;
-      }
-      let contentHash = this.computeContentHash(patchContent);
-      if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
-        continue;
+  async applyPatches(patches, opts) {
+    const applyMode = opts?.applyMode ?? "replay";
+    this.currentApplyMode = applyMode;
+    this.resetAccumulator();
+    const fileFreq = /* @__PURE__ */ new Map();
+    for (const p of patches) {
+      for (const f of p.files) {
+        fileFreq.set(f, (fileFreq.get(f) ?? 0) + 1);
       }
-      if (this.isCreationOnlyPatch(patchContent)) {
+    }
+    this.sharedFiles = new Set(
+      Array.from(fileFreq.entries()).filter(([, n]) => n > 1).map(([f]) => f)
+    );
+    const results = [];
+    for (let i = 0; i < patches.length; i++) {
+      const patch = patches[i];
+      if (this.isExcluded(patch)) {
+        results.push({
+          patch,
+          status: "skipped",
+          method: "git-am"
+        });
         continue;
       }
-      const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-      const allScanFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f));
-      const sensitiveScanFiles = allScanFiles.filter((f) => isSensitiveFile(f));
-      const files = allScanFiles.filter((f) => !isSensitiveFile(f));
-      if (sensitiveScanFiles.length > 0) {
-        this.warnings.push(
-          `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveScanFiles.join(", ")}. These files will not be tracked by replay.`
-        );
-        if (files.length > 0) {
-          if (parents.length === 0) {
-            continue;
+      const result = await this.applyPatchWithFallback(patch);
+      results.push(result);
+      if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
+        const laterFiles = /* @__PURE__ */ new Set();
+        for (let j = i + 1; j < patches.length; j++) {
+          for (const f of patches[j].files) {
+            laterFiles.add(f);
           }
-          try {
-            patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
-          } catch {
-            continue;
+        }
+        const resolvedToOriginal = /* @__PURE__ */ new Map();
+        if (result.resolvedFiles) {
+          for (const [orig, resolved] of Object.entries(result.resolvedFiles)) {
+            resolvedToOriginal.set(resolved, orig);
+          }
+        }
+        for (const fileResult of result.fileResults) {
+          if (fileResult.status !== "conflict") continue;
+          const originalPath = resolvedToOriginal.get(fileResult.file) ?? fileResult.file;
+          if (laterFiles.has(fileResult.file) || laterFiles.has(originalPath)) {
+            const filePath = join2(this.outputDir, fileResult.file);
+            try {
+              const content = await readFile(filePath, "utf-8");
+              const stripped = stripConflictMarkers(content);
+              await writeFile(filePath, stripped);
+            } catch {
+            }
           }
-          if (!patchContent.trim()) continue;
-          contentHash = this.computeContentHash(patchContent);
         }
       }
-      if (files.length === 0) {
-        continue;
-      }
-      if (parents.length === 0) {
-        continue;
-      }
-      const parentSha = parents[0];
-      newPatches.push({
-        id: `patch-${commit.sha.slice(0, 8)}`,
-        content_hash: contentHash,
-        original_commit: commit.sha,
-        original_message: commit.message,
-        original_author: `${commit.authorName} <${commit.authorEmail}>`,
-        base_generation: parentSha,
-        files,
-        patch_content: patchContent
-      });
     }
-    newPatches.reverse();
-    return { patches: newPatches, revertedPatchIds: [] };
+    return results;
   }
   /**
-   * Check if a format-patch consists entirely of new-file creations.
-   * Used to identify squashed commits after force push, which create all files
-   * from scratch (--- /dev/null) rather than modifying existing files.
+   * Populate accumulator after git apply succeeds, AND collect per-file
+   * results including any "dropped context lines" — lines that were
+   * present in BASE and THEIRS (unchanged context) but absent from the
+   * final on-disk state because OURS deleted them. This is the fast-path
+   * counterpart to ThreeWayMerge.computeDroppedContextLines used by the
+   * 3-way slow path; both must surface the same warning.
    */
-  isCreationOnlyPatch(patchContent) {
-    const diffOldHeaders = patchContent.split("\n").filter((l) => l.startsWith("--- "));
-    if (diffOldHeaders.length === 0) {
-      return false;
+  async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
+    const fileResults = [];
+    if (!baseGen) return fileResults;
+    const tempDir = await mkdtemp(join2(tmpdir(), "replay-acc-"));
+    const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
+    const tempGit = new GitClient2(tempDir);
+    await tempGit.exec(["init"]);
+    await tempGit.exec(["config", "user.email", "replay@fern.com"]);
+    await tempGit.exec(["config", "user.name", "Fern Replay"]);
+    try {
+      for (const filePath of patch.files) {
+        if (isBinaryFile(filePath)) continue;
+        const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
+        const base = await this.git.showFile(baseGen.tree_hash, filePath);
+        const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
+        const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
+        const theirs = !fileIsShared && snapshotForFile != null ? snapshotForFile : await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
+        const finalOnDisk = await readFile(join2(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+        const effectiveTheirs = theirs ?? finalOnDisk;
+        if (effectiveTheirs != null) {
+          this.fileTheirsAccumulator.set(resolvedPath, {
+            content: effectiveTheirs,
+            baseGeneration: patch.base_generation
+          });
+        }
+        if (base != null && effectiveTheirs != null && finalOnDisk != null) {
+          const dropped = computeDroppedContextLinesForFile(base, effectiveTheirs, finalOnDisk);
+          if (dropped.length > 0) {
+            fileResults.push({
+              file: resolvedPath,
+              status: "merged",
+              droppedContextLines: dropped
+            });
+          }
+        }
+      }
+    } finally {
+      await rm(tempDir, { recursive: true }).catch(() => {
+      });
     }
-    return diffOldHeaders.every((l) => l === "--- /dev/null");
+    return fileResults;
   }
-  /**
-   * Resolve the best available diff base for a generation record.
-   * Prefers commit_sha, falls back to tree_hash for unreachable commits.
-   * When commitKnownMissing is true, skips the redundant commitExists check.
-   */
-  async resolveDiffBase(gen, commitKnownMissing) {
-    if (!commitKnownMissing && await this.git.commitExists(gen.commit_sha)) {
-      return gen.commit_sha;
+  async applyPatchWithFallback(patch) {
+    const baseGen = await this.resolveBaseGeneration(patch.base_generation);
+    const lock = this.lockManager.read();
+    const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+    const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
+    const needsAccumulation = await Promise.all(
+      patch.files.map(async (f) => {
+        if (!baseGen) return false;
+        const resolved = await this.resolveFilePath(f, baseGen.tree_hash, currentTreeHash);
+        return this.fileTheirsAccumulator.has(resolved);
+      })
+    ).then((results) => results.some(Boolean));
+    const resolvedFiles = {};
+    for (const filePath of patch.files) {
+      const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
+      if (resolvedPath !== filePath) {
+        resolvedFiles[filePath] = resolvedPath;
+      }
     }
-    if (await this.git.treeExists(gen.tree_hash)) {
-      return gen.tree_hash;
+    const patchIsRenameAware = /^rename from /m.test(patch.patch_content);
+    const hasGeneratorRename = Object.keys(resolvedFiles).length > 0 && !patchIsRenameAware;
+    if (!needsAccumulation && !hasGeneratorRename) {
+      const snapshots = /* @__PURE__ */ new Map();
+      for (const filePath of patch.files) {
+        const fullPath = join2(this.outputDir, filePath);
+        snapshots.set(filePath, await readFile(fullPath, "utf-8").catch(() => null));
+      }
+      try {
+        await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
+        const fastPathFileResults = await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
+        return {
+          patch,
+          status: "applied",
+          method: "git-am",
+          ...fastPathFileResults.length > 0 && { fileResults: fastPathFileResults },
+          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+        };
+      } catch {
+        for (const [filePath, content] of snapshots) {
+          const fullPath = join2(this.outputDir, filePath);
+          if (content != null) {
+            await writeFile(fullPath, content);
+          } else {
+            await unlink(fullPath).catch(() => {
+            });
+          }
+        }
+      }
     }
-    return null;
+    return this.applyWithThreeWayMerge(patch);
   }
-  parseGitLog(log) {
-    return log.trim().split("\n").map((line) => {
-      const [sha, authorName, authorEmail, message] = line.split("\0");
-      return { sha, authorName, authorEmail, message };
-    });
+  async applyWithThreeWayMerge(patch) {
+    const fileResults = [];
+    const resolvedFiles = {};
+    const tempDir = await mkdtemp(join2(tmpdir(), "replay-"));
+    const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
+    const tempGit = new GitClient2(tempDir);
+    await tempGit.exec(["init"]);
+    await tempGit.exec(["config", "user.email", "replay@fern.com"]);
+    await tempGit.exec(["config", "user.name", "Fern Replay"]);
+    try {
+      for (const filePath of patch.files) {
+        if (isBinaryFile(filePath)) {
+          fileResults.push({
+            file: filePath,
+            status: "skipped",
+            reason: "binary-file"
+          });
+          continue;
+        }
+        const result = await this.mergeFile(patch, filePath, tempGit, tempDir);
+        if (result.file !== filePath) {
+          resolvedFiles[filePath] = result.file;
+        }
+        fileResults.push(result);
+      }
+    } finally {
+      await rm(tempDir, { recursive: true }).catch(() => {
+      });
+    }
+    const conflictFiles = fileResults.filter((r) => r.status === "conflict");
+    const hasConflicts = conflictFiles.length > 0;
+    const conflictReason = hasConflicts ? conflictFiles.some((f) => f.conflictReason === "base-generation-mismatch") ? "base-generation-mismatch" : conflictFiles[0]?.conflictReason : void 0;
+    return {
+      patch,
+      status: hasConflicts ? "conflict" : "applied",
+      method: "3way-merge",
+      fileResults,
+      conflictReason,
+      ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+    };
   }
-  getLastGeneration(lock) {
-    return lock.generations.find((g) => g.commit_sha === lock.current_generation);
-  }
-};
-
-// src/ThreeWayMerge.ts
-import { diff3Merge, diffPatch } from "node-diff3";
-function threeWayMerge(base, ours, theirs) {
-  const baseLines = base.split("\n");
-  const oursLines = ours.split("\n");
-  const theirsLines = theirs.split("\n");
-  const regions = diff3Merge(oursLines, baseLines, theirsLines);
-  const outputLines = [];
-  const conflicts = [];
-  let currentLine = 1;
-  for (const region of regions) {
-    if (region.ok) {
-      outputLines.push(...region.ok);
-      currentLine += region.ok.length;
-    } else if (region.conflict) {
-      const resolved = tryResolveConflict(
-        region.conflict.a,
-        // ours (generator)
-        region.conflict.o,
-        // base
-        region.conflict.b
-        // theirs (user)
-      );
-      if (resolved !== null) {
-        outputLines.push(...resolved);
-        currentLine += resolved.length;
-      } else {
-        const startLine = currentLine;
-        outputLines.push("<<<<<<< Generated");
-        outputLines.push(...region.conflict.a);
-        outputLines.push("=======");
-        outputLines.push(...region.conflict.b);
-        outputLines.push(">>>>>>> Your customization");
-        const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
-        conflicts.push({
-          startLine,
-          endLine: startLine + conflictLines - 1,
-          ours: region.conflict.a,
-          theirs: region.conflict.b
-        });
-        currentLine += conflictLines;
+  async mergeFile(patch, filePath, tempGit, tempDir) {
+    try {
+      const baseGen = await this.resolveBaseGeneration(patch.base_generation);
+      if (!baseGen) {
+        return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
       }
-    }
-  }
-  const result = {
-    content: outputLines.join("\n"),
-    hasConflicts: conflicts.length > 0,
-    conflicts
-  };
-  if (conflicts.length === 0) {
-    const dropped = computeDroppedContextLines(baseLines, theirsLines, outputLines);
-    if (dropped.length > 0) {
-      result.droppedContextLines = dropped;
-    }
-  }
-  return result;
-}
-function computeDroppedContextLines(baseLines, theirsLines, mergedLines) {
-  const baseCounts = countLines(baseLines);
-  const theirsCounts = countLines(theirsLines);
-  const mergedCounts = countLines(mergedLines);
-  const dropped = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const line of baseLines) {
-    if (seen.has(line)) continue;
-    const inBase = baseCounts.get(line) ?? 0;
-    const inTheirs = theirsCounts.get(line) ?? 0;
-    const inMerged = mergedCounts.get(line) ?? 0;
-    if (inBase > 0 && inTheirs > 0 && inMerged < Math.min(inBase, inTheirs)) {
-      dropped.push(line);
-      seen.add(line);
-    }
-  }
-  return dropped;
-}
-function countLines(lines) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    counts.set(line, (counts.get(line) ?? 0) + 1);
-  }
-  return counts;
-}
-function tryResolveConflict(oursLines, baseLines, theirsLines) {
-  if (baseLines.length === 0) {
-    return null;
-  }
-  const oursPatches = diffPatch(baseLines, oursLines);
-  const theirsPatches = diffPatch(baseLines, theirsLines);
-  if (oursPatches.length === 0) return theirsLines;
-  if (theirsPatches.length === 0) return oursLines;
-  if (patchesOverlap(oursPatches, theirsPatches)) {
-    return null;
-  }
-  return applyBothPatches(baseLines, oursPatches, theirsPatches);
-}
-function patchesOverlap(oursPatches, theirsPatches) {
-  for (const op of oursPatches) {
-    const oStart = op.buffer1.offset;
-    const oEnd = oStart + op.buffer1.length;
-    for (const tp of theirsPatches) {
-      const tStart = tp.buffer1.offset;
-      const tEnd = tStart + tp.buffer1.length;
-      if (op.buffer1.length === 0 && tp.buffer1.length === 0 && oStart === tStart) {
-        return true;
+      const lock = this.lockManager.read();
+      const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+      const currentTreeHash = currentGen?.tree_hash ?? baseGen.tree_hash;
+      const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
+      const metadata = {
+        patchId: patch.id,
+        patchMessage: patch.original_message,
+        baseGeneration: patch.base_generation,
+        currentGeneration: lock.current_generation
+      };
+      let base = await this.git.showFile(baseGen.tree_hash, filePath);
+      let renameSourcePath;
+      if (!base) {
+        const renameSource = this.extractRenameSource(patch.patch_content, filePath);
+        if (renameSource) {
+          base = await this.git.showFile(baseGen.tree_hash, renameSource);
+          renameSourcePath = renameSource;
+        }
       }
-      if (tp.buffer1.length === 0 && tStart === oEnd) {
-        return true;
+      const oursPath = join2(this.outputDir, resolvedPath);
+      const ours = await readFile(oursPath, "utf-8").catch(() => null);
+      let ghostReconstructed = false;
+      let theirs = null;
+      if (!base && ours && !renameSourcePath) {
+        const treeReachable = await this.isTreeReachable(baseGen.tree_hash);
+        if (!treeReachable) {
+          const fileDiff = this.extractFileDiff(patch.patch_content, filePath);
+          if (fileDiff) {
+            const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
+            const result = reconstructFromGhostPatch2(fileDiff, ours);
+            if (result) {
+              base = result.base;
+              theirs = result.theirs;
+              ghostReconstructed = true;
+            }
+          }
+        }
       }
-      if (op.buffer1.length === 0 && oStart === tEnd) {
-        return true;
+      const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
+      const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
+      const useSnapshotAsPrimary = !fileIsShared && snapshotForFile != null;
+      if (!ghostReconstructed) {
+        if (useSnapshotAsPrimary) {
+          theirs = snapshotForFile;
+        } else {
+          theirs = await this.applyPatchToContent(
+            base,
+            patch.patch_content,
+            filePath,
+            tempGit,
+            tempDir,
+            renameSourcePath
+          );
+          const reconstructionHasMarkers = theirs != null && (theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization"));
+          const baseHadMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
+          if (reconstructionHasMarkers && !baseHadMarkers && snapshotForFile != null) {
+            theirs = snapshotForFile;
+          }
+        }
       }
-      if (oStart < tEnd && tStart < oEnd) {
-        return true;
+      const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
+      if (theirs) {
+        const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
+        const baseHasMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
+        if (theirsHasMarkers && !baseHasMarkers) {
+          if (accumulatorEntry) {
+            theirs = null;
+          } else {
+            return {
+              file: resolvedPath,
+              status: "skipped",
+              reason: "stale-conflict-markers"
+            };
+          }
+        }
       }
-    }
-  }
-  return false;
-}
-function applyBothPatches(baseLines, oursPatches, theirsPatches) {
-  const allPatches = [
-    ...oursPatches.map((p) => ({
-      offset: p.buffer1.offset,
-      length: p.buffer1.length,
-      replacement: p.buffer2.chunk
-    })),
-    ...theirsPatches.map((p) => ({
-      offset: p.buffer1.offset,
-      length: p.buffer1.length,
-      replacement: p.buffer2.chunk
-    }))
-  ];
-  allPatches.sort((a, b) => b.offset - a.offset);
-  const result = [...baseLines];
-  for (const p of allPatches) {
-    result.splice(p.offset, p.length, ...p.replacement);
-  }
-  return result;
-}
-
-// src/ReplayApplicator.ts
-import { mkdir, mkdtemp, readFile, rm, unlink, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { dirname as dirname2, extname, join as join2 } from "path";
-import { minimatch } from "minimatch";
-
-// src/conflict-utils.ts
-var CONFLICT_OPENER = "<<<<<<< Generated";
-var CONFLICT_SEPARATOR = "=======";
-var CONFLICT_CLOSER = ">>>>>>> Your customization";
-function trimCR(line) {
-  return line.endsWith("\r") ? line.slice(0, -1) : line;
-}
-function findConflictRanges(lines) {
-  const ranges = [];
-  let i = 0;
-  while (i < lines.length) {
-    if (trimCR(lines[i]) === CONFLICT_OPENER) {
-      let separatorIdx = -1;
-      let j = i + 1;
-      let found = false;
-      while (j < lines.length) {
-        const trimmed = trimCR(lines[j]);
-        if (trimmed === CONFLICT_OPENER) {
-          break;
+      let useAccumulatorAsMergeBase = false;
+      if (accumulatorEntry && (theirs == null || base == null)) {
+        theirs = await this.applyPatchToContent(
+          accumulatorEntry.content,
+          patch.patch_content,
+          filePath,
+          tempGit,
+          tempDir
+        );
+        if (theirs != null) {
+          useAccumulatorAsMergeBase = true;
+        } else if (await this.isPatchAlreadyApplied(
+          patch.patch_content,
+          filePath,
+          accumulatorEntry.content,
+          tempGit,
+          tempDir
+        )) {
+          theirs = accumulatorEntry.content;
+          useAccumulatorAsMergeBase = true;
         }
-        if (separatorIdx === -1 && trimmed === CONFLICT_SEPARATOR) {
-          separatorIdx = j;
-        } else if (separatorIdx !== -1 && trimmed === CONFLICT_CLOSER) {
-          ranges.push({ start: i, separator: separatorIdx, end: j });
-          i = j;
-          found = true;
-          break;
+      }
+      if (theirs) {
+        const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
+        const accBaseHasMarkers = accumulatorEntry != null && (accumulatorEntry.content.includes("<<<<<<< Generated") || accumulatorEntry.content.includes(">>>>>>> Your customization"));
+        if (theirsHasMarkers && !accBaseHasMarkers && !(base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization")))) {
+          return {
+            file: resolvedPath,
+            status: "skipped",
+            reason: "stale-conflict-markers"
+          };
         }
-        j++;
       }
-      if (!found) {
-        i++;
-        continue;
+      let effective_theirs = theirs;
+      let baseMismatchSkipped = false;
+      if (theirs != null && base != null && !useAccumulatorAsMergeBase) {
+        if (accumulatorEntry && accumulatorEntry.baseGeneration === patch.base_generation) {
+          try {
+            const preMerged = threeWayMerge(base, accumulatorEntry.content, theirs);
+            if (!preMerged.hasConflicts) {
+              effective_theirs = preMerged.content;
+            } else {
+              effective_theirs = theirs;
+            }
+          } catch {
+            effective_theirs = theirs;
+          }
+        } else if (accumulatorEntry) {
+          baseMismatchSkipped = true;
+        }
       }
-    }
-    i++;
-  }
-  return ranges;
-}
-function stripConflictMarkers(content) {
-  const lines = content.split(/\r?\n/);
-  const ranges = findConflictRanges(lines);
-  if (ranges.length === 0) {
-    return content;
-  }
-  const result = [];
-  let rangeIdx = 0;
-  for (let i = 0; i < lines.length; i++) {
-    if (rangeIdx < ranges.length) {
-      const range = ranges[rangeIdx];
-      if (i === range.start) {
-        continue;
+      if (base == null && ours == null && effective_theirs != null) {
+        this.fileTheirsAccumulator.set(resolvedPath, {
+          content: effective_theirs,
+          baseGeneration: patch.base_generation
+        });
+        const outDir2 = dirname2(oursPath);
+        await mkdir(outDir2, { recursive: true });
+        await writeFile(oursPath, effective_theirs);
+        return { file: resolvedPath, status: "merged", reason: "new-file" };
+      }
+      if (base == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
+        const merged2 = threeWayMerge("", ours, effective_theirs);
+        const outDir2 = dirname2(oursPath);
+        await mkdir(outDir2, { recursive: true });
+        await writeFile(oursPath, merged2.content);
+        if (merged2.hasConflicts) {
+          return {
+            file: resolvedPath,
+            status: "conflict",
+            conflicts: merged2.conflicts,
+            conflictReason: "new-file-both",
+            conflictMetadata: metadata
+          };
+        }
+        this.fileTheirsAccumulator.set(resolvedPath, {
+          content: merged2.content,
+          baseGeneration: patch.base_generation
+        });
+        return { file: resolvedPath, status: "merged" };
       }
-      if (i > range.start && i < range.separator) {
-        result.push(lines[i]);
-        continue;
+      if (effective_theirs == null) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
       }
-      if (i === range.separator) {
-        continue;
+      if (base == null && !useAccumulatorAsMergeBase || ours == null) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
       }
-      if (i > range.separator && i < range.end) {
-        continue;
+      const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
+      if (mergeBase == null) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
       }
-      if (i === range.end) {
-        rangeIdx++;
-        continue;
+      const merged = threeWayMerge(mergeBase, ours, effective_theirs);
+      const outDir = dirname2(oursPath);
+      await mkdir(outDir, { recursive: true });
+      await writeFile(oursPath, merged.content);
+      const populateAccumulator = effective_theirs != null && (!merged.hasConflicts || this.currentApplyMode === "resolve");
+      if (populateAccumulator) {
+        this.fileTheirsAccumulator.set(resolvedPath, {
+          content: effective_theirs,
+          baseGeneration: patch.base_generation
+        });
+      }
+      if (merged.hasConflicts) {
+        return {
+          file: resolvedPath,
+          status: "conflict",
+          conflicts: merged.conflicts,
+          conflictReason: baseMismatchSkipped ? "base-generation-mismatch" : "same-line-edit",
+          conflictMetadata: metadata
+        };
       }
-    }
-    result.push(lines[i]);
-  }
-  return result.join("\n");
-}
-
-// src/ReplayApplicator.ts
-var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".bmp",
-  ".ico",
-  ".webp",
-  ".svg",
-  ".pdf",
-  ".doc",
-  ".docx",
-  ".xls",
-  ".xlsx",
-  ".ppt",
-  ".pptx",
-  ".zip",
-  ".gz",
-  ".tar",
-  ".bz2",
-  ".7z",
-  ".rar",
-  ".jar",
-  ".war",
-  ".ear",
-  ".class",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".o",
-  ".a",
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".eot",
-  ".otf",
-  ".mp3",
-  ".mp4",
-  ".avi",
-  ".mov",
-  ".wav",
-  ".flac",
-  ".sqlite",
-  ".db",
-  ".pyc",
-  ".pyo",
-  ".DS_Store"
-]);
-var ReplayApplicator = class {
-  git;
-  lockManager;
-  outputDir;
-  renameCache = /* @__PURE__ */ new Map();
-  treeExistsCache = /* @__PURE__ */ new Map();
-  fileTheirsAccumulator = /* @__PURE__ */ new Map();
-  /**
-   * Apply mode for the current `applyPatches` invocation. Set at the start
-   * of `applyPatches`, read by `mergeFile` to decide:
-   *   - whether to skip the intra-loop marker strip (kept in `applyPatches`)
-   *   - whether to populate the accumulator after a conflicted merge
-   *     (resolve mode populates so subsequent patches on the same file
-   *     can use patch A's THEIRS as a structurally-correct merge base
-   *     when their diff was authored against post-A structure)
-   *   - whether to retry THEIRS reconstruction against the accumulator
-   *     when the BASE-relative reconstruction produced markers from a
-   *     cross-patch context mismatch
-   */
-  currentApplyMode = "replay";
-  constructor(git, lockManager, outputDir) {
-    this.git = git;
-    this.lockManager = lockManager;
-    this.outputDir = outputDir;
-  }
-  /**
-   * Resolve the GenerationRecord for a patch's base_generation.
-   * Falls back to constructing an ad-hoc record from the commit's tree
-   * when base_generation isn't a tracked generation (commit-scan patches).
-   */
-  async resolveBaseGeneration(baseGeneration) {
-    const gen = this.lockManager.getGeneration(baseGeneration);
-    if (gen) return gen;
-    try {
-      const treeHash = await this.git.getTreeHash(baseGeneration);
       return {
-        commit_sha: baseGeneration,
-        tree_hash: treeHash,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        cli_version: "unknown",
-        generator_versions: {}
+        file: resolvedPath,
+        status: "merged",
+        ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
+      };
+    } catch (error) {
+      return {
+        file: filePath,
+        status: "skipped",
+        reason: `error: ${error instanceof Error ? error.message : String(error)}`
       };
-    } catch {
-      return void 0;
     }
   }
-  /** Reset inter-patch accumulator for a new cycle. */
-  resetAccumulator() {
-    this.fileTheirsAccumulator.clear();
-  }
-  /**
-   * @internal Test-only.
-   * Returns a defensive copy of the inter-patch accumulator. Used by the
-   * adversarial test suite (FER-9791) to assert invariant I2: after every
-   * applied patch, the accumulator has an entry for each file the patch
-   * touched, and the entry's content matches on-disk.
-   */
-  getAccumulatorSnapshot() {
-    const snapshot = /* @__PURE__ */ new Map();
-    for (const [path, entry] of this.fileTheirsAccumulator) {
-      snapshot.set(path, { content: entry.content, baseGeneration: entry.baseGeneration });
+  async isTreeReachable(treeHash) {
+    let result = this.treeExistsCache.get(treeHash);
+    if (result === void 0) {
+      result = await this.git.treeExists(treeHash);
+      this.treeExistsCache.set(treeHash, result);
     }
-    return snapshot;
+    return result;
   }
-  /**
-   * Apply all patches, returning results for each.
-   * Skips patches that match exclude patterns in replay.yml
-   *
-   * `applyMode` controls the post-conflict marker strategy:
-   *   - `"replay"` (default): strip conflict markers from disk between
-   *     iterations whenever a later patch touches the same file. Lets the
-   *     follow-up patch's `git apply --3way` see clean OURS content,
-   *     which is what the silent-loss fix (PR #73) relies on. The replay
-   *     pipeline calls `revertConflictingFiles` after the loop to clean
-   *     any markers that survive.
-   *   - `"resolve"`: keep markers on disk. The resolve command needs the
-   *     customer to see them. Slow-path 3-way merge naturally preserves
-   *     A's markers and B's clean writes when their regions don't overlap;
-   *     when they do overlap, the customer gets nested markers and
-   *     resolves manually. Either way they aren't silently dropped.
-   */
-  async applyPatches(patches, opts) {
-    const applyMode = opts?.applyMode ?? "replay";
-    this.currentApplyMode = applyMode;
-    this.resetAccumulator();
-    const results = [];
-    for (let i = 0; i < patches.length; i++) {
-      const patch = patches[i];
-      if (this.isExcluded(patch)) {
-        results.push({
-          patch,
-          status: "skipped",
-          method: "git-am"
-        });
-        continue;
-      }
-      const result = await this.applyPatchWithFallback(patch);
-      results.push(result);
-      if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
-        const laterFiles = /* @__PURE__ */ new Set();
-        for (let j = i + 1; j < patches.length; j++) {
-          for (const f of patches[j].files) {
-            laterFiles.add(f);
-          }
-        }
-        const resolvedToOriginal = /* @__PURE__ */ new Map();
-        if (result.resolvedFiles) {
-          for (const [orig, resolved] of Object.entries(result.resolvedFiles)) {
-            resolvedToOriginal.set(resolved, orig);
+  isExcluded(patch) {
+    const config = this.lockManager.getCustomizationsConfig();
+    if (!config.exclude) return false;
+    return patch.files.some((file) => config.exclude.some((pattern) => minimatch(file, pattern)));
+  }
+  async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
+    const config = this.lockManager.getCustomizationsConfig();
+    if (config.moves) {
+      for (const move of config.moves) {
+        if (minimatch(filePath, move.from) || filePath === move.from) {
+          if (filePath === move.from) {
+            return move.to;
           }
-        }
-        for (const fileResult of result.fileResults) {
-          if (fileResult.status !== "conflict") continue;
-          const originalPath = resolvedToOriginal.get(fileResult.file) ?? fileResult.file;
-          if (laterFiles.has(fileResult.file) || laterFiles.has(originalPath)) {
-            const filePath = join2(this.outputDir, fileResult.file);
-            try {
-              const content = await readFile(filePath, "utf-8");
-              const stripped = stripConflictMarkers(content);
-              await writeFile(filePath, stripped);
-            } catch {
-            }
+          const fromBase = move.from.replace(/\*\*.*$/, "");
+          const toBase = move.to.replace(/\*\*.*$/, "");
+          if (filePath.startsWith(fromBase)) {
+            return toBase + filePath.slice(fromBase.length);
           }
         }
       }
     }
-    return results;
+    const cacheKey = `${baseTreeHash}:${currentTreeHash}`;
+    let renames = this.renameCache.get(cacheKey);
+    if (!renames) {
+      renames = await this.git.detectRenames(baseTreeHash, currentTreeHash);
+      this.renameCache.set(cacheKey, renames);
+    }
+    const gitRename = renames.find((r) => r.from === filePath);
+    if (gitRename) {
+      return gitRename.to;
+    }
+    return filePath;
+  }
+  async applyPatchToContent(base, patchContent, filePath, tempGit, tempDir, sourceFilePath) {
+    if (!base) {
+      return this.extractNewFileFromPatch(patchContent, filePath);
+    }
+    const fileDiff = this.extractFileDiff(patchContent, filePath);
+    if (!fileDiff) return null;
+    try {
+      if (sourceFilePath) {
+        const tempSourcePath = join2(tempDir, sourceFilePath);
+        await mkdir(dirname2(tempSourcePath), { recursive: true });
+        await writeFile(tempSourcePath, base);
+        await tempGit.exec(["add", sourceFilePath]);
+        await tempGit.exec([
+          "commit",
+          "-m",
+          `base for rename ${sourceFilePath} -> ${filePath}`,
+          "--allow-empty"
+        ]);
+        await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
+        const tempTargetPath = join2(tempDir, filePath);
+        return await readFile(tempTargetPath, "utf-8");
+      }
+      const tempFilePath = join2(tempDir, filePath);
+      await mkdir(dirname2(tempFilePath), { recursive: true });
+      await writeFile(tempFilePath, base);
+      await tempGit.exec(["add", filePath]);
+      await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
+      await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
+      return await readFile(tempFilePath, "utf-8");
+    } catch {
+      return null;
+    }
   }
   /**
-   * Populate accumulator after git apply succeeds, AND collect per-file
-   * results including any "dropped context lines" — lines that were
-   * present in BASE and THEIRS (unchanged context) but absent from the
-   * final on-disk state because OURS deleted them. This is the fast-path
-   * counterpart to ThreeWayMerge.computeDroppedContextLines used by the
-   * 3-way slow path; both must surface the same warning.
+   * Detects whether a patch's additions are already present in `content`.
+   * Uses `git apply --reverse --check` — if the reverse patch applies cleanly,
+   * the forward patch is effectively a no-op (its +lines are already there and
+   * its -lines are already gone). Used to distinguish "patch already applied"
+   * from "patch base mismatch" after a forward-apply fails.
    */
-  async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
-    const fileResults = [];
-    if (!baseGen) return fileResults;
-    const tempDir = await mkdtemp(join2(tmpdir(), "replay-acc-"));
-    const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
-    const tempGit = new GitClient2(tempDir);
-    await tempGit.exec(["init"]);
-    await tempGit.exec(["config", "user.email", "replay@fern.com"]);
-    await tempGit.exec(["config", "user.name", "Fern Replay"]);
+  async isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
+    const fileDiff = this.extractFileDiff(patchContent, filePath);
+    if (!fileDiff) return false;
     try {
-      for (const filePath of patch.files) {
-        if (isBinaryFile(filePath)) continue;
-        const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
-        const base = await this.git.showFile(baseGen.tree_hash, filePath);
-        const theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
-        const finalOnDisk = await readFile(join2(this.outputDir, resolvedPath), "utf-8").catch(() => null);
-        const effectiveTheirs = theirs ?? finalOnDisk;
-        if (effectiveTheirs != null) {
-          this.fileTheirsAccumulator.set(resolvedPath, {
-            content: effectiveTheirs,
-            baseGeneration: patch.base_generation
-          });
+      const tempFilePath = join2(tempDir, filePath);
+      await mkdir(dirname2(tempFilePath), { recursive: true });
+      await writeFile(tempFilePath, content);
+      await tempGit.exec(["add", filePath]);
+      await tempGit.exec(["commit", "-m", `check already-applied ${filePath}`, "--allow-empty"]);
+      await tempGit.execWithInput(["apply", "--reverse", "--check", "--allow-empty"], fileDiff);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  extractFileDiff(patchContent, filePath) {
+    const lines = patchContent.split("\n");
+    const diffLines = [];
+    let inTargetFile = false;
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        if (inTargetFile) {
+          break;
         }
-        if (base != null && effectiveTheirs != null && finalOnDisk != null) {
-          const dropped = computeDroppedContextLinesForFile(base, effectiveTheirs, finalOnDisk);
-          if (dropped.length > 0) {
-            fileResults.push({
-              file: resolvedPath,
-              status: "merged",
-              droppedContextLines: dropped
-            });
-          }
+        if (isDiffLineForFile(line, filePath)) {
+          inTargetFile = true;
+          diffLines.push(line);
         }
+        continue;
+      }
+      if (inTargetFile) {
+        diffLines.push(line);
       }
-    } finally {
-      await rm(tempDir, { recursive: true }).catch(() => {
-      });
     }
-    return fileResults;
+    return diffLines.length > 0 ? diffLines.join("\n") + "\n" : null;
   }
-  async applyPatchWithFallback(patch) {
-    const baseGen = await this.resolveBaseGeneration(patch.base_generation);
-    const lock = this.lockManager.read();
-    const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
-    const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
-    const needsAccumulation = await Promise.all(
-      patch.files.map(async (f) => {
-        if (!baseGen) return false;
-        const resolved = await this.resolveFilePath(f, baseGen.tree_hash, currentTreeHash);
-        return this.fileTheirsAccumulator.has(resolved);
-      })
-    ).then((results) => results.some(Boolean));
-    const resolvedFiles = {};
-    for (const filePath of patch.files) {
-      const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
-      if (resolvedPath !== filePath) {
-        resolvedFiles[filePath] = resolvedPath;
+  extractRenameSource(patchContent, targetFilePath) {
+    const lines = patchContent.split("\n");
+    let inTargetFile = false;
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        if (inTargetFile) break;
+        inTargetFile = isDiffLineForFile(line, targetFilePath);
+        continue;
+      }
+      if (!inTargetFile) continue;
+      if (line.startsWith("@@")) break;
+      if (line.startsWith("rename from ")) {
+        return line.slice("rename from ".length);
       }
     }
-    const patchIsRenameAware = /^rename from /m.test(patch.patch_content);
-    const hasGeneratorRename = Object.keys(resolvedFiles).length > 0 && !patchIsRenameAware;
-    if (!needsAccumulation && !hasGeneratorRename) {
-      const snapshots = /* @__PURE__ */ new Map();
-      for (const filePath of patch.files) {
-        const fullPath = join2(this.outputDir, filePath);
-        snapshots.set(filePath, await readFile(fullPath, "utf-8").catch(() => null));
+    return null;
+  }
+  extractNewFileFromPatch(patchContent, filePath) {
+    const lines = patchContent.split("\n");
+    const addedLines = [];
+    let inTargetFile = false;
+    let inHunk = false;
+    let isNewFile = false;
+    let noTrailingNewline = false;
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        if (inTargetFile) break;
+        inTargetFile = isDiffLineForFile(line, filePath);
+        inHunk = false;
+        isNewFile = false;
+        continue;
       }
-      try {
-        await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
-        const fastPathFileResults = await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
-        return {
-          patch,
-          status: "applied",
-          method: "git-am",
-          ...fastPathFileResults.length > 0 && { fileResults: fastPathFileResults },
-          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
-        };
-      } catch {
-        for (const [filePath, content] of snapshots) {
-          const fullPath = join2(this.outputDir, filePath);
-          if (content != null) {
-            await writeFile(fullPath, content);
-          } else {
-            await unlink(fullPath).catch(() => {
-            });
-          }
+      if (!inTargetFile) continue;
+      if (!inHunk) {
+        if (line === "--- /dev/null" || line.startsWith("new file mode")) {
+          isNewFile = true;
         }
       }
+      if (line.startsWith("@@")) {
+        if (!isNewFile) return null;
+        inHunk = true;
+        continue;
+      }
+      if (!inHunk) continue;
+      if (line === "\") {
+        noTrailingNewline = true;
+        continue;
+      }
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        addedLines.push(line.slice(1));
+      }
+    }
+    if (addedLines.length === 0) return null;
+    return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
+  }
+};
+function isBinaryFile(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+function computeDroppedContextLinesForFile(base, theirs, finalContent) {
+  const baseLines = base.split("\n");
+  const theirsLines = theirs.split("\n");
+  const finalLines = finalContent.split("\n");
+  const baseCounts = /* @__PURE__ */ new Map();
+  const theirsCounts = /* @__PURE__ */ new Map();
+  const finalCounts = /* @__PURE__ */ new Map();
+  for (const l of baseLines) baseCounts.set(l, (baseCounts.get(l) ?? 0) + 1);
+  for (const l of theirsLines) theirsCounts.set(l, (theirsCounts.get(l) ?? 0) + 1);
+  for (const l of finalLines) finalCounts.set(l, (finalCounts.get(l) ?? 0) + 1);
+  const dropped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of baseLines) {
+    if (seen.has(line)) continue;
+    const inBase = baseCounts.get(line) ?? 0;
+    const inTheirs = theirsCounts.get(line) ?? 0;
+    const inFinal = finalCounts.get(line) ?? 0;
+    if (inBase > 0 && inTheirs > 0 && inFinal < Math.min(inBase, inTheirs)) {
+      dropped.push(line);
+      seen.add(line);
+    }
+  }
+  return dropped;
+}
+function isDiffLineForFile(diffLine, filePath) {
+  const match = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
+  return match !== null && match[1] === filePath;
+}
+
+// src/ReplayDetector.ts
+var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
+function parsePatchFileHeaders(patchContent) {
+  const results = [];
+  let currentPath = null;
+  let currentIsCreate = false;
+  let currentIsDelete = false;
+  const flush = () => {
+    if (currentPath !== null) {
+      results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
+    }
+  };
+  for (const line of patchContent.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      currentPath = null;
+      currentIsCreate = false;
+      currentIsDelete = false;
+      const match = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+      if (match) {
+        currentPath = match[2] ?? null;
+      }
+    } else if (currentPath !== null) {
+      if (line.startsWith("new file mode ")) {
+        currentIsCreate = true;
+      } else if (line.startsWith("deleted file mode ")) {
+        currentIsDelete = true;
+      }
     }
-    return this.applyWithThreeWayMerge(patch);
   }
-  async applyWithThreeWayMerge(patch) {
-    const fileResults = [];
-    const resolvedFiles = {};
-    const tempDir = await mkdtemp(join2(tmpdir(), "replay-"));
-    const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
-    const tempGit = new GitClient2(tempDir);
-    await tempGit.exec(["init"]);
-    await tempGit.exec(["config", "user.email", "replay@fern.com"]);
-    await tempGit.exec(["config", "user.name", "Fern Replay"]);
-    try {
-      for (const filePath of patch.files) {
-        if (isBinaryFile(filePath)) {
-          fileResults.push({
-            file: filePath,
-            status: "skipped",
-            reason: "binary-file"
-          });
-          continue;
-        }
-        const result = await this.mergeFile(patch, filePath, tempGit, tempDir);
-        if (result.file !== filePath) {
-          resolvedFiles[filePath] = result.file;
-        }
-        fileResults.push(result);
-      }
-    } finally {
-      await rm(tempDir, { recursive: true }).catch(() => {
-      });
+  flush();
+  return results;
+}
+var ReplayDetector = class {
+  git;
+  lockManager;
+  sdkOutputDir;
+  warnings = [];
+  constructor(git, lockManager, sdkOutputDir) {
+    this.git = git;
+    this.lockManager = lockManager;
+    this.sdkOutputDir = sdkOutputDir;
+  }
+  async detectNewPatches() {
+    const lock = this.lockManager.read();
+    const lastGen = this.getLastGeneration(lock);
+    if (!lastGen) {
+      return { patches: [], revertedPatchIds: [] };
     }
-    const conflictFiles = fileResults.filter((r) => r.status === "conflict");
-    const hasConflicts = conflictFiles.length > 0;
-    const conflictReason = hasConflicts ? conflictFiles.some((f) => f.conflictReason === "base-generation-mismatch") ? "base-generation-mismatch" : conflictFiles[0]?.conflictReason : void 0;
-    return {
-      patch,
-      status: hasConflicts ? "conflict" : "applied",
-      method: "3way-merge",
-      fileResults,
-      conflictReason,
-      ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
-    };
+    const exists = await this.git.commitExists(lastGen.commit_sha);
+    if (!exists) {
+      this.warnings.push(
+        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
+      );
+      return this.detectPatchesViaTreeDiff(
+        lastGen,
+        /* commitKnownMissing */
+        true
+      );
+    }
+    const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
+    if (!isAncestor) {
+      return this.detectPatchesViaMergeBase(lastGen, lock);
+    }
+    return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
   }
-  async mergeFile(patch, filePath, tempGit, tempDir) {
+  /**
+   * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+   *
+   * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
+   * `[fern-generated]`) is orphaned but still in git's object database. The
+   * merge-base is the commit on main from which the bot's branch was created —
+   * a reachable ancestor of HEAD. Walking that range and classifying each
+   * commit via `isGenerationCommit` mirrors the linear path and eliminates
+   * the bug class where pipeline-driven changes (autoversion, replay,
+   * generation) get bundled as customer customizations.
+   *
+   * Falls through to the legacy composite path when no common ancestor exists
+   * (truly disjoint history — orphan branches with no shared root).
+   */
+  async detectPatchesViaMergeBase(lastGen, lock) {
+    let mergeBase = "";
     try {
-      const baseGen = await this.resolveBaseGeneration(patch.base_generation);
-      if (!baseGen) {
-        return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
-      }
-      const lock = this.lockManager.read();
-      const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
-      const currentTreeHash = currentGen?.tree_hash ?? baseGen.tree_hash;
-      const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
-      const metadata = {
-        patchId: patch.id,
-        patchMessage: patch.original_message,
-        baseGeneration: patch.base_generation,
-        currentGeneration: lock.current_generation
-      };
-      let base = await this.git.showFile(baseGen.tree_hash, filePath);
-      let renameSourcePath;
-      if (!base) {
-        const renameSource = this.extractRenameSource(patch.patch_content, filePath);
-        if (renameSource) {
-          base = await this.git.showFile(baseGen.tree_hash, renameSource);
-          renameSourcePath = renameSource;
-        }
-      }
-      const oursPath = join2(this.outputDir, resolvedPath);
-      const ours = await readFile(oursPath, "utf-8").catch(() => null);
-      let ghostReconstructed = false;
-      let theirs = null;
-      if (!base && ours && !renameSourcePath) {
-        const treeReachable = await this.isTreeReachable(baseGen.tree_hash);
-        if (!treeReachable) {
-          const fileDiff = this.extractFileDiff(patch.patch_content, filePath);
-          if (fileDiff) {
-            const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
-            const result = reconstructFromGhostPatch2(fileDiff, ours);
-            if (result) {
-              base = result.base;
-              theirs = result.theirs;
-              ghostReconstructed = true;
-            }
-          }
-        }
+      mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
+    } catch {
+    }
+    if (!mergeBase) {
+      this.warnings.push(
+        `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
+      );
+      return this.detectPatchesViaTreeDiff(
+        lastGen,
+        /* commitKnownMissing */
+        false
+      );
+    }
+    return this.detectPatchesInRange(mergeBase, lastGen, lock);
+  }
+  /**
+   * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
+   * `StoredPatch` per customer commit. Body shared by the linear path
+   * (rangeStart = lastGen.commit_sha) and the merge-base path.
+   *
+   * Patch `base_generation` is always `lastGen.commit_sha` — the
+   * lockfile-tracked reference the applicator uses to fetch base file
+   * content, regardless of where the walk actually started.
+   */
+  async detectPatchesInRange(rangeStart, lastGen, lock) {
+    const log = await this.git.exec([
+      "log",
+      "--first-parent",
+      "--format=%H%x00%an%x00%ae%x00%s",
+      `${rangeStart}..HEAD`,
+      "--",
+      this.sdkOutputDir
+    ]);
+    if (!log.trim()) {
+      return { patches: [], revertedPatchIds: [] };
+    }
+    const commits = this.parseGitLog(log);
+    const newPatches = [];
+    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+    for (const commit of commits) {
+      if (isGenerationCommit(commit)) {
+        continue;
       }
-      if (!ghostReconstructed) {
-        theirs = await this.applyPatchToContent(
-          base,
-          patch.patch_content,
-          filePath,
-          tempGit,
-          tempDir,
-          renameSourcePath
-        );
+      if (lock.patches.find((p) => p.original_commit === commit.sha)) {
+        continue;
       }
-      const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-      if (theirs) {
-        const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
-        const baseHasMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
-        if (theirsHasMarkers && !baseHasMarkers) {
-          if (accumulatorEntry) {
-            theirs = null;
-          } else {
-            return {
-              file: resolvedPath,
-              status: "skipped",
-              reason: "stale-conflict-markers"
-            };
-          }
+      const parents = await this.git.getCommitParents(commit.sha);
+      if (parents.length > 1) {
+        const compositePatch = await this.createMergeCompositePatch({
+          mergeCommit: commit,
+          firstParent: parents[0],
+          lastGen,
+          lock
+        });
+        if (compositePatch) {
+          newPatches.push(compositePatch);
         }
+        continue;
       }
-      let useAccumulatorAsMergeBase = false;
-      if (accumulatorEntry && (theirs == null || base == null)) {
-        theirs = await this.applyPatchToContent(
-          accumulatorEntry.content,
-          patch.patch_content,
-          filePath,
-          tempGit,
-          tempDir
+      let patchContent;
+      try {
+        patchContent = await this.git.formatPatch(commit.sha);
+      } catch {
+        this.warnings.push(
+          `Could not generate patch for commit ${commit.sha.slice(0, 7)} \u2014 it may be unreachable in a shallow clone. Skipping.`
         );
-        if (theirs != null) {
-          useAccumulatorAsMergeBase = true;
-        } else if (await this.isPatchAlreadyApplied(
-          patch.patch_content,
-          filePath,
-          accumulatorEntry.content,
-          tempGit,
-          tempDir
-        )) {
-          theirs = accumulatorEntry.content;
-          useAccumulatorAsMergeBase = true;
-        }
+        continue;
       }
-      if (theirs) {
-        const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
-        const accBaseHasMarkers = accumulatorEntry != null && (accumulatorEntry.content.includes("<<<<<<< Generated") || accumulatorEntry.content.includes(">>>>>>> Your customization"));
-        if (theirsHasMarkers && !accBaseHasMarkers && !(base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization")))) {
-          return {
-            file: resolvedPath,
-            status: "skipped",
-            reason: "stale-conflict-markers"
-          };
-        }
+      let contentHash = this.computeContentHash(patchContent);
+      if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
+        continue;
       }
-      let effective_theirs = theirs;
-      let baseMismatchSkipped = false;
-      if (theirs != null && base != null && !useAccumulatorAsMergeBase) {
-        if (accumulatorEntry && accumulatorEntry.baseGeneration === patch.base_generation) {
-          try {
-            const preMerged = threeWayMerge(base, accumulatorEntry.content, theirs);
-            if (!preMerged.hasConflicts) {
-              effective_theirs = preMerged.content;
-            } else {
-              effective_theirs = theirs;
+      const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
+      const allFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+      const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
+      const files = allFiles.filter((f) => !isSensitiveFile(f));
+      if (sensitiveFiles.length > 0) {
+        this.warnings.push(
+          `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
+        );
+        if (files.length > 0) {
+          const parentSha = parents[0];
+          if (parentSha) {
+            try {
+              patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
+            } catch {
+              continue;
             }
-          } catch {
-            effective_theirs = theirs;
+            if (!patchContent.trim()) continue;
+            contentHash = this.computeContentHash(patchContent);
           }
-        } else if (accumulatorEntry) {
-          baseMismatchSkipped = true;
         }
       }
-      if (base == null && ours == null && effective_theirs != null) {
-        this.fileTheirsAccumulator.set(resolvedPath, {
-          content: effective_theirs,
-          baseGeneration: patch.base_generation
-        });
-        const outDir2 = dirname2(oursPath);
-        await mkdir(outDir2, { recursive: true });
-        await writeFile(oursPath, effective_theirs);
-        return { file: resolvedPath, status: "merged", reason: "new-file" };
+      if (files.length === 0) {
+        continue;
       }
-      if (base == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
-        const merged2 = threeWayMerge("", ours, effective_theirs);
-        const outDir2 = dirname2(oursPath);
-        await mkdir(outDir2, { recursive: true });
-        await writeFile(oursPath, merged2.content);
-        if (merged2.hasConflicts) {
-          return {
-            file: resolvedPath,
-            status: "conflict",
-            conflicts: merged2.conflicts,
-            conflictReason: "new-file-both",
-            conflictMetadata: metadata
-          };
-        }
-        this.fileTheirsAccumulator.set(resolvedPath, {
-          content: merged2.content,
-          baseGeneration: patch.base_generation
-        });
-        return { file: resolvedPath, status: "merged" };
+      const theirsSnapshot = {};
+      for (const file of files) {
+        if (isBinaryFile(file)) continue;
+        const content = await this.git.showFile(commit.sha, file).catch(() => null);
+        if (content != null) theirsSnapshot[file] = content;
       }
-      if (effective_theirs == null) {
-        return {
-          file: resolvedPath,
-          status: "skipped",
-          reason: "missing-content"
-        };
+      newPatches.push({
+        id: `patch-${commit.sha.slice(0, 8)}`,
+        content_hash: contentHash,
+        original_commit: commit.sha,
+        original_message: commit.message,
+        original_author: `${commit.authorName} <${commit.authorEmail}>`,
+        base_generation: lastGen.commit_sha,
+        files,
+        patch_content: patchContent,
+        ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+        ...this.isCreationOnlyPatch(patchContent) ? { user_owned: true } : {}
+      });
+    }
+    const survivingPatches = await this.collapseNetZeroFiles(newPatches);
+    survivingPatches.reverse();
+    const revertedPatchIdSet = /* @__PURE__ */ new Set();
+    const revertIndicesToRemove = /* @__PURE__ */ new Set();
+    for (let i = 0; i < survivingPatches.length; i++) {
+      const patch = survivingPatches[i];
+      if (!isRevertCommit(patch.original_message)) continue;
+      let body = "";
+      try {
+        body = await this.git.getCommitBody(patch.original_commit);
+      } catch {
       }
-      if (base == null && !useAccumulatorAsMergeBase || ours == null) {
-        return {
-          file: resolvedPath,
-          status: "skipped",
-          reason: "missing-content"
-        };
+      const revertedSha = parseRevertedSha(body);
+      const revertedMessage = parseRevertedMessage(patch.original_message);
+      let matchedExisting = false;
+      if (revertedSha) {
+        const existing = lock.patches.find((p) => p.original_commit === revertedSha);
+        if (existing) {
+          revertedPatchIdSet.add(existing.id);
+          revertIndicesToRemove.add(i);
+          matchedExisting = true;
+        }
       }
-      const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
-      if (mergeBase == null) {
-        return {
-          file: resolvedPath,
-          status: "skipped",
-          reason: "missing-content"
-        };
+      if (!matchedExisting && revertedMessage) {
+        const existing = lock.patches.find((p) => p.original_message === revertedMessage);
+        if (existing) {
+          revertedPatchIdSet.add(existing.id);
+          revertIndicesToRemove.add(i);
+          matchedExisting = true;
+        }
       }
-      const merged = threeWayMerge(mergeBase, ours, effective_theirs);
-      const outDir = dirname2(oursPath);
-      await mkdir(outDir, { recursive: true });
-      await writeFile(oursPath, merged.content);
-      const populateAccumulator = effective_theirs != null && (!merged.hasConflicts || this.currentApplyMode === "resolve");
-      if (populateAccumulator) {
-        this.fileTheirsAccumulator.set(resolvedPath, {
-          content: effective_theirs,
-          baseGeneration: patch.base_generation
-        });
+      if (matchedExisting) continue;
+      let matchedNew = false;
+      if (revertedSha) {
+        const idx = survivingPatches.findIndex(
+          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_commit === revertedSha
+        );
+        if (idx !== -1) {
+          revertIndicesToRemove.add(i);
+          revertIndicesToRemove.add(idx);
+          matchedNew = true;
+        }
       }
-      if (merged.hasConflicts) {
-        return {
-          file: resolvedPath,
-          status: "conflict",
-          conflicts: merged.conflicts,
-          conflictReason: baseMismatchSkipped ? "base-generation-mismatch" : "same-line-edit",
-          conflictMetadata: metadata
-        };
+      if (!matchedNew && revertedMessage) {
+        const idx = survivingPatches.findIndex(
+          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_message === revertedMessage
+        );
+        if (idx !== -1) {
+          revertIndicesToRemove.add(i);
+          revertIndicesToRemove.add(idx);
+        }
+      }
+      if (!matchedExisting && !matchedNew) {
+        revertIndicesToRemove.add(i);
       }
-      return {
-        file: resolvedPath,
-        status: "merged",
-        ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
-      };
-    } catch (error) {
-      return {
-        file: filePath,
-        status: "skipped",
-        reason: `error: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  async isTreeReachable(treeHash) {
-    let result = this.treeExistsCache.get(treeHash);
-    if (result === void 0) {
-      result = await this.git.treeExists(treeHash);
-      this.treeExistsCache.set(treeHash, result);
     }
-    return result;
+    const filteredPatches = survivingPatches.filter((_, i) => !revertIndicesToRemove.has(i));
+    return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
   }
-  isExcluded(patch) {
-    const config = this.lockManager.getCustomizationsConfig();
-    if (!config.exclude) return false;
-    return patch.files.some((file) => config.exclude.some((pattern) => minimatch(file, pattern)));
+  /**
+   * Compute content hash for deduplication.
+   *
+   * Produces a format-agnostic hash so both `git format-patch` output
+   * (email-wrapped) and plain `git diff` output hash to the same value
+   * when the underlying diff hunks are identical.
+   *
+   * Normalization:
+   *   1. Strip email wrapper: everything before the first `diff --git` line
+   *      (From:, Subject:, Date:, diffstat, blank separators).
+   *   2. Strip `index` lines (blob SHA pairs change across rebases).
+   *   3. Strip trailing git version marker (`-- \n<version>`).
+   *
+   * This ensures content hashes match across the no-patches and normal-
+   * regeneration flows, which store formatPatch and git-diff formats
+   * respectively (FER-9850, D5-D9).
+   */
+  computeContentHash(patchContent) {
+    const lines = patchContent.split("\n");
+    const diffStart = lines.findIndex((l) => l.startsWith("diff --git "));
+    const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
+    const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
+    return `sha256:${createHash("sha256").update(normalized).digest("hex")}`;
   }
-  async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
-    const config = this.lockManager.getCustomizationsConfig();
-    if (config.moves) {
-      for (const move of config.moves) {
-        if (minimatch(filePath, move.from) || filePath === move.from) {
-          if (filePath === move.from) {
-            return move.to;
-          }
-          const fromBase = move.from.replace(/\*\*.*$/, "");
-          const toBase = move.to.replace(/\*\*.*$/, "");
-          if (filePath.startsWith(fromBase)) {
-            return toBase + filePath.slice(fromBase.length);
-          }
-        }
+  /**
+   * FER-9805 — Drop patches whose files were transiently created and then
+   * deleted within the current linear detection window, and are absent from
+   * HEAD at the end of the window.
+   *
+   * Rationale: on a merge commit, createMergeCompositePatch already diffs
+   * firstParent..mergeCommit so net-zero files never enter the composite. On
+   * linear history each commit becomes its own patch, so a file that was
+   * briefly added and later removed survives as a create+delete pair whose
+   * cumulative diff is empty. We drop such patches before they reach the
+   * lockfile.
+   *
+   * A file is "transient" when:
+   *   1. some patch in the window sets `new file mode` for it (a creation), AND
+   *   2. some patch in the window sets `deleted file mode` for it (a deletion), AND
+   *   3. it is absent from HEAD's tree.
+   *
+   * The HEAD guard (#3) prevents false positives when a file is deleted
+   * and then recreated with different content — the cumulative diff of
+   * such a pair is non-empty and must be preserved.
+   *
+   * This only drops patches whose `files` are a subset of the transient
+   * set. A partial-transient patch (one that touches a transient file
+   * alongside a persistent one) is left unmodified; surgical stripping of
+   * single files from a multi-file patch would require a follow-up that
+   * regenerates the patch content via `git format-patch -- <files>`. No
+   * current failing test exercises this, and leaving the patch intact
+   * preserves today's behaviour. TODO(FER-9805): revisit if a future
+   * adversarial test demands per-file stripping.
+   */
+  async collapseNetZeroFiles(patches) {
+    if (patches.length === 0) return patches;
+    const stateByFile = /* @__PURE__ */ new Map();
+    for (const patch of patches) {
+      for (const header of parsePatchFileHeaders(patch.patch_content)) {
+        if (!header.isCreate && !header.isDelete) continue;
+        const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
+        if (header.isCreate) prior.created = true;
+        if (header.isDelete) prior.deleted = true;
+        stateByFile.set(header.path, prior);
       }
     }
-    const cacheKey = `${baseTreeHash}:${currentTreeHash}`;
-    let renames = this.renameCache.get(cacheKey);
-    if (!renames) {
-      renames = await this.git.detectRenames(baseTreeHash, currentTreeHash);
-      this.renameCache.set(cacheKey, renames);
+    let anyCandidate = false;
+    for (const state of stateByFile.values()) {
+      if (state.created && state.deleted) {
+        anyCandidate = true;
+        break;
+      }
     }
-    const gitRename = renames.find((r) => r.from === filePath);
-    if (gitRename) {
-      return gitRename.to;
+    if (!anyCandidate) return patches;
+    const headFiles = await this.listHeadFiles();
+    const transient = /* @__PURE__ */ new Set();
+    for (const [file, state] of stateByFile) {
+      if (state.created && state.deleted && !headFiles.has(file)) {
+        transient.add(file);
+      }
     }
-    return filePath;
+    if (transient.size === 0) return patches;
+    return patches.filter((patch) => !patch.files.every((f) => transient.has(f)));
   }
-  async applyPatchToContent(base, patchContent, filePath, tempGit, tempDir, sourceFilePath) {
-    if (!base) {
-      return this.extractNewFileFromPatch(patchContent, filePath);
-    }
-    const fileDiff = this.extractFileDiff(patchContent, filePath);
-    if (!fileDiff) return null;
+  /**
+   * List every tracked path at HEAD (one `git ls-tree -r` invocation).
+   * Returns an empty Set if HEAD is unborn or the invocation fails — the
+   * caller then treats every candidate as "not in HEAD" and may collapse
+   * more aggressively. On typical SDK repos this is a single sub-10ms call.
+   */
+  async listHeadFiles() {
     try {
-      if (sourceFilePath) {
-        const tempSourcePath = join2(tempDir, sourceFilePath);
-        await mkdir(dirname2(tempSourcePath), { recursive: true });
-        await writeFile(tempSourcePath, base);
-        await tempGit.exec(["add", sourceFilePath]);
-        await tempGit.exec([
-          "commit",
-          "-m",
-          `base for rename ${sourceFilePath} -> ${filePath}`,
-          "--allow-empty"
-        ]);
-        await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-        const tempTargetPath = join2(tempDir, filePath);
-        return await readFile(tempTargetPath, "utf-8");
-      }
-      const tempFilePath = join2(tempDir, filePath);
-      await mkdir(dirname2(tempFilePath), { recursive: true });
-      await writeFile(tempFilePath, base);
-      await tempGit.exec(["add", filePath]);
-      await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
-      await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-      return await readFile(tempFilePath, "utf-8");
+      const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
+      return new Set(out.split("\n").map((l) => l.trim()).filter(Boolean));
     } catch {
-      return null;
+      return /* @__PURE__ */ new Set();
     }
   }
   /**
-   * Detects whether a patch's additions are already present in `content`.
-   * Uses `git apply --reverse --check` — if the reverse patch applies cleanly,
-   * the forward patch is effectively a no-op (its +lines are already there and
-   * its -lines are already gone). Used to distinguish "patch already applied"
-   * from "patch base mismatch" after a forward-apply fails.
+   * Create a single composite patch for a merge commit by diffing the merge
+   * commit against its first parent. This captures the net change of the
+   * entire merged branch as one patch, eliminating accumulator chaining and
+   * zero-net-change ghost conflicts.
    */
-  async isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
-    const fileDiff = this.extractFileDiff(patchContent, filePath);
-    if (!fileDiff) return false;
-    try {
-      const tempFilePath = join2(tempDir, filePath);
-      await mkdir(dirname2(tempFilePath), { recursive: true });
-      await writeFile(tempFilePath, content);
-      await tempGit.exec(["add", filePath]);
-      await tempGit.exec(["commit", "-m", `check already-applied ${filePath}`, "--allow-empty"]);
-      await tempGit.execWithInput(["apply", "--reverse", "--check", "--allow-empty"], fileDiff);
-      return true;
-    } catch {
-      return false;
+  async createMergeCompositePatch(input) {
+    const { mergeCommit, firstParent, lastGen, lock } = input;
+    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+    const filesOutput = await this.git.exec([
+      "diff",
+      "--name-only",
+      firstParent,
+      mergeCommit.sha
+    ]);
+    const allMergeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+    const sensitiveMergeFiles = allMergeFiles.filter((f) => isSensitiveFile(f));
+    const files = allMergeFiles.filter((f) => !isSensitiveFile(f));
+    if (sensitiveMergeFiles.length > 0) {
+      this.warnings.push(
+        `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveMergeFiles.join(", ")}. These files will not be tracked by replay.`
+      );
+    }
+    if (files.length === 0) return null;
+    const diff = await this.git.exec([
+      "diff",
+      firstParent,
+      mergeCommit.sha,
+      "--",
+      ...files
+    ]);
+    if (!diff.trim()) return null;
+    const contentHash = this.computeContentHash(diff);
+    if (lock.patches.some((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
+      return null;
+    }
+    const theirsSnapshot = {};
+    for (const file of files) {
+      if (isBinaryFile(file)) continue;
+      const content = await this.git.showFile(mergeCommit.sha, file).catch(() => null);
+      if (content != null) theirsSnapshot[file] = content;
     }
+    return {
+      id: `patch-merge-${mergeCommit.sha.slice(0, 8)}`,
+      content_hash: contentHash,
+      original_commit: mergeCommit.sha,
+      original_message: mergeCommit.message,
+      original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
+      base_generation: lastGen.commit_sha,
+      files,
+      patch_content: diff,
+      ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+      ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
+    };
   }
-  extractFileDiff(patchContent, filePath) {
-    const lines = patchContent.split("\n");
-    const diffLines = [];
-    let inTargetFile = false;
-    for (const line of lines) {
-      if (line.startsWith("diff --git")) {
-        if (inTargetFile) {
-          break;
-        }
-        if (isDiffLineForFile(line, filePath)) {
-          inTargetFile = true;
-          diffLines.push(line);
-        }
-        continue;
-      }
-      if (inTargetFile) {
-        diffLines.push(line);
-      }
+  /**
+   * Detect patches via tree diff for non-linear history. Returns a composite patch.
+   * Revert reconciliation is skipped here because tree-diff produces a single composite
+   * patch from the aggregate diff — individual revert commits are not distinguishable.
+   */
+  async detectPatchesViaTreeDiff(lastGen, commitKnownMissing) {
+    const diffBase = await this.resolveDiffBase(lastGen, commitKnownMissing);
+    if (!diffBase) {
+      return this.detectPatchesViaCommitScan();
     }
-    return diffLines.length > 0 ? diffLines.join("\n") + "\n" : null;
+    const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
+    const allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+    const sensitiveTreeFiles = allTreeFiles.filter((f) => isSensitiveFile(f));
+    const files = allTreeFiles.filter((f) => !isSensitiveFile(f));
+    if (sensitiveTreeFiles.length > 0) {
+      this.warnings.push(
+        `Sensitive file(s) excluded from composite patch: ${sensitiveTreeFiles.join(", ")}. These files will not be tracked by replay.`
+      );
+    }
+    if (files.length === 0) return { patches: [], revertedPatchIds: [] };
+    const diff = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
+    if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
+    const contentHash = this.computeContentHash(diff);
+    const lock = this.lockManager.read();
+    if (lock.patches.some((p) => p.content_hash === contentHash) || (lock.forgotten_hashes ?? []).includes(contentHash)) {
+      return { patches: [], revertedPatchIds: [] };
+    }
+    const headSha = (await this.git.exec(["rev-parse", "HEAD"])).trim();
+    const theirsSnapshot = {};
+    for (const file of files) {
+      if (isBinaryFile(file)) continue;
+      const content = await this.git.showFile("HEAD", file).catch(() => null);
+      if (content != null) theirsSnapshot[file] = content;
+    }
+    const compositePatch = {
+      id: `patch-composite-${headSha.slice(0, 8)}`,
+      content_hash: contentHash,
+      original_commit: headSha,
+      original_message: "Customer customizations (composite)",
+      original_author: "composite",
+      // Use diffBase when commit is unreachable — the applicator needs a reachable
+      // reference to find base file content. diffBase may be the tree_hash.
+      base_generation: commitKnownMissing ? diffBase : lastGen.commit_sha,
+      files,
+      patch_content: diff,
+      ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+      ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
+    };
+    return { patches: [compositePatch], revertedPatchIds: [] };
   }
-  extractRenameSource(patchContent, targetFilePath) {
-    const lines = patchContent.split("\n");
-    let inTargetFile = false;
-    for (const line of lines) {
-      if (line.startsWith("diff --git")) {
-        if (inTargetFile) break;
-        inTargetFile = isDiffLineForFile(line, targetFilePath);
+  /**
+   * Last-resort detection when both generation commit and tree are unreachable.
+   * Scans all commits from HEAD, filters against known lockfile patches, and
+   * skips creation-only commits (squashed history after force push).
+   *
+   * Detected patches use the commit's parent as base_generation so the applicator
+   * can find base file content from the parent's tree (which IS reachable).
+   */
+  async detectPatchesViaCommitScan() {
+    const lock = this.lockManager.read();
+    const log = await this.git.exec([
+      "log",
+      "--max-count=200",
+      "--format=%H%x00%an%x00%ae%x00%s",
+      "HEAD",
+      "--",
+      this.sdkOutputDir
+    ]);
+    if (!log.trim()) {
+      return { patches: [], revertedPatchIds: [] };
+    }
+    const commits = this.parseGitLog(log);
+    const newPatches = [];
+    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+    const existingHashes = new Set(lock.patches.map((p) => p.content_hash));
+    const existingCommits = new Set(lock.patches.map((p) => p.original_commit));
+    for (const commit of commits) {
+      if (isGenerationCommit(commit)) {
         continue;
       }
-      if (!inTargetFile) continue;
-      if (line.startsWith("@@")) break;
-      if (line.startsWith("rename from ")) {
-        return line.slice("rename from ".length);
-      }
-    }
-    return null;
-  }
-  extractNewFileFromPatch(patchContent, filePath) {
-    const lines = patchContent.split("\n");
-    const addedLines = [];
-    let inTargetFile = false;
-    let inHunk = false;
-    let isNewFile = false;
-    let noTrailingNewline = false;
-    for (const line of lines) {
-      if (line.startsWith("diff --git")) {
-        if (inTargetFile) break;
-        inTargetFile = isDiffLineForFile(line, filePath);
-        inHunk = false;
-        isNewFile = false;
+      const parents = await this.git.getCommitParents(commit.sha);
+      if (parents.length > 1) {
         continue;
       }
-      if (!inTargetFile) continue;
-      if (!inHunk) {
-        if (line === "--- /dev/null" || line.startsWith("new file mode")) {
-          isNewFile = true;
+      if (existingCommits.has(commit.sha)) {
+        continue;
+      }
+      let patchContent;
+      try {
+        patchContent = await this.git.formatPatch(commit.sha);
+      } catch {
+        continue;
+      }
+      let contentHash = this.computeContentHash(patchContent);
+      if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
+        continue;
+      }
+      if (this.isCreationOnlyPatch(patchContent)) {
+        continue;
+      }
+      const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
+      const allScanFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f));
+      const sensitiveScanFiles = allScanFiles.filter((f) => isSensitiveFile(f));
+      const files = allScanFiles.filter((f) => !isSensitiveFile(f));
+      if (sensitiveScanFiles.length > 0) {
+        this.warnings.push(
+          `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveScanFiles.join(", ")}. These files will not be tracked by replay.`
+        );
+        if (files.length > 0) {
+          if (parents.length === 0) {
+            continue;
+          }
+          try {
+            patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
+          } catch {
+            continue;
+          }
+          if (!patchContent.trim()) continue;
+          contentHash = this.computeContentHash(patchContent);
         }
       }
-      if (line.startsWith("@@")) {
-        if (!isNewFile) return null;
-        inHunk = true;
+      if (files.length === 0) {
         continue;
       }
-      if (!inHunk) continue;
-      if (line === "\") {
-        noTrailingNewline = true;
+      if (parents.length === 0) {
         continue;
       }
-      if (line.startsWith("+") && !line.startsWith("+++")) {
-        addedLines.push(line.slice(1));
+      const parentSha = parents[0];
+      const theirsSnapshot = {};
+      for (const file of files) {
+        if (isBinaryFile(file)) continue;
+        const content = await this.git.showFile(commit.sha, file).catch(() => null);
+        if (content != null) theirsSnapshot[file] = content;
       }
+      newPatches.push({
+        id: `patch-${commit.sha.slice(0, 8)}`,
+        content_hash: contentHash,
+        original_commit: commit.sha,
+        original_message: commit.message,
+        original_author: `${commit.authorName} <${commit.authorEmail}>`,
+        base_generation: parentSha,
+        files,
+        patch_content: patchContent,
+        ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
+      });
     }
-    if (addedLines.length === 0) return null;
-    return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
+    newPatches.reverse();
+    return { patches: newPatches, revertedPatchIds: [] };
   }
-};
-function isBinaryFile(filePath) {
-  const ext = extname(filePath).toLowerCase();
-  return BINARY_EXTENSIONS.has(ext);
-}
-function computeDroppedContextLinesForFile(base, theirs, finalContent) {
-  const baseLines = base.split("\n");
-  const theirsLines = theirs.split("\n");
-  const finalLines = finalContent.split("\n");
-  const baseCounts = /* @__PURE__ */ new Map();
-  const theirsCounts = /* @__PURE__ */ new Map();
-  const finalCounts = /* @__PURE__ */ new Map();
-  for (const l of baseLines) baseCounts.set(l, (baseCounts.get(l) ?? 0) + 1);
-  for (const l of theirsLines) theirsCounts.set(l, (theirsCounts.get(l) ?? 0) + 1);
-  for (const l of finalLines) finalCounts.set(l, (finalCounts.get(l) ?? 0) + 1);
-  const dropped = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const line of baseLines) {
-    if (seen.has(line)) continue;
-    const inBase = baseCounts.get(line) ?? 0;
-    const inTheirs = theirsCounts.get(line) ?? 0;
-    const inFinal = finalCounts.get(line) ?? 0;
-    if (inBase > 0 && inTheirs > 0 && inFinal < Math.min(inBase, inTheirs)) {
-      dropped.push(line);
-      seen.add(line);
+  /**
+   * Check if a format-patch consists entirely of new-file creations.
+   * Used to identify squashed commits after force push, which create all files
+   * from scratch (--- /dev/null) rather than modifying existing files.
+   */
+  isCreationOnlyPatch(patchContent) {
+    const diffOldHeaders = patchContent.split("\n").filter((l) => l.startsWith("--- "));
+    if (diffOldHeaders.length === 0) {
+      return false;
     }
+    return diffOldHeaders.every((l) => l === "--- /dev/null");
   }
-  return dropped;
-}
-function isDiffLineForFile(diffLine, filePath) {
-  const match = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
-  return match !== null && match[1] === filePath;
-}
+  /**
+   * Resolve the best available diff base for a generation record.
+   * Prefers commit_sha, falls back to tree_hash for unreachable commits.
+   * When commitKnownMissing is true, skips the redundant commitExists check.
+   */
+  async resolveDiffBase(gen, commitKnownMissing) {
+    if (!commitKnownMissing && await this.git.commitExists(gen.commit_sha)) {
+      return gen.commit_sha;
+    }
+    if (await this.git.treeExists(gen.tree_hash)) {
+      return gen.tree_hash;
+    }
+    return null;
+  }
+  parseGitLog(log) {
+    return log.trim().split("\n").map((line) => {
+      const [sha, authorName, authorEmail, message] = line.split("\0");
+      return { sha, authorName, authorEmail, message };
+    });
+  }
+  getLastGeneration(lock) {
+    return lock.generations.find((g) => g.commit_sha === lock.current_generation);
+  }
+};
 
 // src/ReplayCommitter.ts
 var ReplayCommitter = class {
@@ -2267,7 +2407,8 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
 
 // src/ReplayService.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { readFile as readFileAsync } from "fs/promises";
+import { join as join5 } from "path";
 import { minimatch as minimatch2 } from "minimatch";
 init_GitClient();
 
@@ -2326,13 +2467,13 @@ async function computePerPatchDiff(patch, getCurrentGenContent, getWorkingTreeCo
     const hunksRaw = parseHunks(fileDiff).map(normalizeHunkBody);
     const hunks = hunksRaw.filter((h) => {
       if (h.lines.length === 0) return false;
-      let ctx = 0, rm3 = 0, add = 0;
+      let ctx = 0, rm4 = 0, add = 0;
       for (const ln of h.lines) {
         if (ln.type === "context") ctx++;
-        else if (ln.type === "remove") rm3++;
+        else if (ln.type === "remove") rm4++;
         else if (ln.type === "add") add++;
       }
-      return ctx + rm3 === h.oldCount && ctx + add === h.newCount;
+      return ctx + rm4 === h.oldCount && ctx + add === h.newCount;
     });
     if (hunks.length === 0) {
       if (hunksRaw.length > 0) unlocatableFiles.push(file);
@@ -3042,19 +3183,14 @@ var ReplayService = class {
     existingPatches = this.lockManager.getPatches();
     const seenHashes = /* @__PURE__ */ new Map();
     for (const p of existingPatches) {
-      const priorOrigin = seenHashes.get(p.content_hash);
-      if (priorOrigin !== void 0) {
-        const provenanceMissing = !priorOrigin || !p.original_commit;
-        const sameOrigin = priorOrigin === p.original_commit;
-        if (sameOrigin && !provenanceMissing) {
-          this.lockManager.removePatch(p.id);
-        } else {
-          this.warnings.push(
-            `Preserving patch ${p.id} (commit ${(p.original_commit || "<missing>").slice(0, 7)}): shares content_hash with a prior patch ${provenanceMissing ? "(provenance missing on at least one side)" : "from a different source commit"}. Both retained to avoid silent customization loss (FER-9983).`
-          );
-        }
+      const priorPatchId = seenHashes.get(p.content_hash);
+      if (priorPatchId !== void 0) {
+        this.lockManager.removePatch(p.id);
+        this.warnings.push(
+          `Consolidated patch ${p.id} (commit ${(p.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content. Per-commit attribution preserved in git log; lockfile collapsed to avoid duplicate-apply corruption on next regen.`
+        );
       } else {
-        seenHashes.set(p.content_hash, p.original_commit);
+        seenHashes.set(p.content_hash, p.id);
       }
     }
     existingPatches = this.lockManager.getPatches();
@@ -3235,17 +3371,27 @@ var ReplayService = class {
         if (allUserOwned && patch.files.length > 0) {
           const baseChanged = patch.base_generation !== currentGenSha;
           const userDiff = await this.git.exec(["diff", currentGenSha, "--", ...patch.files]).catch(() => null);
+          let userDiffSnapshot = null;
           if (userDiff != null && userDiff.trim()) {
             const newHash = this.detector.computeContentHash(userDiff);
             patch.patch_content = userDiff;
             patch.content_hash = newHash;
+            const snap = await this.readSnapshotFromDisk(patch.files);
+            if (Object.keys(snap).length > 0) {
+              userDiffSnapshot = snap;
+              patch.theirs_snapshot = snap;
+            }
           }
           patch.base_generation = currentGenSha;
           try {
             this.lockManager.updatePatch(patch.id, {
               base_generation: currentGenSha,
               ...!patch.user_owned ? { user_owned: true } : {},
-              ...userDiff != null && userDiff.trim() ? { patch_content: patch.patch_content, content_hash: patch.content_hash } : {}
+              ...userDiff != null && userDiff.trim() ? {
+                patch_content: patch.patch_content,
+                content_hash: patch.content_hash,
+                ...userDiffSnapshot != null && Object.keys(userDiffSnapshot).length > 0 ? { theirs_snapshot: userDiffSnapshot } : {}
+              } : {}
             });
           } catch {
           }
@@ -3293,30 +3439,34 @@ var ReplayService = class {
           continue;
         }
         const newContentHash = this.detector.computeContentHash(diff);
-        const priorOrigin = seenContentHashes.get(newContentHash);
-        if (priorOrigin !== void 0) {
-          const provenanceMissing = !priorOrigin || !patch.original_commit;
-          const sameOrigin = priorOrigin === patch.original_commit;
-          if (sameOrigin && !provenanceMissing) {
-            this.lockManager.removePatch(patch.id);
-            absorbedPatchIds.add(patch.id);
-            absorbed++;
-            continue;
+        const priorPatchId = seenContentHashes.get(newContentHash);
+        if (priorPatchId !== void 0) {
+          this.lockManager.removePatch(patch.id);
+          absorbedPatchIds.add(patch.id);
+          absorbed++;
+          if (priorPatchId !== patch.id) {
+            this.warnings.push(
+              `Consolidated patch ${patch.id} (commit ${(patch.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content after rebase. Per-commit attribution preserved in git log.`
+            );
           }
-          this.warnings.push(
-            `Preserving patch ${patch.id} (commit ${(patch.original_commit || "<missing>").slice(0, 7)}): shares content_hash with a prior patch ${provenanceMissing ? "(provenance missing on at least one side)" : "from a different source commit"}. Both retained to avoid silent customization loss (FER-9983).`
-          );
+          continue;
         } else {
-          seenContentHashes.set(newContentHash, patch.original_commit);
+          seenContentHashes.set(newContentHash, patch.id);
         }
         patch.base_generation = currentGenSha;
         patch.patch_content = diff;
         patch.content_hash = newContentHash;
+        const snapshot = await this.readSnapshotFromDisk(patch.files);
+        const snapshotIsNonEmpty = Object.keys(snapshot).length > 0;
+        if (snapshotIsNonEmpty) {
+          patch.theirs_snapshot = snapshot;
+        }
         try {
           this.lockManager.updatePatch(patch.id, {
             base_generation: currentGenSha,
             patch_content: diff,
-            content_hash: newContentHash
+            content_hash: newContentHash,
+            ...snapshotIsNonEmpty ? { theirs_snapshot: snapshot } : {}
           });
         } catch {
         }
@@ -3326,6 +3476,172 @@ var ReplayService = class {
     }
     return { absorbed, repointed, contentRebased, keptAsUserOwned, absorbedPatchIds };
   }
+  /**
+   * Read THEIRS snapshot (post-customer-edit content) for a list of files
+   * from the working tree on disk. Used by `rebasePatches` after a clean
+   * apply — disk = correctly-merged customer state at the new generation.
+   * Skips binary files (matches `mergeFile`/`populateAccumulatorForPatch`
+   * policy — binary content as `utf-8` is lossy and snapshots of it would
+   * never be used during apply anyway).
+   */
+  async readSnapshotFromDisk(files) {
+    const snapshot = {};
+    for (const file of files) {
+      if (isBinaryFile(file)) continue;
+      try {
+        const content = await readFileAsync(join5(this.outputDir, file), "utf-8");
+        snapshot[file] = content;
+      } catch {
+      }
+    }
+    return snapshot;
+  }
+  /**
+   * FER-10203: returns true when a `[fern-autoversion]` commit between
+   * `fromSha` and `toSha` touched any of the patch's `files`. Re-classifies
+   * each grep match via `isGenerationCommit` so a customer commit that
+   * merely quotes the marker in its body doesn't false-positive.
+   */
+  async hasAutoversionContamination(fromSha, toSha, files) {
+    if (files.length === 0) return false;
+    const log = await this.git.exec([
+      "log",
+      `${fromSha}..${toSha}`,
+      "--grep=\\[fern-autoversion\\]",
+      "--extended-regexp",
+      "--format=%H%x09%aN%x09%ae%x09%s",
+      "--",
+      ...files
+    ]).catch(() => "");
+    if (!log.trim()) return false;
+    for (const line of log.trim().split("\n")) {
+      const [sha, authorName, authorEmail, message] = line.split("	");
+      if (sha == null) continue;
+      if (isGenerationCommit({
+        sha,
+        authorName: authorName ?? "",
+        authorEmail: authorEmail ?? "",
+        message: message ?? ""
+      })) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * FER-10203: rebuild patch_content from `theirs_snapshot` (captured at
+   * detection time, predates pipeline content) rather than a HEAD-relative
+   * diff. Returns `null` when snapshot is missing or doesn't cover every
+   * file in `patch.files` — caller leaves the patch unchanged.
+   */
+  async computeSnapshotBasedPatchDiff(patch, currentGen) {
+    if (!patch.theirs_snapshot) return null;
+    if (Object.keys(patch.theirs_snapshot).length === 0) return null;
+    for (const file of patch.files) {
+      if (patch.theirs_snapshot[file] == null) return null;
+    }
+    const fragments = [];
+    for (const file of patch.files) {
+      const theirsContent = patch.theirs_snapshot[file];
+      const oursContent = await this.git.showFile(currentGen, file).catch(() => null);
+      if (oursContent == null) {
+        fragments.push(synthesizeNewFileDiff(file, theirsContent));
+        continue;
+      }
+      if (oursContent === theirsContent) continue;
+      const fileDiff = await unifiedDiff(oursContent, theirsContent, file);
+      if (fileDiff.trim()) {
+        fragments.push(fileDiff);
+      }
+    }
+    return fragments.join("");
+  }
+  /**
+   * Read THEIRS snapshot from a git tree-ish (commit, branch, or tree).
+   * Used when the diff that produced `patch_content` was relative to that
+   * tree (e.g., `git diff currentGen HEAD --` → snapshot from HEAD).
+   * Skips binary files.
+   */
+  async readSnapshotFromTree(treeRef, files) {
+    const snapshot = {};
+    for (const file of files) {
+      if (isBinaryFile(file)) continue;
+      const content = await this.git.showFile(treeRef, file).catch(() => null);
+      if (content != null) snapshot[file] = content;
+    }
+    return snapshot;
+  }
+  /**
+   * One-shot auto-migration: backfill `theirs_snapshot` on existing
+   * patches that predate the snapshot encoding. Computes the snapshot by
+   * applying the patch's `patch_content` to its `base_generation` tree —
+   * yielding the patch's INDIVIDUAL contribution.
+   *
+   * **Skips patches sharing files with other patches.** HEAD's content
+   * for a file shared by N patches is cumulative across all of them, so
+   * a HEAD-fallback would falsely encode other patches' contributions
+   * into one patch's snapshot — breaking FER-9525 cross-patch isolation
+   * if the snapshot fallback later fires. Per-patch snapshots only
+   * make sense when the patch owns its file. Multi-patch-same-file
+   * legacy lockfiles keep using line-anchored reconstruction (the
+   * existing path); they're no worse than pre-upgrade.
+   *
+   * **Does not fall back to HEAD when BASE-reconstruction fails.** Same
+   * reason — HEAD content can be cumulative. Patches whose
+   * reconstruction fails just don't get a snapshot; legacy paths
+   * (PR #73's by-association gate, accumulator fallback) handle them.
+   *
+   * Skips patches that already have a snapshot.
+   */
+  async migratePatchesToSnapshot(patches) {
+    const { applyPatchToContent: applyPatchToContent2 } = await Promise.resolve().then(() => (init_PatchApplyTheirs(), PatchApplyTheirs_exports));
+    const fileFreq = /* @__PURE__ */ new Map();
+    for (const p of patches) {
+      for (const f of p.files) {
+        fileFreq.set(f, (fileFreq.get(f) ?? 0) + 1);
+      }
+    }
+    let migrated = 0;
+    let skipped = 0;
+    for (const patch of patches) {
+      if (patch.theirs_snapshot != null) continue;
+      const sharesAnyFile = patch.files.some((f) => (fileFreq.get(f) ?? 0) > 1);
+      if (sharesAnyFile) {
+        skipped++;
+        continue;
+      }
+      const snapshot = {};
+      for (const file of patch.files) {
+        if (isBinaryFile(file)) continue;
+        try {
+          const base = await this.git.showFile(patch.base_generation, file).catch(() => null);
+          if (base != null) {
+            const content = await applyPatchToContent2(base, patch.patch_content, file);
+            if (content != null) snapshot[file] = content;
+          }
+        } catch {
+        }
+      }
+      if (Object.keys(snapshot).length > 0) {
+        patch.theirs_snapshot = snapshot;
+        try {
+          this.lockManager.updatePatch(patch.id, { theirs_snapshot: snapshot });
+          migrated++;
+        } catch {
+        }
+      }
+    }
+    if (migrated > 0) {
+      this.warnings.push(
+        `Migrated ${migrated} patch(es) to snapshot encoding. Future regens use 3-way merge with stored THEIRS, robust to generator structural changes.`
+      );
+    }
+    if (skipped > 0) {
+      this.warnings.push(
+        `Skipped snapshot migration for ${skipped} patch(es) sharing files with other patches. These continue to use line-anchored reconstruction (the existing path).`
+      );
+    }
+  }
   /**
    * Determine whether `file` is user-owned (never produced by the generator).
    *
@@ -3446,6 +3762,20 @@ var ReplayService = class {
       this.lockManager.clearReplaySkippedAt();
       return { conflictResolved: 0, conflictAbsorbed: 0, contentRefreshed: 0 };
     }
+    await this.migratePatchesToSnapshot(patches);
+    const headMessage = await this.git.exec(["log", "-1", "--format=%s%n%aN%n%ae", "HEAD"]).catch(() => "");
+    const [headMsgLine, headAuthorName, headAuthorEmail] = headMessage.split("\n");
+    const headIsGeneration = headMsgLine ? isGenerationCommit({
+      sha: "HEAD",
+      authorName: headAuthorName ?? "",
+      authorEmail: headAuthorEmail ?? "",
+      message: headMsgLine
+    }) : false;
+    const headParentChangedFiles = async (patchFiles) => {
+      if (patchFiles.length === 0) return /* @__PURE__ */ new Set();
+      const diff = await this.git.exec(["diff", "--name-only", "HEAD~1", "HEAD", "--", ...patchFiles]).catch(() => "");
+      return new Set(diff.trim().split("\n").filter(Boolean));
+    };
     let conflictResolved = 0;
     let conflictAbsorbed = 0;
     let contentRefreshed = 0;
@@ -3482,8 +3812,50 @@ var ReplayService = class {
         delete patch.status;
         continue;
       }
+      if (headIsGeneration) {
+        const parentChangedFiles = await headParentChangedFiles(patch.files);
+        const headTouchedSource = patch.files.some((f) => parentChangedFiles.has(f));
+        if (headTouchedSource) {
+          continue;
+        }
+      }
       if (patch.base_generation === currentGen) {
         try {
+          const contaminated = await this.hasAutoversionContamination(
+            currentGen,
+            "HEAD",
+            patch.files
+          );
+          if (contaminated) {
+            const snapshotDiff = await this.computeSnapshotBasedPatchDiff(
+              patch,
+              currentGen
+            );
+            if (snapshotDiff === null) continue;
+            if (!snapshotDiff.trim()) {
+              if (await allPatchFilesUserOwned(patch)) continue;
+              this.lockManager.removePatch(patch.id);
+              contentRefreshed++;
+              continue;
+            }
+            const snapHasStaleMarkers = snapshotDiff.split("\n").some(
+              (l) => l.startsWith("+<<<<<<< Generated") || l.startsWith("+>>>>>>> Your customization")
+            );
+            if (snapHasStaleMarkers) continue;
+            const isProtectedSnap = patch.files.some(
+              (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || minimatch2(file, p))
+            );
+            if (isProtectedSnap) continue;
+            const snapHash = this.detector.computeContentHash(snapshotDiff);
+            if (snapHash !== patch.content_hash) {
+              this.lockManager.updatePatch(patch.id, {
+                patch_content: snapshotDiff,
+                content_hash: snapHash
+              });
+              contentRefreshed++;
+            }
+            continue;
+          }
           const ppResult = await computePerPatchDiffWithFallback(
             patch,
             (f) => this.git.showFile(currentGen, f),
@@ -3518,10 +3890,12 @@ var ReplayService = class {
             if (newFiles.length === 0) {
               this.lockManager.removePatch(patch.id);
             } else {
+              const snapshot = await this.readSnapshotFromTree("HEAD", newFiles);
               this.lockManager.updatePatch(patch.id, {
                 patch_content: diff,
                 content_hash: newContentHash,
-                files: newFiles
+                files: newFiles,
+                ...Object.keys(snapshot).length > 0 ? { theirs_snapshot: snapshot } : {}
               });
             }
             contentRefreshed++;
@@ -3533,6 +3907,42 @@ var ReplayService = class {
       try {
         const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "HEAD", "--", ...patch.files]).catch(() => "");
         if (markerFiles.trim()) continue;
+        const contaminated = await this.hasAutoversionContamination(
+          currentGen,
+          "HEAD",
+          patch.files
+        );
+        if (contaminated) {
+          const snapshotDiff = await this.computeSnapshotBasedPatchDiff(
+            patch,
+            currentGen
+          );
+          if (snapshotDiff === null) continue;
+          if (!snapshotDiff.trim()) {
+            if (await allPatchFilesUserOwned(patch)) {
+              try {
+                this.lockManager.updatePatch(patch.id, { base_generation: currentGen });
+              } catch {
+              }
+              continue;
+            }
+            this.lockManager.removePatch(patch.id);
+            conflictAbsorbed++;
+            continue;
+          }
+          const snapHasStaleMarkers = snapshotDiff.split("\n").some(
+            (l) => l.startsWith("+<<<<<<< Generated") || l.startsWith("+>>>>>>> Your customization")
+          );
+          if (snapHasStaleMarkers) continue;
+          const snapHash = this.detector.computeContentHash(snapshotDiff);
+          this.lockManager.updatePatch(patch.id, {
+            base_generation: currentGen,
+            patch_content: snapshotDiff,
+            content_hash: snapHash
+          });
+          conflictResolved++;
+          continue;
+        }
         const ppResult = await computePerPatchDiffWithFallback(
           patch,
           (f) => this.git.showFile(currentGen, f),
@@ -3554,10 +3964,12 @@ var ReplayService = class {
           continue;
         }
         const newContentHash = this.detector.computeContentHash(diff);
+        const snapshot = await this.readSnapshotFromTree("HEAD", patch.files);
         this.lockManager.updatePatch(patch.id, {
           base_generation: currentGen,
           patch_content: diff,
-          content_hash: newContentHash
+          content_hash: newContentHash,
+          ...Object.keys(snapshot).length > 0 ? { theirs_snapshot: snapshot } : {}
         });
         conflictResolved++;
       } catch {
@@ -3600,7 +4012,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
       if (result.status !== "conflict" || !result.fileResults) continue;
       for (const fileResult of result.fileResults) {
         if (fileResult.status !== "conflict") continue;
-        const filePath = join4(this.outputDir, fileResult.file);
+        const filePath = join5(this.outputDir, fileResult.file);
         try {
           const content = readFileSync2(filePath, "utf-8");
           const stripped = stripConflictMarkers(content);
@@ -3630,7 +4042,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     }
   }
   readFernignorePatterns() {
-    const fernignorePath = join4(this.outputDir, ".fernignore");
+    const fernignorePath = join5(this.outputDir, ".fernignore");
     if (!existsSync2(fernignorePath)) return [];
     return readFileSync2(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   }
@@ -3709,7 +4121,7 @@ function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit)
 // src/FernignoreMigrator.ts
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname4, join as join6 } from "path";
 import { minimatch as minimatch3 } from "minimatch";
 import { parse as parse2, stringify as stringify2 } from "yaml";
 var FernignoreMigrator = class {
@@ -3722,10 +4134,10 @@ var FernignoreMigrator = class {
     this.outputDir = outputDir;
   }
   fernignoreExists() {
-    return existsSync3(join5(this.outputDir, ".fernignore"));
+    return existsSync3(join6(this.outputDir, ".fernignore"));
   }
   readFernignorePatterns() {
-    const fernignorePath = join5(this.outputDir, ".fernignore");
+    const fernignorePath = join6(this.outputDir, ".fernignore");
     if (!existsSync3(fernignorePath)) {
       return [];
     }
@@ -3777,6 +4189,12 @@ var FernignoreMigrator = class {
         if (patchFiles.length > 0) {
           const patchContent = diffParts.join("\n");
           const contentHash = `sha256:${createHash2("sha256").update(patchContent).digest("hex")}`;
+          const theirsSnapshot = {};
+          for (const filePath of patchFiles) {
+            if (isBinaryFile(filePath)) continue;
+            const c = this.readFileContent(filePath);
+            if (c != null) theirsSnapshot[filePath] = c;
+          }
           syntheticPatches.push({
             id: `patch-fernignore-${createHash2("sha256").update(pattern).digest("hex").slice(0, 8)}`,
             content_hash: contentHash,
@@ -3786,6 +4204,7 @@ var FernignoreMigrator = class {
             base_generation: currentGen.commit_sha,
             files: patchFiles,
             patch_content: patchContent,
+            ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
             // Synthetic patches captured from .fernignore-protected files
             // are user-owned by definition — the customer's content
             // diverges from the generator's pristine output, and the
@@ -3827,7 +4246,7 @@ var FernignoreMigrator = class {
     return results;
   }
   readFileContent(filePath) {
-    const fullPath = join5(this.outputDir, filePath);
+    const fullPath = join6(this.outputDir, filePath);
     if (!existsSync3(fullPath)) {
       return null;
     }
@@ -3892,7 +4311,7 @@ var FernignoreMigrator = class {
     };
   }
   movePatternsToReplayYml(patterns) {
-    const replayYmlPath = join5(this.outputDir, ".fern", "replay.yml");
+    const replayYmlPath = join6(this.outputDir, ".fern", "replay.yml");
     let config = {};
     if (existsSync3(replayYmlPath)) {
       const content = readFileSync3(replayYmlPath, "utf-8");
@@ -3901,7 +4320,7 @@ var FernignoreMigrator = class {
     const existing = config.exclude ?? [];
     const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
     config.exclude = merged;
-    const dir = dirname3(replayYmlPath);
+    const dir = dirname4(replayYmlPath);
     if (!existsSync3(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
@@ -3912,7 +4331,7 @@ var FernignoreMigrator = class {
 // src/commands/bootstrap.ts
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 init_GitClient();
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
@@ -4079,7 +4498,7 @@ function parseGitLog(log) {
 }
 var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = join6(outputDir, ".fernignore");
+  const fernignorePath = join7(outputDir, ".fernignore");
   let content = "";
   if (existsSync4(fernignorePath)) {
     content = readFileSync4(fernignorePath, "utf-8");
@@ -4103,7 +4522,7 @@ function ensureFernignoreEntries(outputDir) {
 }
 var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = join6(outputDir, ".gitattributes");
+  const gitattributesPath = join7(outputDir, ".gitattributes");
   let content = "";
   if (existsSync4(gitattributesPath)) {
     content = readFileSync4(gitattributesPath, "utf-8");
@@ -4302,8 +4721,8 @@ function reset(outputDir, options) {
 
 // src/commands/resolve.ts
 init_GitClient();
-import { readFile as readFile2 } from "fs/promises";
-import { join as join7 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join8 } from "path";
 async function resolve(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
@@ -4346,36 +4765,78 @@ async function resolve(outputDir, options) {
     const detector = new ReplayDetector(git, lockManager, outputDir);
     const warnings = [];
     let patchesResolved = 0;
+    const pass1 = [];
     for (const patch of patchesToCommit) {
       const result = await computePerPatchDiffWithFallback(
         patch,
         (f) => git.showFile(currentGen, f),
-        (f) => readFile2(join7(outputDir, f), "utf-8").catch(() => null),
+        (f) => readFile3(join8(outputDir, f), "utf-8").catch(() => null),
         (files) => git.exec(["diff", currentGen, "--", ...files]).catch(() => null)
       );
       if (result === null) {
         warnings.push(
           `Patch ${patch.id}: cumulative-diff fallback failed for unlocatable files; preserving patch unchanged`
         );
+        pass1.push({ kind: "skip" });
         continue;
       }
       const diff = result.diff;
       if (!diff.trim()) {
+        pass1.push({ kind: "revert" });
+        continue;
+      }
+      const hash = detector.computeContentHash(diff);
+      pass1.push({
+        kind: "apply",
+        diff,
+        hash,
+        hadFallback: result.hadFallback,
+        fallbackFiles: result.fallbackFiles
+      });
+    }
+    const lastIndexByHash = /* @__PURE__ */ new Map();
+    for (let i = 0; i < pass1.length; i++) {
+      const r = pass1[i];
+      if (r.kind === "apply") lastIndexByHash.set(r.hash, i);
+    }
+    for (let i = 0; i < patchesToCommit.length; i++) {
+      const patch = patchesToCommit[i];
+      const r = pass1[i];
+      if (r.kind === "skip") continue;
+      if (r.kind === "revert") {
+        lockManager.removePatch(patch.id);
+        continue;
+      }
+      if (lastIndexByHash.get(r.hash) !== i) {
+        const canonicalIdx = lastIndexByHash.get(r.hash);
+        const canonical = patchesToCommit[canonicalIdx];
         lockManager.removePatch(patch.id);
+        warnings.push(
+          `Consolidated patch ${patch.id} (commit ${(patch.original_commit || "<missing>").slice(0, 7)}) into patch ${canonical.id} (commit ${(canonical.original_commit || "<missing>").slice(0, 7)}): byte-identical patch_content after resolution. Per-commit attribution preserved in git log; lockfile collapsed to avoid duplicate-apply corruption on next regen.`
+        );
         continue;
       }
-      if (result.hadFallback) {
+      if (r.hadFallback) {
         warnings.push(
-          `Patch ${patch.id}: ${result.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
+          `Patch ${patch.id}: ${r.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
         );
       }
-      const newContentHash = detector.computeContentHash(diff);
-      const changedFiles = result.hadFallback ? await getChangedFiles(git, currentGen, patch.files) : extractFilesFromDiff(diff);
+      const changedFiles = r.hadFallback ? await getChangedFiles(git, currentGen, patch.files) : extractFilesFromDiff(r.diff);
+      const filesForSnapshot = changedFiles.length > 0 ? changedFiles : patch.files;
+      const theirsSnapshot = {};
+      for (const file of filesForSnapshot) {
+        if (isBinaryFile(file)) continue;
+        const content = await readFile3(join8(outputDir, file), "utf-8").catch(() => null);
+        if (content != null) {
+          theirsSnapshot[file] = content;
+        }
+      }
       lockManager.markPatchResolved(patch.id, {
-        patch_content: diff,
-        content_hash: newContentHash,
+        patch_content: r.diff,
+        content_hash: r.hash,
         base_generation: currentGen,
-        files: changedFiles.length > 0 ? changedFiles : patch.files
+        files: filesForSnapshot,
+        ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
       });
       patchesResolved++;
     }