@fern-api/replay 0.13.0 → 0.14.1

package/dist/index.cjs

@@ -51,9 +51,9 @@ var init_GitClient = __esm({
         return this.git.raw(args);
       }
       async execWithInput(args, input) {
-        const { spawn } = await import("child_process");
+        const { spawn: spawn2 } = await import("child_process");
         return new Promise((resolve2, reject) => {
-          const proc = spawn("git", args, { cwd: this.repoPath });
+          const proc = spawn2("git", args, { cwd: this.repoPath });
           let stdout = "";
           let stderr = "";
           proc.stdout.on("data", (data) => {
@@ -417,6 +417,64 @@ var init_HybridReconstruction = __esm({
   }
 });
 
+// src/PatchApplyTheirs.ts
+var PatchApplyTheirs_exports = {};
+__export(PatchApplyTheirs_exports, {
+  applyPatchToContent: () => applyPatchToContent
+});
+async function applyPatchToContent(base, patchContent, filePath) {
+  const fileDiff = extractFileDiff(patchContent, filePath);
+  if (!fileDiff) return null;
+  const tempDir = await (0, import_promises3.mkdtemp)((0, import_node_path4.join)((0, import_node_os3.tmpdir)(), "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 = (0, import_node_path4.join)(tempDir, filePath);
+    await (0, import_promises3.mkdir)((0, import_node_path4.dirname)(tempFilePath), { recursive: true });
+    await (0, import_promises3.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 (0, import_promises3.readFile)(tempFilePath, "utf-8");
+  } catch {
+    return null;
+  } finally {
+    await (0, import_promises3.rm)(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 import_promises3, import_node_os3, import_node_path4;
+var init_PatchApplyTheirs = __esm({
+  "src/PatchApplyTheirs.ts"() {
+    "use strict";
+    import_promises3 = require("fs/promises");
+    import_node_os3 = require("os");
+    import_node_path4 = require("path");
+    init_GitClient();
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -580,7 +638,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 = [];
@@ -701,1406 +769,1593 @@ var LockfileManager = class {
 
 // src/ReplayDetector.ts
 var import_node_crypto = require("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
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path2 = require("path");
+var import_minimatch = require("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;
-        }
+    result.push(lines[i]);
+  }
+  return result.join("\n");
+}
+
+// src/ThreeWayMerge.ts
+var import_node_diff3 = require("node-diff3");
+function threeWayMerge(base, ours, theirs) {
+  const baseLines = base.split("\n");
+  const oursLines = ours.split("\n");
+  const theirsLines = theirs.split("\n");
+  const regions = (0, import_node_diff3.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;
       }
-      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 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 = (0, import_node_diff3.diffPatch)(baseLines, oursLines);
+  const theirsPatches = (0, import_node_diff3.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 (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 (tp.buffer1.length === 0 && tStart === oEnd) {
+        return 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 (op.buffer1.length === 0 && oStart === tEnd) {
+        return true;
       }
-      if (!matchedExisting && !matchedNew) {
-        revertIndicesToRemove.add(i);
+      if (oStart < tEnd && tStart < oEnd) {
+        return true;
       }
     }
-    const filteredPatches = survivingPatches.filter((_, i) => !revertIndicesToRemove.has(i));
-    return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
   }
+  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();
   /**
-   * 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.
+   * 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";
+  /**
+   * 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).
    *
-   * 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>`).
+   * 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.
    *
-   * 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).
+   * 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.
    */
-  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:${(0, import_node_crypto.createHash)("sha256").update(normalized).digest("hex")}`;
+  sharedFiles = /* @__PURE__ */ new Set();
+  constructor(git, lockManager, outputDir) {
+    this.git = git;
+    this.lockManager = lockManager;
+    this.outputDir = outputDir;
   }
   /**
-   * 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);
-      }
-    }
-    let anyCandidate = false;
-    for (const state of stateByFile.values()) {
-      if (state.created && state.deleted) {
-        anyCandidate = true;
-        break;
-      }
-    }
-    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 (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.
+   * 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 listHeadFiles() {
+  async resolveBaseGeneration(baseGeneration) {
+    const gen = this.lockManager.getGeneration(baseGeneration);
+    if (gen) return gen;
     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));
+      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 /* @__PURE__ */ new Set();
+      return void 0;
     }
   }
-  /**
-   * 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 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;
-    }
-    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 = (0, import_node_path2.join)(this.outputDir, fileResult.file);
+            try {
+              const content = await (0, import_promises.readFile)(filePath, "utf-8");
+              const stripped = stripConflictMarkers(content);
+              await (0, import_promises.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 (0, import_promises.mkdtemp)((0, import_node_path2.join)((0, import_node_os.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 (0, import_promises.readFile)((0, import_node_path2.join)(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 (0, import_promises.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 = (0, import_node_path2.join)(this.outputDir, filePath);
+        snapshots.set(filePath, await (0, import_promises.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 = (0, import_node_path2.join)(this.outputDir, filePath);
+          if (content != null) {
+            await (0, import_promises.writeFile)(fullPath, content);
+          } else {
+            await (0, import_promises.unlink)(fullPath).catch(() => {
+            });
+          }
+        }
+      }
     }
-    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);
+    return this.applyWithThreeWayMerge(patch);
   }
-};
-
-// src/ThreeWayMerge.ts
-var import_node_diff3 = require("node-diff3");
-function threeWayMerge(base, ours, theirs) {
-  const baseLines = base.split("\n");
-  const oursLines = ours.split("\n");
-  const theirsLines = theirs.split("\n");
-  const regions = (0, import_node_diff3.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 applyWithThreeWayMerge(patch) {
+    const fileResults = [];
+    const resolvedFiles = {};
+    const tempDir = await (0, import_promises.mkdtemp)((0, import_node_path2.join)((0, import_node_os.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 (0, import_promises.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 }
+    };
   }
-  return {
-    content: outputLines.join("\n"),
-    hasConflicts: conflicts.length > 0,
-    conflicts
-  };
-}
-function tryResolveConflict(oursLines, baseLines, theirsLines) {
-  if (baseLines.length === 0) {
-    return null;
-  }
-  const oursPatches = (0, import_node_diff3.diffPatch)(baseLines, oursLines);
-  const theirsPatches = (0, import_node_diff3.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;
+  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" };
       }
-      if (tp.buffer1.length === 0 && tStart === oEnd) {
-        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 (op.buffer1.length === 0 && oStart === tEnd) {
-        return true;
+      const oursPath = (0, import_node_path2.join)(this.outputDir, resolvedPath);
+      const ours = await (0, import_promises.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 (oStart < tEnd && tStart < oEnd) {
-        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;
+          }
+        }
       }
-    }
-  }
-  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 import_promises = require("fs/promises");
-var import_node_os = require("os");
-var import_node_path2 = require("path");
-var import_minimatch = require("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;
+      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"
+            };
+          }
         }
-        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;
+      }
+      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;
         }
-        j++;
       }
-      if (!found) {
-        i++;
-        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 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;
+        }
+      }
+      if (base == null && ours == null && effective_theirs != null) {
+        this.fileTheirsAccumulator.set(resolvedPath, {
+          content: effective_theirs,
+          baseGeneration: patch.base_generation
+        });
+        const outDir2 = (0, import_node_path2.dirname)(oursPath);
+        await (0, import_promises.mkdir)(outDir2, { recursive: true });
+        await (0, import_promises.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 = (0, import_node_path2.dirname)(oursPath);
+        await (0, import_promises.mkdir)(outDir2, { recursive: true });
+        await (0, import_promises.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" };
       }
-    }
-    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 (effective_theirs == null) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
       }
-      if (i > range.start && i < range.separator) {
-        result.push(lines[i]);
-        continue;
+      if (base == null && !useAccumulatorAsMergeBase || ours == null) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
       }
-      if (i === range.separator) {
-        continue;
+      const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
+      if (mergeBase == null) {
+        return {
+          file: resolvedPath,
+          status: "skipped",
+          reason: "missing-content"
+        };
       }
-      if (i > range.separator && i < range.end) {
-        continue;
+      const merged = threeWayMerge(mergeBase, ours, effective_theirs);
+      const outDir = (0, import_node_path2.dirname)(oursPath);
+      await (0, import_promises.mkdir)(outDir, { recursive: true });
+      await (0, import_promises.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 (i === range.end) {
-        rangeIdx++;
-        continue;
+      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();
-  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
-   */
-  async applyPatches(patches) {
-    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 (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) => (0, import_minimatch.minimatch)(file, pattern)));
+  }
+  async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
+    const config = this.lockManager.getCustomizationsConfig();
+    if (config.moves) {
+      for (const move of config.moves) {
+        if ((0, import_minimatch.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 = (0, import_node_path2.join)(this.outputDir, fileResult.file);
-            try {
-              const content = await (0, import_promises.readFile)(filePath, "utf-8");
-              const stripped = stripConflictMarkers(content);
-              await (0, import_promises.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 = (0, import_node_path2.join)(tempDir, sourceFilePath);
+        await (0, import_promises.mkdir)((0, import_node_path2.dirname)(tempSourcePath), { recursive: true });
+        await (0, import_promises.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 = (0, import_node_path2.join)(tempDir, filePath);
+        return await (0, import_promises.readFile)(tempTargetPath, "utf-8");
+      }
+      const tempFilePath = (0, import_node_path2.join)(tempDir, filePath);
+      await (0, import_promises.mkdir)((0, import_node_path2.dirname)(tempFilePath), { recursive: true });
+      await (0, import_promises.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 (0, import_promises.readFile)(tempFilePath, "utf-8");
+    } catch {
+      return null;
+    }
   }
-  /** Populate accumulator after git apply succeeds. */
-  async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
-    if (!baseGen) return;
-    const tempDir = await (0, import_promises.mkdtemp)((0, import_node_path2.join)((0, import_node_os.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"]);
+  /**
+   * 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 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 effectiveTheirs = theirs ?? await (0, import_promises.readFile)((0, import_node_path2.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
-        if (effectiveTheirs != null) {
-          this.fileTheirsAccumulator.set(resolvedPath, {
-            content: effectiveTheirs,
-            baseGeneration: patch.base_generation
-          });
+      const tempFilePath = (0, import_node_path2.join)(tempDir, filePath);
+      await (0, import_promises.mkdir)((0, import_node_path2.dirname)(tempFilePath), { recursive: true });
+      await (0, import_promises.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 (isDiffLineForFile(line, filePath)) {
+          inTargetFile = true;
+          diffLines.push(line);
+        }
+        continue;
+      }
+      if (inTargetFile) {
+        diffLines.push(line);
       }
-    } finally {
-      await (0, import_promises.rm)(tempDir, { recursive: true }).catch(() => {
-      });
     }
+    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 = (0, import_node_path2.join)(this.outputDir, filePath);
-        snapshots.set(filePath, await (0, import_promises.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);
-        await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
-        return {
-          patch,
-          status: "applied",
-          method: "git-am",
-          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
-        };
-      } catch {
-        for (const [filePath, content] of snapshots) {
-          const fullPath = (0, import_node_path2.join)(this.outputDir, filePath);
-          if (content != null) {
-            await (0, import_promises.writeFile)(fullPath, content);
-          } else {
-            await (0, import_promises.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));
+      }
     }
-    return this.applyWithThreeWayMerge(patch);
+    if (addedLines.length === 0) return null;
+    return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
   }
-  async applyWithThreeWayMerge(patch) {
-    const fileResults = [];
-    const resolvedFiles = {};
-    const tempDir = await (0, import_promises.mkdtemp)((0, import_node_path2.join)((0, import_node_os.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);
+};
+function isBinaryFile(filePath) {
+  const ext = (0, import_node_path2.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;
       }
-    } finally {
-      await (0, import_promises.rm)(tempDir, { recursive: true }).catch(() => {
-      });
+    } else if (currentPath !== null) {
+      if (line.startsWith("new file mode ")) {
+        currentIsCreate = true;
+      } else if (line.startsWith("deleted file mode ")) {
+        currentIsDelete = true;
+      }
+    }
+  }
+  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" };
+      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;
       }
-      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 (lock.patches.find((p) => p.original_commit === commit.sha)) {
+        continue;
       }
-      const oursPath = (0, import_node_path2.join)(this.outputDir, resolvedPath);
-      const ours = await (0, import_promises.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;
-            }
-          }
+      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;
       }
-      if (!ghostReconstructed) {
-        theirs = await this.applyPatchToContent(
-          base,
-          patch.patch_content,
-          filePath,
-          tempGit,
-          tempDir,
-          renameSourcePath
+      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.`
         );
+        continue;
       }
-      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) {
-          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 useAccumulatorAsMergeBase = false;
-      const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-      if (accumulatorEntry && (theirs == null || base == null)) {
-        theirs = await this.applyPatchToContent(
-          accumulatorEntry.content,
-          patch.patch_content,
-          filePath,
-          tempGit,
-          tempDir
+      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 (theirs != null) {
-          useAccumulatorAsMergeBase = true;
-        } else if (await this.isPatchAlreadyApplied(
-          patch.patch_content,
-          filePath,
-          accumulatorEntry.content,
-          tempGit,
-          tempDir
-        )) {
-          theirs = accumulatorEntry.content;
-          useAccumulatorAsMergeBase = true;
+        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 (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"
-          };
-        }
+      if (files.length === 0) {
+        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;
+      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: 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 {
+      }
+      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 (base == null && ours == null && effective_theirs != null) {
-        this.fileTheirsAccumulator.set(resolvedPath, {
-          content: effective_theirs,
-          baseGeneration: patch.base_generation
-        });
-        const outDir2 = (0, import_node_path2.dirname)(oursPath);
-        await (0, import_promises.mkdir)(outDir2, { recursive: true });
-        await (0, import_promises.writeFile)(oursPath, effective_theirs);
-        return { file: resolvedPath, status: "merged", reason: "new-file" };
+      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 (base == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
-        const merged2 = threeWayMerge("", ours, effective_theirs);
-        const outDir2 = (0, import_node_path2.dirname)(oursPath);
-        await (0, import_promises.mkdir)(outDir2, { recursive: true });
-        await (0, import_promises.writeFile)(oursPath, merged2.content);
-        if (merged2.hasConflicts) {
-          return {
-            file: resolvedPath,
-            status: "conflict",
-            conflicts: merged2.conflicts,
-            conflictReason: "new-file-both",
-            conflictMetadata: metadata
-          };
+      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;
         }
-        this.fileTheirsAccumulator.set(resolvedPath, {
-          content: merged2.content,
-          baseGeneration: patch.base_generation
-        });
-        return { file: resolvedPath, status: "merged" };
       }
-      if (effective_theirs == null) {
-        return {
-          file: resolvedPath,
-          status: "skipped",
-          reason: "missing-content"
-        };
+      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 (base == null && !useAccumulatorAsMergeBase || ours == null) {
-        return {
-          file: resolvedPath,
-          status: "skipped",
-          reason: "missing-content"
-        };
+      if (!matchedExisting && !matchedNew) {
+        revertIndicesToRemove.add(i);
       }
-      const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
-      if (mergeBase == null) {
-        return {
-          file: resolvedPath,
-          status: "skipped",
-          reason: "missing-content"
-        };
+    }
+    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:${(0, import_node_crypto.createHash)("sha256").update(normalized).digest("hex")}`;
+  }
+  /**
+   * 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 merged = threeWayMerge(mergeBase, ours, effective_theirs);
-      const outDir = (0, import_node_path2.dirname)(oursPath);
-      await (0, import_promises.mkdir)(outDir, { recursive: true });
-      await (0, import_promises.writeFile)(oursPath, merged.content);
-      if (effective_theirs != null && !merged.hasConflicts) {
-        this.fileTheirsAccumulator.set(resolvedPath, {
-          content: effective_theirs,
-          baseGeneration: patch.base_generation
-        });
+    }
+    let anyCandidate = false;
+    for (const state of stateByFile.values()) {
+      if (state.created && state.deleted) {
+        anyCandidate = true;
+        break;
       }
-      if (merged.hasConflicts) {
-        return {
-          file: resolvedPath,
-          status: "conflict",
-          conflicts: merged.conflicts,
-          conflictReason: baseMismatchSkipped ? "base-generation-mismatch" : "same-line-edit",
-          conflictMetadata: metadata
-        };
+    }
+    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 { file: resolvedPath, status: "merged" };
-    } catch (error) {
-      return {
-        file: filePath,
-        status: "skipped",
-        reason: `error: ${error instanceof Error ? error.message : String(error)}`
-      };
     }
+    if (transient.size === 0) return patches;
+    return patches.filter((patch) => !patch.files.every((f) => transient.has(f)));
   }
-  async isTreeReachable(treeHash) {
-    let result = this.treeExistsCache.get(treeHash);
-    if (result === void 0) {
-      result = await this.git.treeExists(treeHash);
-      this.treeExistsCache.set(treeHash, result);
+  /**
+   * 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 {
+      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();
     }
-    return result;
-  }
-  isExcluded(patch) {
-    const config = this.lockManager.getCustomizationsConfig();
-    if (!config.exclude) return false;
-    return patch.files.some((file) => config.exclude.some((pattern) => (0, import_minimatch.minimatch)(file, pattern)));
   }
-  async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
-    const config = this.lockManager.getCustomizationsConfig();
-    if (config.moves) {
-      for (const move of config.moves) {
-        if ((0, import_minimatch.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);
-          }
-        }
-      }
+  /**
+   * 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 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.`
+      );
     }
-    const cacheKey = `${baseTreeHash}:${currentTreeHash}`;
-    let renames = this.renameCache.get(cacheKey);
-    if (!renames) {
-      renames = await this.git.detectRenames(baseTreeHash, currentTreeHash);
-      this.renameCache.set(cacheKey, renames);
+    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 gitRename = renames.find((r) => r.from === filePath);
-    if (gitRename) {
-      return gitRename.to;
+    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 filePath;
+    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 } : {}
+    };
   }
-  async applyPatchToContent(base, patchContent, filePath, tempGit, tempDir, sourceFilePath) {
-    if (!base) {
-      return this.extractNewFileFromPatch(patchContent, filePath);
+  /**
+   * 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();
     }
-    const fileDiff = this.extractFileDiff(patchContent, filePath);
-    if (!fileDiff) return null;
-    try {
-      if (sourceFilePath) {
-        const tempSourcePath = (0, import_node_path2.join)(tempDir, sourceFilePath);
-        await (0, import_promises.mkdir)((0, import_node_path2.dirname)(tempSourcePath), { recursive: true });
-        await (0, import_promises.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 = (0, import_node_path2.join)(tempDir, filePath);
-        return await (0, import_promises.readFile)(tempTargetPath, "utf-8");
-      }
-      const tempFilePath = (0, import_node_path2.join)(tempDir, filePath);
-      await (0, import_promises.mkdir)((0, import_node_path2.dirname)(tempFilePath), { recursive: true });
-      await (0, import_promises.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 (0, import_promises.readFile)(tempFilePath, "utf-8");
-    } catch {
-      return 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: [] };
   }
   /**
-   * 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.
+   * 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 isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
-    const fileDiff = this.extractFileDiff(patchContent, filePath);
-    if (!fileDiff) return false;
-    try {
-      const tempFilePath = (0, import_node_path2.join)(tempDir, filePath);
-      await (0, import_promises.mkdir)((0, import_node_path2.dirname)(tempFilePath), { recursive: true });
-      await (0, import_promises.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 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: [] };
     }
-  }
-  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);
-        }
+    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) {
-        diffLines.push(line);
+      const parents = await this.git.getCommitParents(commit.sha);
+      if (parents.length > 1) {
+        continue;
       }
-    }
-    return diffLines.length > 0 ? diffLines.join("\n") + "\n" : null;
-  }
-  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);
+      if (existingCommits.has(commit.sha)) {
         continue;
       }
-      if (!inTargetFile) continue;
-      if (line.startsWith("@@")) break;
-      if (line.startsWith("rename from ")) {
-        return line.slice("rename from ".length);
+      let patchContent;
+      try {
+        patchContent = await this.git.formatPatch(commit.sha);
+      } catch {
+        continue;
       }
-    }
-    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;
+      let contentHash = this.computeContentHash(patchContent);
+      if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
         continue;
       }
-      if (!inTargetFile) continue;
-      if (!inHunk) {
-        if (line === "--- /dev/null" || line.startsWith("new file mode")) {
-          isNewFile = true;
+      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 } : {}
+      });
+    }
+    newPatches.reverse();
+    return { patches: newPatches, revertedPatchIds: [] };
+  }
+  /**
+   * 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;
     }
-    if (addedLines.length === 0) return null;
-    return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
+    return diffOldHeaders.every((l) => l === "--- /dev/null");
+  }
+  /**
+   * 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);
   }
 };
-function isBinaryFile(filePath) {
-  const ext = (0, import_node_path2.extname)(filePath).toLowerCase();
-  return BINARY_EXTENSIONS.has(ext);
-}
-function isDiffLineForFile(diffLine, filePath) {
-  const match = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
-  return match !== null && match[1] === filePath;
-}
 
 // src/ReplayCommitter.ts
 var ReplayCommitter = class {
@@ -2132,13 +2387,46 @@ CLI Version: ${options.cliVersion}`;
     await this.git.exec(["commit", "-m", fullMessage]);
     return (await this.git.exec(["rev-parse", "HEAD"])).trim();
   }
-  async commitReplay(_patchCount, patches, message) {
+  async commitReplay(_patchCount, patches, message, options) {
     await this.stageAll();
     if (!await this.hasStagedChanges()) {
       return (await this.git.exec(["rev-parse", "HEAD"])).trim();
     }
     let fullMessage = message ?? `[fern-replay] Applied customizations`;
-    if (patches && patches.length > 0) {
+    const buckets = options?.buckets;
+    if (buckets) {
+      if (buckets.applied.length > 0) {
+        fullMessage += `
+
+Patches applied (${buckets.applied.length}):`;
+        for (const p of buckets.applied) {
+          fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+        }
+      }
+      if (buckets.unresolved.length > 0) {
+        fullMessage += `
+
+Patches with unresolved conflicts (${buckets.unresolved.length}):`;
+        for (const p of buckets.unresolved) {
+          fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+        }
+        fullMessage += `
+    Run \`fern-replay resolve\` to apply these customizations.`;
+      }
+      if (buckets.absorbed.length > 0) {
+        fullMessage += `
+
+Patches absorbed by generator (${buckets.absorbed.length}):`;
+        for (const p of buckets.absorbed) {
+          fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+        }
+        fullMessage += `
+    The generator now produces these customizations natively.`;
+      }
+    } else if (patches && patches.length > 0) {
       fullMessage += "\n\nPatches replayed:";
       for (const patch of patches) {
         fullMessage += `
@@ -2174,9 +2462,304 @@ CLI Version: ${options.cliVersion}`;
 
 // src/ReplayService.ts
 var import_node_fs2 = require("fs");
-var import_node_path3 = require("path");
+var import_promises4 = require("fs/promises");
+var import_node_path5 = require("path");
 var import_minimatch2 = require("minimatch");
 init_GitClient();
+
+// src/PatchRegionDiff.ts
+var import_promises2 = require("fs/promises");
+var import_node_os2 = require("os");
+var import_node_path3 = require("path");
+var import_node_child_process = require("child_process");
+init_HybridReconstruction();
+function normalizeHunkBody(hunk) {
+  let contextC = 0;
+  let removeC = 0;
+  let addC = 0;
+  const trimmed = [];
+  for (const line of hunk.lines) {
+    const oldUsed = contextC + removeC;
+    const newUsed = contextC + addC;
+    if (oldUsed >= hunk.oldCount && newUsed >= hunk.newCount) break;
+    trimmed.push(line);
+    if (line.type === "context") contextC++;
+    else if (line.type === "remove") removeC++;
+    else if (line.type === "add") addC++;
+  }
+  return { ...hunk, lines: trimmed };
+}
+function extractFileDiffForFile(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;
+      if (isDiffLineForFile2(line, filePath)) {
+        inTarget = true;
+        out.push(line);
+      }
+      continue;
+    }
+    if (inTarget) out.push(line);
+  }
+  return out.length > 0 ? out.join("\n") + "\n" : null;
+}
+function isDiffLineForFile2(line, filePath) {
+  const match = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+  return match !== null && (match[2] === filePath || match[1] === filePath);
+}
+async function computePerPatchDiff(patch, getCurrentGenContent, getWorkingTreeContent) {
+  const fragments = [];
+  const unlocatableFiles = [];
+  for (const file of patch.files) {
+    const fileDiff = extractFileDiffForFile(patch.patch_content, file);
+    if (fileDiff == null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    const hunksRaw = parseHunks(fileDiff).map(normalizeHunkBody);
+    const hunks = hunksRaw.filter((h) => {
+      if (h.lines.length === 0) return false;
+      let ctx = 0, rm4 = 0, add = 0;
+      for (const ln of h.lines) {
+        if (ln.type === "context") ctx++;
+        else if (ln.type === "remove") rm4++;
+        else if (ln.type === "add") add++;
+      }
+      return ctx + rm4 === h.oldCount && ctx + add === h.newCount;
+    });
+    if (hunks.length === 0) {
+      if (hunksRaw.length > 0) unlocatableFiles.push(file);
+      continue;
+    }
+    const currentGen = await getCurrentGenContent(file);
+    const workingTree = await getWorkingTreeContent(file);
+    const isPureNewFile = hunks.every((h) => h.oldCount === 0);
+    const isPureDelete = hunks.every((h) => h.newCount === 0);
+    if (currentGen == null) {
+      if (!isPureNewFile) {
+        unlocatableFiles.push(file);
+        continue;
+      }
+      if (workingTree == null) continue;
+      fragments.push(synthesizeNewFileDiff(file, workingTree));
+      continue;
+    }
+    if (isPureNewFile) {
+      if (workingTree == null) {
+        fragments.push(synthesizeDeleteFileDiff(file, currentGen));
+        continue;
+      }
+      if (workingTree === currentGen) {
+        continue;
+      }
+      const fullDiff = await unifiedDiff(currentGen, workingTree, file);
+      if (fullDiff && fullDiff.trim()) fragments.push(fullDiff);
+      continue;
+    }
+    if (workingTree == null) {
+      if (!isPureDelete) {
+        unlocatableFiles.push(file);
+        continue;
+      }
+      fragments.push(synthesizeDeleteFileDiff(file, currentGen));
+      continue;
+    }
+    const currentGenLines = splitLines(currentGen);
+    const workingTreeLines = splitLines(workingTree);
+    const locInCurrentGenRaw = locateHunksInOurs(hunks, currentGenLines);
+    const locInWorkingTreeRaw = locateHunksInOurs(hunks, workingTreeLines);
+    if (locInCurrentGenRaw == null || locInWorkingTreeRaw == null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    const locInCurrentGen = locInCurrentGenRaw.map(
+      (l) => resolveSpan(l, currentGenLines, "old")
+    );
+    const locInWorkingTree = locInWorkingTreeRaw.map(
+      (l) => resolveSpan(l, workingTreeLines, "new")
+    );
+    const overlay = overlayRegions(
+      currentGenLines,
+      locInCurrentGen,
+      workingTreeLines,
+      locInWorkingTree
+    );
+    if (overlay === null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    if (overlay === currentGen) {
+      continue;
+    }
+    const fileUnifiedDiff = await unifiedDiff(currentGen, overlay, file);
+    if (fileUnifiedDiff && fileUnifiedDiff.trim()) {
+      fragments.push(fileUnifiedDiff);
+    }
+  }
+  return {
+    diff: fragments.join(""),
+    unlocatableFiles
+  };
+}
+async function computePerPatchDiffWithFallback(patch, getCurrentGenContent, getWorkingTreeContent, runCumulativeDiff) {
+  const ppDiff = await computePerPatchDiff(
+    patch,
+    getCurrentGenContent,
+    getWorkingTreeContent
+  );
+  if (ppDiff.unlocatableFiles.length === 0) {
+    return { diff: ppDiff.diff, hadFallback: false, fallbackFiles: [] };
+  }
+  const cumulative = await runCumulativeDiff(ppDiff.unlocatableFiles);
+  if (cumulative === null) {
+    return null;
+  }
+  const merged = ppDiff.diff + (cumulative.trim() ? cumulative : "");
+  return { diff: merged, hadFallback: true, fallbackFiles: ppDiff.unlocatableFiles };
+}
+function splitLines(content) {
+  return content.split("\n");
+}
+function resolveSpan(loc, oursLines, prefer) {
+  const { hunk, oursOffset } = loc;
+  const oldSide = [];
+  const newSide = [];
+  for (const line of hunk.lines) {
+    if (line.type === "context") {
+      oldSide.push(line.content);
+      newSide.push(line.content);
+    } else if (line.type === "remove") {
+      oldSide.push(line.content);
+    } else if (line.type === "add") {
+      newSide.push(line.content);
+    }
+  }
+  const oldFits = sequenceMatches(oldSide, oursLines, oursOffset);
+  const newFits = sequenceMatches(newSide, oursLines, oursOffset);
+  if (prefer === "old") {
+    if (oldFits) return { ...loc, oursSpan: hunk.oldCount };
+    if (newFits) return { ...loc, oursSpan: hunk.newCount };
+  } else {
+    if (newFits) return { ...loc, oursSpan: hunk.newCount };
+    if (oldFits) return { ...loc, oursSpan: hunk.oldCount };
+  }
+  return loc;
+}
+function sequenceMatches(needle, haystack, offset) {
+  if (offset + needle.length > haystack.length) return false;
+  for (let i = 0; i < needle.length; i++) {
+    if (haystack[offset + i] !== needle[i]) return false;
+  }
+  return true;
+}
+function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locInWorkingTree) {
+  if (locInCurrentGen.length !== locInWorkingTree.length) {
+    return null;
+  }
+  const out = [];
+  let cursor = 0;
+  for (let i = 0; i < locInCurrentGen.length; i++) {
+    const cg = locInCurrentGen[i];
+    const wt = locInWorkingTree[i];
+    if (cg.oursOffset > cursor) {
+      out.push(...currentGenLines.slice(cursor, cg.oursOffset));
+    }
+    out.push(...workingTreeLines.slice(wt.oursOffset, wt.oursOffset + wt.oursSpan));
+    cursor = cg.oursOffset + cg.oursSpan;
+  }
+  if (cursor < currentGenLines.length) {
+    out.push(...currentGenLines.slice(cursor));
+  }
+  return out.join("\n");
+}
+async function unifiedDiff(beforeContent, afterContent, filePath) {
+  if (beforeContent === afterContent) return "";
+  const tmp = await (0, import_promises2.mkdtemp)((0, import_node_path3.join)((0, import_node_os2.tmpdir)(), "fern-replay-pp-"));
+  try {
+    const beforePath = (0, import_node_path3.join)(tmp, "before");
+    const afterPath = (0, import_node_path3.join)(tmp, "after");
+    await (0, import_promises2.writeFile)(beforePath, beforeContent, "utf-8");
+    await (0, import_promises2.writeFile)(afterPath, afterContent, "utf-8");
+    const raw = await runGitDiffNoIndex(beforePath, afterPath);
+    if (!raw.trim()) return "";
+    return rewriteDiffHeaders(raw, filePath);
+  } finally {
+    await (0, import_promises2.rm)(tmp, { recursive: true, force: true });
+  }
+}
+function runGitDiffNoIndex(beforePath, afterPath) {
+  return new Promise((resolve2, reject) => {
+    const proc = (0, import_node_child_process.spawn)("git", ["diff", "--no-index", "--", beforePath, afterPath]);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d) => stdout += d.toString());
+    proc.stderr.on("data", (d) => stderr += d.toString());
+    proc.on("close", (code) => {
+      if (code === 0 || code === 1) resolve2(stdout);
+      else reject(new Error(`git diff --no-index failed (code ${code}): ${stderr}`));
+    });
+  });
+}
+function rewriteDiffHeaders(raw, filePath) {
+  const lines = raw.split("\n");
+  const out = [];
+  let seenFirstHeader = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      out.push(`diff --git a/${filePath} b/${filePath}`);
+      seenFirstHeader = true;
+      continue;
+    }
+    if (!seenFirstHeader) {
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      out.push(`--- a/${filePath}`);
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      out.push(`+++ b/${filePath}`);
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function synthesizeNewFileDiff(file, content) {
+  const lines = content.split("\n");
+  const hasTrailingNewline = content.endsWith("\n");
+  const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const header = [
+    `diff --git a/${file} b/${file}`,
+    "new file mode 100644",
+    "--- /dev/null",
+    `+++ b/${file}`,
+    `@@ -0,0 +1,${bodyLines.length} @@`
+  ].join("\n");
+  const body = bodyLines.map((l) => `+${l}`).join("\n");
+  const trailer = hasTrailingNewline ? "" : "\n\";
+  return header + "\n" + body + trailer + "\n";
+}
+function synthesizeDeleteFileDiff(file, content) {
+  const lines = content.split("\n");
+  const hasTrailingNewline = content.endsWith("\n");
+  const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const header = [
+    `diff --git a/${file} b/${file}`,
+    "deleted file mode 100644",
+    `--- a/${file}`,
+    "+++ /dev/null",
+    `@@ -1,${bodyLines.length} +0,0 @@`
+  ].join("\n");
+  const body = bodyLines.map((l) => `-${l}`).join("\n");
+  const trailer = hasTrailingNewline ? "" : "\n\";
+  return header + "\n" + body + trailer + "\n";
+}
+
+// src/ReplayService.ts
 var ReplayService = class {
   git;
   detector;
@@ -2570,6 +3153,7 @@ var ReplayService = class {
     if (newPatches.length > 0) {
       results = await this.applicator.applyPatches(newPatches);
       this._lastApplyResults = results;
+      this.recordDroppedContextLineWarnings(results);
       this.revertConflictingFiles(results);
       for (const result of results) {
         if (result.status === "conflict") {
@@ -2588,7 +3172,8 @@ var ReplayService = class {
     if (newPatches.length > 0) {
       if (!options?.stageOnly) {
         const appliedCount = results.filter((r) => r.status === "applied").length;
-        await this.committer.commitReplay(appliedCount, newPatches);
+        const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, newPatches);
+        await this.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
       } else {
         await this.committer.stageAll();
       }
@@ -2651,12 +3236,16 @@ var ReplayService = class {
       (p) => preRebasePatchIds.has(p.id) && !postRebasePatchIds.has(p.id)
     );
     existingPatches = this.lockManager.getPatches();
-    const seenHashes = /* @__PURE__ */ new Set();
+    const seenHashes = /* @__PURE__ */ new Map();
     for (const p of existingPatches) {
-      if (seenHashes.has(p.content_hash)) {
+      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.add(p.content_hash);
+        seenHashes.set(p.content_hash, p.id);
       }
     }
     existingPatches = this.lockManager.getPatches();
@@ -2717,6 +3306,7 @@ var ReplayService = class {
     const genSha = prep._prepared.genSha;
     const results = await this.applicator.applyPatches(allPatches);
     this._lastApplyResults = results;
+    this.recordDroppedContextLineWarnings(results);
     this.revertConflictingFiles(results);
     for (const result of results) {
       if (result.status === "conflict") {
@@ -2744,7 +3334,8 @@ var ReplayService = class {
       await this.committer.stageAll();
     } else {
       const appliedCount = results.filter((r) => r.status === "applied").length;
-      await this.committer.commitReplay(appliedCount, allPatches);
+      const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, allPatches);
+      await this.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
     }
     const warnings = [...detectorWarnings, ...this.warnings];
     return this.buildReport(
@@ -2768,7 +3359,7 @@ var ReplayService = class {
     let repointed = 0;
     let contentRebased = 0;
     let keptAsUserOwned = 0;
-    const seenContentHashes = /* @__PURE__ */ new Set();
+    const seenContentHashes = /* @__PURE__ */ new Map();
     const absorbedPatchIds = /* @__PURE__ */ new Set();
     const fernignorePatterns = this.readFernignorePatterns();
     for (const result of results) {
@@ -2782,6 +3373,23 @@ var ReplayService = class {
         }
       }
     }
+    const conflictedFilePaths = /* @__PURE__ */ new Set();
+    for (const r of results) {
+      if (r.status !== "conflict") continue;
+      if (r.fileResults) {
+        for (const fr of r.fileResults) {
+          if (fr.status !== "conflict") continue;
+          conflictedFilePaths.add(fr.file);
+          if (r.resolvedFiles) {
+            for (const [orig, resolved] of Object.entries(r.resolvedFiles)) {
+              if (resolved === fr.file) conflictedFilePaths.add(orig);
+            }
+          }
+        }
+      } else {
+        for (const f of r.patch.files) conflictedFilePaths.add(f);
+      }
+    }
     for (const result of results) {
       if (result.status === "conflict" && result.fileResults) {
         await this.trimAbsorbedFiles(result, currentGenSha);
@@ -2818,17 +3426,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 {
           }
@@ -2849,6 +3467,18 @@ var ReplayService = class {
             keptAsUserOwned++;
             continue;
           }
+          const overlapsConflicted = patch.files.some((f) => conflictedFilePaths.has(f));
+          if (overlapsConflicted) {
+            patch.status = "unresolved";
+            try {
+              this.lockManager.updatePatch(patch.id, { status: "unresolved" });
+            } catch {
+            }
+            this.warnings.push(
+              `Patch ${patch.id} (${patch.original_message}) was preserved as unresolved because an earlier patch conflicted on the same file(s) (${patch.files.join(", ")}). Run \`fern replay resolve\` to apply this customization manually.`
+            );
+            continue;
+          }
           this.lockManager.removePatch(patch.id);
           absorbedPatchIds.add(patch.id);
           absorbed++;
@@ -2864,21 +3494,34 @@ var ReplayService = class {
           continue;
         }
         const newContentHash = this.detector.computeContentHash(diff);
-        if (seenContentHashes.has(newContentHash)) {
+        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.`
+            );
+          }
           continue;
+        } else {
+          seenContentHashes.set(newContentHash, patch.id);
         }
-        seenContentHashes.add(newContentHash);
         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 {
         }
@@ -2888,6 +3531,112 @@ 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 (0, import_promises4.readFile)((0, import_node_path5.join)(this.outputDir, file), "utf-8");
+        snapshot[file] = content;
+      } catch {
+      }
+    }
+    return snapshot;
+  }
+  /**
+   * 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).
    *
@@ -3008,6 +3757,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;
@@ -3044,10 +3807,23 @@ 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 diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
-          if (diff === null) continue;
+          const ppResult = await computePerPatchDiffWithFallback(
+            patch,
+            (f) => this.git.showFile(currentGen, f),
+            (f) => this.git.showFile("HEAD", f),
+            (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+          );
+          if (ppResult === null) continue;
+          const diff = ppResult.diff;
           if (!diff.trim()) {
             if (await allPatchFilesUserOwned(patch)) continue;
             this.lockManager.removePatch(patch.id);
@@ -3074,10 +3850,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++;
@@ -3089,8 +3867,14 @@ var ReplayService = class {
       try {
         const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "HEAD", "--", ...patch.files]).catch(() => "");
         if (markerFiles.trim()) continue;
-        const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
-        if (diff === null) continue;
+        const ppResult = await computePerPatchDiffWithFallback(
+          patch,
+          (f) => this.git.showFile(currentGen, f),
+          (f) => this.git.showFile("HEAD", f),
+          (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+        );
+        if (ppResult === null) continue;
+        const diff = ppResult.diff;
         if (!diff.trim()) {
           if (await allPatchFilesUserOwned(patch)) {
             try {
@@ -3104,10 +3888,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 {
@@ -3115,6 +3901,32 @@ var ReplayService = class {
     }
     return { conflictResolved, conflictAbsorbed, contentRefreshed };
   }
+  /**
+   * After applyPatches(), surface a warning for each (patch × file) where
+   * diff3 silently dropped lines that were unchanged context in the
+   * customer's THEIRS. The deletion stays on disk (correct diff3 outcome),
+   * but the customer must learn so they can re-add the lines if they
+   * relied on them. This is the "surface or preserve, never silently drop"
+   * contract for legitimate-deletion cases.
+   */
+  recordDroppedContextLineWarnings(results) {
+    const PREVIEW_COUNT = 5;
+    for (const result of results) {
+      if (!result.fileResults) continue;
+      for (const fr of result.fileResults) {
+        const dropped = fr.droppedContextLines;
+        if (!dropped || dropped.length === 0) continue;
+        const preview = dropped.slice(0, PREVIEW_COUNT).map((line) => `    ${line}`).join("\n");
+        const more = dropped.length > PREVIEW_COUNT ? `
+    ... and ${dropped.length - PREVIEW_COUNT} more` : "";
+        this.warnings.push(
+          `${fr.file}: ${dropped.length} line(s) that appeared as unchanged context in your customization were deleted by the new generator output. The merge followed the deletion. First lines deleted:
+${preview}${more}
+If you want to keep these lines, restore them in a follow-up commit and re-run replay; otherwise this warning can be safely ignored.`
+        );
+      }
+    }
+  }
   /**
    * After applyPatches(), strip conflict markers from conflicting files
    * so only clean content is committed. Keeps the Generated (OURS) side.
@@ -3124,7 +3936,7 @@ var ReplayService = class {
       if (result.status !== "conflict" || !result.fileResults) continue;
       for (const fileResult of result.fileResults) {
         if (fileResult.status !== "conflict") continue;
-        const filePath = (0, import_node_path3.join)(this.outputDir, fileResult.file);
+        const filePath = (0, import_node_path5.join)(this.outputDir, fileResult.file);
         try {
           const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
           const stripped = stripConflictMarkers(content);
@@ -3154,7 +3966,7 @@ var ReplayService = class {
     }
   }
   readFernignorePatterns() {
-    const fernignorePath = (0, import_node_path3.join)(this.outputDir, ".fernignore");
+    const fernignorePath = (0, import_node_path5.join)(this.outputDir, ".fernignore");
     if (!(0, import_node_fs2.existsSync)(fernignorePath)) return [];
     return (0, import_node_fs2.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   }
@@ -3172,6 +3984,9 @@ var ReplayService = class {
       };
     }).filter((d) => d.files.length > 0);
     const partialCount = conflictDetails.filter((d) => d.cleanFiles && d.cleanFiles.length > 0).length;
+    const unresolvedResults = results.filter(
+      (r) => r.status === "conflict" || r.patch.status === "unresolved"
+    );
     return {
       flow,
       patchesDetected: patches.length,
@@ -3188,7 +4003,7 @@ var ReplayService = class {
       patchesRefreshed: preRebaseCounts && preRebaseCounts.contentRefreshed > 0 ? preRebaseCounts.contentRefreshed : void 0,
       conflicts: conflictResults.flatMap((r) => r.fileResults?.filter((f) => f.status === "conflict") ?? []),
       conflictDetails: conflictDetails.length > 0 ? conflictDetails : void 0,
-      unresolvedPatches: conflictResults.length > 0 ? conflictResults.map((r) => ({
+      unresolvedPatches: unresolvedResults.length > 0 ? unresolvedResults.map((r) => ({
         patchId: r.patch.id,
         patchMessage: r.patch.original_message,
         files: r.patch.files,
@@ -3199,11 +4014,38 @@ var ReplayService = class {
     };
   }
 };
+function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit) {
+  const resultByPatchId = /* @__PURE__ */ new Map();
+  for (const r of results) resultByPatchId.set(r.patch.id, r);
+  const applied = [];
+  const unresolved = [];
+  const absorbed = [];
+  for (const patch of patchesPassedToCommit) {
+    if (absorbedPatchIds.has(patch.id)) {
+      absorbed.push(patch);
+      continue;
+    }
+    const r = resultByPatchId.get(patch.id);
+    if (!r) {
+      applied.push(patch);
+      continue;
+    }
+    if (r.status === "conflict" || patch.status === "unresolved") {
+      unresolved.push(patch);
+      continue;
+    }
+    if (r.status === "applied") {
+      applied.push(patch);
+      continue;
+    }
+  }
+  return { applied, unresolved, absorbed };
+}
 
 // src/FernignoreMigrator.ts
 var import_node_crypto2 = require("crypto");
 var import_node_fs3 = require("fs");
-var import_node_path4 = require("path");
+var import_node_path6 = require("path");
 var import_minimatch3 = require("minimatch");
 var import_yaml2 = require("yaml");
 var FernignoreMigrator = class {
@@ -3216,10 +4058,10 @@ var FernignoreMigrator = class {
     this.outputDir = outputDir;
   }
   fernignoreExists() {
-    return (0, import_node_fs3.existsSync)((0, import_node_path4.join)(this.outputDir, ".fernignore"));
+    return (0, import_node_fs3.existsSync)((0, import_node_path6.join)(this.outputDir, ".fernignore"));
   }
   readFernignorePatterns() {
-    const fernignorePath = (0, import_node_path4.join)(this.outputDir, ".fernignore");
+    const fernignorePath = (0, import_node_path6.join)(this.outputDir, ".fernignore");
     if (!(0, import_node_fs3.existsSync)(fernignorePath)) {
       return [];
     }
@@ -3271,6 +4113,12 @@ var FernignoreMigrator = class {
         if (patchFiles.length > 0) {
           const patchContent = diffParts.join("\n");
           const contentHash = `sha256:${(0, import_node_crypto2.createHash)("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-${(0, import_node_crypto2.createHash)("sha256").update(pattern).digest("hex").slice(0, 8)}`,
             content_hash: contentHash,
@@ -3279,7 +4127,17 @@ var FernignoreMigrator = class {
             original_author: "Fern Replay <replay@buildwithfern.com>",
             base_generation: currentGen.commit_sha,
             files: patchFiles,
-            patch_content: patchContent
+            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
+            // generator never produced this divergent content. Without
+            // this flag, removing the file from .fernignore later (so
+            // it leaves the protection check in `isFileUserOwned`) would
+            // expose the patch to absorption on the next regen,
+            // silently losing the customization.
+            user_owned: true
           });
           trackedByBoth.push({
             file: pattern,
@@ -3312,7 +4170,7 @@ var FernignoreMigrator = class {
     return results;
   }
   readFileContent(filePath) {
-    const fullPath = (0, import_node_path4.join)(this.outputDir, filePath);
+    const fullPath = (0, import_node_path6.join)(this.outputDir, filePath);
     if (!(0, import_node_fs3.existsSync)(fullPath)) {
       return null;
     }
@@ -3377,7 +4235,7 @@ var FernignoreMigrator = class {
     };
   }
   movePatternsToReplayYml(patterns) {
-    const replayYmlPath = (0, import_node_path4.join)(this.outputDir, ".fern", "replay.yml");
+    const replayYmlPath = (0, import_node_path6.join)(this.outputDir, ".fern", "replay.yml");
     let config = {};
     if ((0, import_node_fs3.existsSync)(replayYmlPath)) {
       const content = (0, import_node_fs3.readFileSync)(replayYmlPath, "utf-8");
@@ -3386,7 +4244,7 @@ var FernignoreMigrator = class {
     const existing = config.exclude ?? [];
     const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
     config.exclude = merged;
-    const dir = (0, import_node_path4.dirname)(replayYmlPath);
+    const dir = (0, import_node_path6.dirname)(replayYmlPath);
     if (!(0, import_node_fs3.existsSync)(dir)) {
       (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
     }
@@ -3397,7 +4255,7 @@ var FernignoreMigrator = class {
 // src/commands/bootstrap.ts
 var import_node_crypto3 = require("crypto");
 var import_node_fs4 = require("fs");
-var import_node_path5 = require("path");
+var import_node_path7 = require("path");
 init_GitClient();
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
@@ -3564,7 +4422,7 @@ function parseGitLog(log) {
 }
 var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_node_path5.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_node_path7.join)(outputDir, ".fernignore");
   let content = "";
   if ((0, import_node_fs4.existsSync)(fernignorePath)) {
     content = (0, import_node_fs4.readFileSync)(fernignorePath, "utf-8");
@@ -3588,7 +4446,7 @@ function ensureFernignoreEntries(outputDir) {
 }
 var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = (0, import_node_path5.join)(outputDir, ".gitattributes");
+  const gitattributesPath = (0, import_node_path7.join)(outputDir, ".gitattributes");
   let content = "";
   if ((0, import_node_fs4.existsSync)(gitattributesPath)) {
     content = (0, import_node_fs4.readFileSync)(gitattributesPath, "utf-8");
@@ -3786,6 +4644,8 @@ function reset(outputDir, options) {
 }
 
 // src/commands/resolve.ts
+var import_promises5 = require("fs/promises");
+var import_node_path8 = require("path");
 init_GitClient();
 async function resolve(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
@@ -3801,7 +4661,7 @@ async function resolve(outputDir, options) {
   const resolvingPatches = lockManager.getResolvingPatches();
   if (unresolvedPatches.length > 0) {
     const applicator = new ReplayApplicator(git, lockManager, outputDir);
-    await applicator.applyPatches(unresolvedPatches);
+    await applicator.applyPatches(unresolvedPatches, { applyMode: "resolve" });
     const markerFiles = await findConflictMarkerFiles(git);
     if (markerFiles.length > 0) {
       for (const patch of unresolvedPatches) {
@@ -3827,20 +4687,80 @@ async function resolve(outputDir, options) {
   if (patchesToCommit.length > 0) {
     const currentGen = lock.current_generation;
     const detector = new ReplayDetector(git, lockManager, outputDir);
+    const warnings = [];
     let patchesResolved = 0;
+    const pass1 = [];
     for (const patch of patchesToCommit) {
-      const diff = await git.exec(["diff", currentGen, "--", ...patch.files]).catch(() => null);
-      if (!diff || !diff.trim()) {
+      const result = await computePerPatchDiffWithFallback(
+        patch,
+        (f) => git.showFile(currentGen, f),
+        (f) => (0, import_promises5.readFile)((0, import_node_path8.join)(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;
       }
-      const newContentHash = detector.computeContentHash(diff);
-      const changedFiles = await getChangedFiles(git, currentGen, patch.files);
+      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 (r.hadFallback) {
+        warnings.push(
+          `Patch ${patch.id}: ${r.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
+        );
+      }
+      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 (0, import_promises5.readFile)((0, import_node_path8.join)(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
+        files: filesForSnapshot,
+        ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
       });
       patchesResolved++;
     }
@@ -3856,7 +4776,8 @@ async function resolve(outputDir, options) {
       success: true,
       commitSha: commitSha2,
       phase: "committed",
-      patchesResolved
+      patchesResolved,
+      warnings: warnings.length > 0 ? warnings : void 0
     };
   }
   const committer = new ReplayCommitter(git, outputDir);
@@ -3874,6 +4795,24 @@ async function getChangedFiles(git, currentGen, files) {
   const changed = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !f.startsWith(".fern/"));
   return changed.length > 0 ? changed : files;
 }
+function extractFilesFromDiff(unifiedDiff2) {
+  const out = /* @__PURE__ */ new Set();
+  const renameSources = /* @__PURE__ */ new Set();
+  let currentTarget = null;
+  for (const line of unifiedDiff2.split("\n")) {
+    const headerMatch = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (headerMatch) {
+      currentTarget = headerMatch[2];
+      if (!currentTarget.startsWith(".fern/")) out.add(currentTarget);
+      continue;
+    }
+    if (currentTarget && line.startsWith("rename from ")) {
+      renameSources.add(line.slice("rename from ".length));
+    }
+  }
+  for (const src of renameSources) out.delete(src);
+  return Array.from(out);
+}
 
 // src/commands/status.ts
 function status(outputDir) {