@fern-api/generator-cli 0.9.21 → 0.9.22

package/dist/cli.js

@@ -7031,18 +7031,18 @@ var require_build3 = __commonJS({
 var require_sync = __commonJS({
   "../../node_modules/.pnpm/escalade@3.2.0/node_modules/escalade/sync/index.js"(exports2, module2) {
     "use strict";
-    var { dirname: dirname4, resolve: resolve8 } = require("path");
+    var { dirname: dirname5, resolve: resolve8 } = require("path");
     var { readdirSync: readdirSync2, statSync: statSync4 } = require("fs");
     module2.exports = function(start, callback) {
       let dir = resolve8(".", start);
       let tmp3, stats = statSync4(dir);
       if (!stats.isDirectory()) {
-        dir = dirname4(dir);
+        dir = dirname5(dir);
       }
       while (true) {
         tmp3 = callback(dir, readdirSync2(dir));
         if (tmp3) return resolve8(dir, tmp3);
-        dir = dirname4(tmp3 = dir);
+        dir = dirname5(tmp3 = dir);
         if (tmp3 === dir) break;
       }
     };
@@ -7078,9 +7078,9 @@ var require_require_directory = __commonJS({
   "../../node_modules/.pnpm/require-directory@2.1.1/node_modules/require-directory/index.js"(exports2, module2) {
     "use strict";
     var fs3 = require("fs");
-    var join14 = require("path").join;
+    var join15 = require("path").join;
     var resolve8 = require("path").resolve;
-    var dirname4 = require("path").dirname;
+    var dirname5 = require("path").dirname;
     var defaultOptions2 = {
       extensions: ["js", "json", "coffee"],
       recurse: true,
@@ -7113,9 +7113,9 @@ var require_require_directory = __commonJS({
           options[prop] = defaultOptions2[prop];
         }
       }
-      path5 = !path5 ? dirname4(m.filename) : resolve8(dirname4(m.filename), path5);
+      path5 = !path5 ? dirname5(m.filename) : resolve8(dirname5(m.filename), path5);
       fs3.readdirSync(path5).forEach(function(filename) {
-        var joined = join14(path5, filename), files, key, obj;
+        var joined = join15(path5, filename), files, key, obj;
         if (fs3.statSync(joined).isDirectory() && options.recurse) {
           files = requireDirectory(m, joined, options);
           if (Object.keys(files).length) {
@@ -22028,7 +22028,7 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.14.0/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.14.1/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   CREDENTIAL_PATTERNS: () => CREDENTIAL_PATTERNS,
@@ -22293,6 +22293,48 @@ function reconstructFromGhostPatch(fileDiff, ours) {
   }
   return assembleHybrid(located, oursLines);
 }
+async function applyPatchToContent(base, patchContent, filePath) {
+  const fileDiff = extractFileDiff(patchContent, filePath);
+  if (!fileDiff) return null;
+  const tempDir = await (0, import_promises3.mkdtemp)((0, import_path7.join)((0, import_os.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_path7.join)(tempDir, filePath);
+    await (0, import_promises3.mkdir)((0, import_path7.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 match2 = line.match(/^diff --git a\/.+ b\/(.+)$/);
+      if (match2 && match2[1] === filePath) {
+        inTarget = true;
+        out.push(line);
+      }
+      continue;
+    }
+    if (inTarget) out.push(line);
+  }
+  return out.length > 0 ? out.join("\n") + "\n" : null;
+}
 function isSensitiveFile(filePath) {
   return SENSITIVE_FILE_PATTERNS.some((re) => re.test(filePath));
 }
@@ -22328,36 +22370,73 @@ function parseRevertedMessage(subject) {
   const match2 = subject.match(/^Revert "(.+)"$/);
   return match2?.[1];
 }
-function parsePatchFileHeaders(patchContent) {
-  const results = [];
-  let currentPath = null;
-  let currentIsCreate = false;
-  let currentIsDelete = false;
-  const flush2 = () => {
-    if (currentPath !== null) {
-      results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
+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 j2 = i + 1;
+      let found = false;
+      while (j2 < lines.length) {
+        const trimmed2 = trimCR(lines[j2]);
+        if (trimmed2 === CONFLICT_OPENER) {
+          break;
+        }
+        if (separatorIdx === -1 && trimmed2 === CONFLICT_SEPARATOR) {
+          separatorIdx = j2;
+        } else if (separatorIdx !== -1 && trimmed2 === CONFLICT_CLOSER) {
+          ranges.push({ start: i, separator: separatorIdx, end: j2 });
+          i = j2;
+          found = true;
+          break;
+        }
+        j2++;
+      }
+      if (!found) {
+        i++;
+        continue;
+      }
     }
-  };
-  for (const line of patchContent.split("\n")) {
-    if (line.startsWith("diff --git ")) {
-      flush2();
-      currentPath = null;
-      currentIsCreate = false;
-      currentIsDelete = false;
-      const match2 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
-      if (match2) {
-        currentPath = match2[2] ?? null;
+    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 range2 = ranges[rangeIdx];
+      if (i === range2.start) {
+        continue;
       }
-    } else if (currentPath !== null) {
-      if (line.startsWith("new file mode ")) {
-        currentIsCreate = true;
-      } else if (line.startsWith("deleted file mode ")) {
-        currentIsDelete = true;
+      if (i > range2.start && i < range2.separator) {
+        result.push(lines[i]);
+        continue;
+      }
+      if (i === range2.separator) {
+        continue;
+      }
+      if (i > range2.separator && i < range2.end) {
+        continue;
+      }
+      if (i === range2.end) {
+        rangeIdx++;
+        continue;
       }
     }
+    result.push(lines[i]);
   }
-  flush2();
-  return results;
+  return result.join("\n");
 }
 function threeWayMerge(base, ours, theirs) {
   const baseLines = base.split("\n");
@@ -22495,76 +22574,8 @@ function applyBothPatches(baseLines, oursPatches, theirsPatches) {
   }
   return result;
 }
-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 j2 = i + 1;
-      let found = false;
-      while (j2 < lines.length) {
-        const trimmed2 = trimCR(lines[j2]);
-        if (trimmed2 === CONFLICT_OPENER) {
-          break;
-        }
-        if (separatorIdx === -1 && trimmed2 === CONFLICT_SEPARATOR) {
-          separatorIdx = j2;
-        } else if (separatorIdx !== -1 && trimmed2 === CONFLICT_CLOSER) {
-          ranges.push({ start: i, separator: separatorIdx, end: j2 });
-          i = j2;
-          found = true;
-          break;
-        }
-        j2++;
-      }
-      if (!found) {
-        i++;
-        continue;
-      }
-    }
-    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 range2 = ranges[rangeIdx];
-      if (i === range2.start) {
-        continue;
-      }
-      if (i > range2.start && i < range2.separator) {
-        result.push(lines[i]);
-        continue;
-      }
-      if (i === range2.separator) {
-        continue;
-      }
-      if (i > range2.separator && i < range2.end) {
-        continue;
-      }
-      if (i === range2.end) {
-        rangeIdx++;
-        continue;
-      }
-    }
-    result.push(lines[i]);
-  }
-  return result.join("\n");
-}
 function isBinaryFile(filePath) {
-  const ext2 = (0, import_path8.extname)(filePath).toLowerCase();
+  const ext2 = (0, import_path9.extname)(filePath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext2);
 }
 function computeDroppedContextLinesForFile(base, theirs, finalContent) {
@@ -22595,6 +22606,37 @@ function isDiffLineForFile(diffLine, filePath) {
   const match2 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
   return match2 !== null && match2[1] === filePath;
 }
+function parsePatchFileHeaders(patchContent) {
+  const results = [];
+  let currentPath = null;
+  let currentIsCreate = false;
+  let currentIsDelete = false;
+  const flush2 = () => {
+    if (currentPath !== null) {
+      results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
+    }
+  };
+  for (const line of patchContent.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush2();
+      currentPath = null;
+      currentIsCreate = false;
+      currentIsDelete = false;
+      const match2 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+      if (match2) {
+        currentPath = match2[2] ?? null;
+      }
+    } else if (currentPath !== null) {
+      if (line.startsWith("new file mode ")) {
+        currentIsCreate = true;
+      } else if (line.startsWith("deleted file mode ")) {
+        currentIsDelete = true;
+      }
+    }
+  }
+  flush2();
+  return results;
+}
 function normalizeHunkBody(hunk) {
   let contextC = 0;
   let removeC = 0;
@@ -22644,13 +22686,13 @@ async function computePerPatchDiff(patch, getCurrentGenContent, getWorkingTreeCo
     const hunksRaw = parseHunks(fileDiff).map(normalizeHunkBody);
     const hunks = hunksRaw.filter((h) => {
       if (h.lines.length === 0) return false;
-      let ctx = 0, rm3 = 0, add = 0;
+      let ctx = 0, rm4 = 0, add = 0;
       for (const ln of h.lines) {
         if (ln.type === "context") ctx++;
-        else if (ln.type === "remove") rm3++;
+        else if (ln.type === "remove") rm4++;
         else if (ln.type === "add") add++;
       }
-      return ctx + rm3 === h.oldCount && ctx + add === h.newCount;
+      return ctx + rm4 === h.oldCount && ctx + add === h.newCount;
     });
     if (hunks.length === 0) {
       if (hunksRaw.length > 0) unlocatableFiles.push(file);
@@ -22799,17 +22841,17 @@ function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locI
 }
 async function unifiedDiff(beforeContent, afterContent, filePath) {
   if (beforeContent === afterContent) return "";
-  const tmp3 = await (0, import_promises4.mkdtemp)((0, import_path10.join)((0, import_os2.tmpdir)(), "fern-replay-pp-"));
+  const tmp3 = await (0, import_promises6.mkdtemp)((0, import_path11.join)((0, import_os3.tmpdir)(), "fern-replay-pp-"));
   try {
-    const beforePath = (0, import_path10.join)(tmp3, "before");
-    const afterPath = (0, import_path10.join)(tmp3, "after");
-    await (0, import_promises4.writeFile)(beforePath, beforeContent, "utf-8");
-    await (0, import_promises4.writeFile)(afterPath, afterContent, "utf-8");
+    const beforePath = (0, import_path11.join)(tmp3, "before");
+    const afterPath = (0, import_path11.join)(tmp3, "after");
+    await (0, import_promises6.writeFile)(beforePath, beforeContent, "utf-8");
+    await (0, import_promises6.writeFile)(afterPath, afterContent, "utf-8");
     const raw = await runGitDiffNoIndex(beforePath, afterPath);
     if (!raw.trim()) return "";
     return rewriteDiffHeaders(raw, filePath);
   } finally {
-    await (0, import_promises4.rm)(tmp3, { recursive: true, force: true });
+    await (0, import_promises6.rm)(tmp3, { recursive: true, force: true });
   }
 }
 function runGitDiffNoIndex(beforePath, afterPath) {
@@ -23071,7 +23113,7 @@ function parseGitLog(log) {
   });
 }
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_path12.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_path13.join)(outputDir, ".fernignore");
   let content = "";
   if ((0, import_fs9.existsSync)(fernignorePath)) {
     content = (0, import_fs9.readFileSync)(fernignorePath, "utf-8");
@@ -23094,7 +23136,7 @@ function ensureFernignoreEntries(outputDir) {
   return true;
 }
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = (0, import_path12.join)(outputDir, ".gitattributes");
+  const gitattributesPath = (0, import_path13.join)(outputDir, ".gitattributes");
   let content = "";
   if ((0, import_fs9.existsSync)(gitattributesPath)) {
     content = (0, import_fs9.readFileSync)(gitattributesPath, "utf-8");
@@ -23317,36 +23359,78 @@ async function resolve7(outputDir, options) {
     const detector = new ReplayDetector(git, lockManager, outputDir);
     const warnings = [];
     let patchesResolved = 0;
+    const pass1 = [];
     for (const patch of patchesToCommit) {
       const result = await computePerPatchDiffWithFallback(
         patch,
         (f2) => git.showFile(currentGen, f2),
-        (f2) => (0, import_promises5.readFile)((0, import_path13.join)(outputDir, f2), "utf-8").catch(() => null),
+        (f2) => (0, import_promises7.readFile)((0, import_path14.join)(outputDir, f2), "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 r2 = pass1[i];
+      if (r2.kind === "apply") lastIndexByHash.set(r2.hash, i);
+    }
+    for (let i = 0; i < patchesToCommit.length; i++) {
+      const patch = patchesToCommit[i];
+      const r2 = pass1[i];
+      if (r2.kind === "skip") continue;
+      if (r2.kind === "revert") {
+        lockManager.removePatch(patch.id);
+        continue;
+      }
+      if (lastIndexByHash.get(r2.hash) !== i) {
+        const canonicalIdx = lastIndexByHash.get(r2.hash);
+        const canonical = patchesToCommit[canonicalIdx];
         lockManager.removePatch(patch.id);
+        warnings.push(
+          `Consolidated patch ${patch.id} (commit ${(patch.original_commit || "<missing>").slice(0, 7)}) into patch ${canonical.id} (commit ${(canonical.original_commit || "<missing>").slice(0, 7)}): byte-identical patch_content after resolution. Per-commit attribution preserved in git log; lockfile collapsed to avoid duplicate-apply corruption on next regen.`
+        );
         continue;
       }
-      if (result.hadFallback) {
+      if (r2.hadFallback) {
         warnings.push(
-          `Patch ${patch.id}: ${result.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
+          `Patch ${patch.id}: ${r2.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
         );
       }
-      const newContentHash = detector.computeContentHash(diff);
-      const changedFiles = result.hadFallback ? await getChangedFiles(git, currentGen, patch.files) : extractFilesFromDiff(diff);
+      const changedFiles = r2.hadFallback ? await getChangedFiles(git, currentGen, patch.files) : extractFilesFromDiff(r2.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_promises7.readFile)((0, import_path14.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: r2.diff,
+        content_hash: r2.hash,
         base_generation: currentGen,
-        files: changedFiles.length > 0 ? changedFiles : patch.files
+        files: filesForSnapshot,
+        ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
       });
       patchesResolved++;
     }
@@ -23446,39 +23530,43 @@ function status(outputDir) {
     excludePatterns
   };
 }
-var import_fs6, import_path7, import_yaml, import_crypto, import_promises3, import_os, import_path8, import_fs7, import_path9, import_promises4, import_os2, import_path10, import_child_process3, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, import_promises5, import_path13, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, CREDENTIAL_PATTERNS, SENSITIVE_FILE_PATTERNS, FERN_BOT_NAME, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
+var import_promises3, import_os, import_path7, import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os2, import_path9, import_fs7, import_promises5, import_path10, import_promises6, import_os3, import_path11, import_child_process3, import_crypto2, import_fs8, import_path12, import_yaml2, import_crypto3, import_fs9, import_path13, import_fs10, import_promises7, import_path14, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, PatchApplyTheirs_exports, init_PatchApplyTheirs, CREDENTIAL_PATTERNS, SENSITIVE_FILE_PATTERNS, FERN_BOT_NAME, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, BINARY_EXTENSIONS, ReplayApplicator, INFRASTRUCTURE_FILES, ReplayDetector, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
 var init_dist3 = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.14.0/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.14.1/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
-    import_fs6 = require("fs");
-    import_path7 = require("path");
-    import_yaml = __toESM(require_dist3(), 1);
-    import_crypto = require("crypto");
-    init_diff3();
     import_promises3 = require("fs/promises");
     import_os = require("os");
+    import_path7 = require("path");
+    import_fs6 = require("fs");
     import_path8 = require("path");
-    init_esm3();
-    import_fs7 = require("fs");
-    import_path9 = require("path");
-    init_esm3();
+    import_yaml = __toESM(require_dist3(), 1);
+    import_crypto = require("crypto");
     import_promises4 = require("fs/promises");
     import_os2 = require("os");
+    import_path9 = require("path");
+    init_esm3();
+    init_diff3();
+    import_fs7 = require("fs");
+    import_promises5 = require("fs/promises");
     import_path10 = require("path");
+    init_esm3();
+    import_promises6 = require("fs/promises");
+    import_os3 = require("os");
+    import_path11 = require("path");
     import_child_process3 = require("child_process");
     import_crypto2 = require("crypto");
     import_fs8 = require("fs");
-    import_path11 = require("path");
+    import_path12 = require("path");
     init_esm3();
     import_yaml2 = __toESM(require_dist3(), 1);
     import_crypto3 = require("crypto");
     import_fs9 = require("fs");
-    import_path12 = require("path");
+    import_path13 = require("path");
     init_esm3();
     import_fs10 = require("fs");
-    import_promises5 = require("fs/promises");
-    import_path13 = require("path");
+    import_promises7 = require("fs/promises");
+    import_path14 = require("path");
     __defProp3 = Object.defineProperty;
     __getOwnPropNames3 = Object.getOwnPropertyNames;
     __esm3 = (fn, res) => function __init() {
@@ -23634,6 +23722,16 @@ var init_dist3 = __esm({
         "use strict";
       }
     });
+    PatchApplyTheirs_exports = {};
+    __export3(PatchApplyTheirs_exports, {
+      applyPatchToContent: () => applyPatchToContent
+    });
+    init_PatchApplyTheirs = __esm3({
+      "src/PatchApplyTheirs.ts"() {
+        "use strict";
+        init_GitClient();
+      }
+    });
     CREDENTIAL_PATTERNS = [
       { name: "PRIVATE KEY block", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
       { name: "OPENSSH key", re: /-----BEGIN OPENSSH PRIVATE KEY-----/ },
@@ -23673,10 +23771,10 @@ var init_dist3 = __esm({
         this.outputDir = outputDir;
       }
       get lockfilePath() {
-        return (0, import_path7.join)(this.outputDir, ".fern", "replay.lock");
+        return (0, import_path8.join)(this.outputDir, ".fern", "replay.lock");
       }
       get customizationsPath() {
-        return (0, import_path7.join)(this.outputDir, ".fern", "replay.yml");
+        return (0, import_path8.join)(this.outputDir, ".fern", "replay.yml");
       }
       exists() {
         return (0, import_fs6.existsSync)(this.lockfilePath);
@@ -23720,7 +23818,17 @@ var init_dist3 = __esm({
         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 x2 of m) {
+                if (!snapshotMatches.includes(x2)) snapshotMatches.push(x2);
+              }
+            }
+          }
+          const credentialMatches = [...diffMatches, ...snapshotMatches.filter((m) => !diffMatches.includes(m))];
           const sensitiveFiles = patch.files.filter((f2) => isSensitiveFile(f2));
           if (credentialMatches.length > 0 || sensitiveFiles.length > 0) {
             const reasons = [];
@@ -23738,7 +23846,7 @@ var init_dist3 = __esm({
           }
         }
         this.lock.patches = cleanPatches;
-        const dir = (0, import_path7.dirname)(this.lockfilePath);
+        const dir = (0, import_path8.dirname)(this.lockfilePath);
         if (!(0, import_fs6.existsSync)(dir)) {
           (0, import_fs6.mkdirSync)(dir, { recursive: true });
         }
@@ -23838,716 +23946,210 @@ var init_dist3 = __esm({
         }
       }
     };
-    INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
-    ReplayDetector = class {
+    CONFLICT_OPENER = "<<<<<<< Generated";
+    CONFLICT_SEPARATOR = "=======";
+    CONFLICT_CLOSER = ">>>>>>> Your customization";
+    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"
+    ]);
+    ReplayApplicator = class {
       git;
       lockManager;
-      sdkOutputDir;
-      warnings = [];
-      constructor(git, lockManager, sdkOutputDir) {
+      outputDir;
+      renameCache = /* @__PURE__ */ new Map();
+      treeExistsCache = /* @__PURE__ */ new Map();
+      fileTheirsAccumulator = /* @__PURE__ */ new Map();
+      /**
+       * Apply mode for the current `applyPatches` invocation. Set at the start
+       * of `applyPatches`, read by `mergeFile` to decide:
+       *   - whether to skip the intra-loop marker strip (kept in `applyPatches`)
+       *   - whether to populate the accumulator after a conflicted merge
+       *     (resolve mode populates so subsequent patches on the same file
+       *     can use patch A's THEIRS as a structurally-correct merge base
+       *     when their diff was authored against post-A structure)
+       *   - whether to retry THEIRS reconstruction against the accumulator
+       *     when the BASE-relative reconstruction produced markers from a
+       *     cross-patch context mismatch
+       */
+      currentApplyMode = "replay";
+      /**
+       * Set of files that appear in 2+ patches in the current `applyPatches`
+       * invocation. Computed at the top of `applyPatches`. Read by `mergeFile`
+       * and `populateAccumulatorForPatch` to decide whether to use the patch's
+       * `theirs_snapshot` directly as THEIRS (snapshot-as-primary) or fall
+       * back to line-anchored reconstruction (FER-9525 cross-patch isolation).
+       *
+       * Snapshot-as-primary is correct when the patch owns its file (no other
+       * patch in this run touches it): the snapshot is what the customer
+       * intends for that file post-regen, regardless of generator structural
+       * changes that would invalidate the diff's line anchors.
+       *
+       * When a file IS shared, snapshots are CUMULATIVE across the patches
+       * touching it (each one's snapshot includes prior patches' contributions).
+       * Using a later patch's cumulative snapshot as its individual THEIRS
+       * would propagate prior patches' edits into the merge — surfacing nested
+       * conflicts at regions the patch alone never touched. Reconstruction
+       * via `applyPatchToContent` is required there.
+       */
+      sharedFiles = /* @__PURE__ */ new Set();
+      constructor(git, lockManager, outputDir) {
         this.git = git;
         this.lockManager = lockManager;
-        this.sdkOutputDir = sdkOutputDir;
-      }
-      async detectNewPatches() {
-        const lock = this.lockManager.read();
-        const lastGen = this.getLastGeneration(lock);
-        if (!lastGen) {
-          return { patches: [], revertedPatchIds: [] };
-        }
-        const exists2 = await this.git.commitExists(lastGen.commit_sha);
-        if (!exists2) {
-          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);
+        this.outputDir = outputDir;
       }
       /**
-       * 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).
+       * 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 detectPatchesViaMergeBase(lastGen, lock) {
-        let mergeBase = "";
+      async resolveBaseGeneration(baseGeneration) {
+        const gen = this.lockManager.getGeneration(baseGeneration);
+        if (gen) return gen;
         try {
-          mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
+          const treeHash = await this.git.getTreeHash(baseGeneration);
+          return {
+            commit_sha: baseGeneration,
+            tree_hash: treeHash,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            cli_version: "unknown",
+            generator_versions: {}
+          };
         } catch {
+          return void 0;
         }
-        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
-          );
+      }
+      /** 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 [path5, entry] of this.fileTheirsAccumulator) {
+          snapshot.set(path5, { content: entry.content, baseGeneration: entry.baseGeneration });
         }
-        return this.detectPatchesInRange(mergeBase, lastGen, lock);
+        return snapshot;
       }
       /**
-       * 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.
+       * Apply all patches, returning results for each.
+       * Skips patches that match exclude patterns in replay.yml
        *
-       * 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.
+       * `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 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;
+      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 f2 of p.files) {
+            fileFreq.set(f2, (fileFreq.get(f2) ?? 0) + 1);
           }
-          if (lock.patches.find((p) => p.original_commit === commit.sha)) {
+        }
+        this.sharedFiles = new Set(
+          Array.from(fileFreq.entries()).filter(([, n]) => n > 1).map(([f2]) => f2)
+        );
+        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 parents = await this.git.getCommitParents(commit.sha);
-          if (parents.length > 1) {
-            const compositePatch = await this.createMergeCompositePatch({
-              mergeCommit: commit,
-              firstParent: parents[0],
-              lastGen,
-              lock
-            });
-            if (compositePatch) {
-              newPatches.push(compositePatch);
-            }
-            continue;
-          }
-          let 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;
-          }
-          let contentHash = this.computeContentHash(patchContent);
-          if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
-            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((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
-          const sensitiveFiles = allFiles.filter((f2) => isSensitiveFile(f2));
-          const files = allFiles.filter((f2) => !isSensitiveFile(f2));
-          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) {
-            continue;
-          }
-          newPatches.push({
-            id: `patch-${commit.sha.slice(0, 8)}`,
-            content_hash: contentHash,
-            original_commit: commit.sha,
-            original_message: commit.message,
-            original_author: `${commit.authorName} <${commit.authorEmail}>`,
-            base_generation: lastGen.commit_sha,
-            files,
-            patch_content: patchContent,
-            ...this.isCreationOnlyPatch(patchContent) ? { user_owned: true } : {}
-          });
-        }
-        const survivingPatches = await this.collapseNetZeroFiles(newPatches);
-        survivingPatches.reverse();
-        const revertedPatchIdSet = /* @__PURE__ */ new Set();
-        const revertIndicesToRemove = /* @__PURE__ */ new Set();
-        for (let i = 0; i < survivingPatches.length; i++) {
-          const patch = survivingPatches[i];
-          if (!isRevertCommit(patch.original_message)) continue;
-          let body = "";
-          try {
-            body = await this.git.getCommitBody(patch.original_commit);
-          } catch {
-          }
-          const revertedSha = parseRevertedSha(body);
-          const revertedMessage = parseRevertedMessage(patch.original_message);
-          let matchedExisting = false;
-          if (revertedSha) {
-            const existing = lock.patches.find((p) => p.original_commit === revertedSha);
-            if (existing) {
-              revertedPatchIdSet.add(existing.id);
-              revertIndicesToRemove.add(i);
-              matchedExisting = true;
-            }
-          }
-          if (!matchedExisting && revertedMessage) {
-            const existing = lock.patches.find((p) => p.original_message === revertedMessage);
-            if (existing) {
-              revertedPatchIdSet.add(existing.id);
-              revertIndicesToRemove.add(i);
-              matchedExisting = true;
-            }
-          }
-          if (matchedExisting) continue;
-          let matchedNew = false;
-          if (revertedSha) {
-            const idx = survivingPatches.findIndex(
-              (p, j2) => j2 !== i && !revertIndicesToRemove.has(j2) && p.original_commit === revertedSha
-            );
-            if (idx !== -1) {
-              revertIndicesToRemove.add(i);
-              revertIndicesToRemove.add(idx);
-              matchedNew = true;
-            }
-          }
-          if (!matchedNew && revertedMessage) {
-            const idx = survivingPatches.findIndex(
-              (p, j2) => j2 !== i && !revertIndicesToRemove.has(j2) && p.original_message === revertedMessage
-            );
-            if (idx !== -1) {
-              revertIndicesToRemove.add(i);
-              revertIndicesToRemove.add(idx);
-            }
-          }
-          if (!matchedExisting && !matchedNew) {
-            revertIndicesToRemove.add(i);
-          }
-        }
-        const filteredPatches = survivingPatches.filter((_2, 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_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);
-          }
-        }
-        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((f2) => transient.has(f2)));
-      }
-      /**
-       * 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();
-        }
-      }
-      /**
-       * 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((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
-        const sensitiveMergeFiles = allMergeFiles.filter((f2) => isSensitiveFile(f2));
-        const files = allMergeFiles.filter((f2) => !isSensitiveFile(f2));
-        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 } : {}
-        };
-      }
-      /**
-       * 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 filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
-        const allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
-        const sensitiveTreeFiles = allTreeFiles.filter((f2) => isSensitiveFile(f2));
-        const files = allTreeFiles.filter((f2) => !isSensitiveFile(f2));
-        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 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: [] };
-      }
-      /**
-       * Last-resort detection when both generation commit and tree are unreachable.
-       * Scans all commits from HEAD, filters against known lockfile patches, and
-       * skips creation-only commits (squashed history after force push).
-       *
-       * Detected patches use the commit's parent as base_generation so the applicator
-       * can find base file content from the parent's tree (which IS reachable).
-       */
-      async detectPatchesViaCommitScan() {
-        const lock = this.lockManager.read();
-        const log = await this.git.exec([
-          "log",
-          "--max-count=200",
-          "--format=%H%x00%an%x00%ae%x00%s",
-          "HEAD",
-          "--",
-          this.sdkOutputDir
-        ]);
-        if (!log.trim()) {
-          return { patches: [], revertedPatchIds: [] };
-        }
-        const commits = this.parseGitLog(log);
-        const newPatches = [];
-        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
-        const existingHashes = new Set(lock.patches.map((p) => p.content_hash));
-        const existingCommits = new Set(lock.patches.map((p) => p.original_commit));
-        for (const commit of commits) {
-          if (isGenerationCommit(commit)) {
-            continue;
-          }
-          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;
-          }
-          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((f2) => !INFRASTRUCTURE_FILES.has(f2));
-          const sensitiveScanFiles = allScanFiles.filter((f2) => isSensitiveFile(f2));
-          const files = allScanFiles.filter((f2) => !isSensitiveFile(f2));
-          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 (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: [] };
-      }
-      /**
-       * Check if a format-patch consists entirely of new-file creations.
-       * Used to identify squashed commits after force push, which create all files
-       * from scratch (--- /dev/null) rather than modifying existing files.
-       */
-      isCreationOnlyPatch(patchContent) {
-        const diffOldHeaders = patchContent.split("\n").filter((l) => l.startsWith("--- "));
-        if (diffOldHeaders.length === 0) {
-          return false;
-        }
-        return diffOldHeaders.every((l) => l === "--- /dev/null");
-      }
-      /**
-       * 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((g2) => g2.commit_sha === lock.current_generation);
-      }
-    };
-    CONFLICT_OPENER = "<<<<<<< Generated";
-    CONFLICT_SEPARATOR = "=======";
-    CONFLICT_CLOSER = ">>>>>>> Your customization";
-    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"
-    ]);
-    ReplayApplicator = class {
-      git;
-      lockManager;
-      outputDir;
-      renameCache = /* @__PURE__ */ new Map();
-      treeExistsCache = /* @__PURE__ */ new Map();
-      fileTheirsAccumulator = /* @__PURE__ */ new Map();
-      /**
-       * Apply mode for the current `applyPatches` invocation. Set at the start
-       * of `applyPatches`, read by `mergeFile` to decide:
-       *   - whether to skip the intra-loop marker strip (kept in `applyPatches`)
-       *   - whether to populate the accumulator after a conflicted merge
-       *     (resolve mode populates so subsequent patches on the same file
-       *     can use patch A's THEIRS as a structurally-correct merge base
-       *     when their diff was authored against post-A structure)
-       *   - whether to retry THEIRS reconstruction against the accumulator
-       *     when the BASE-relative reconstruction produced markers from a
-       *     cross-patch context mismatch
-       */
-      currentApplyMode = "replay";
-      constructor(git, lockManager, outputDir) {
-        this.git = git;
-        this.lockManager = lockManager;
-        this.outputDir = outputDir;
-      }
-      /**
-       * Resolve the GenerationRecord for a patch's base_generation.
-       * Falls back to constructing an ad-hoc record from the commit's tree
-       * when base_generation isn't a tracked generation (commit-scan patches).
-       */
-      async resolveBaseGeneration(baseGeneration) {
-        const gen = this.lockManager.getGeneration(baseGeneration);
-        if (gen) return gen;
-        try {
-          const treeHash = await this.git.getTreeHash(baseGeneration);
-          return {
-            commit_sha: baseGeneration,
-            tree_hash: treeHash,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            cli_version: "unknown",
-            generator_versions: {}
-          };
-        } 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 [path5, entry] of this.fileTheirsAccumulator) {
-          snapshot.set(path5, { content: entry.content, baseGeneration: entry.baseGeneration });
-        }
-        return snapshot;
-      }
-      /**
-       * Apply all patches, returning results for each.
-       * Skips patches that match exclude patterns in replay.yml
-       *
-       * `applyMode` controls the post-conflict marker strategy:
-       *   - `"replay"` (default): strip conflict markers from disk between
-       *     iterations whenever a later patch touches the same file. Lets the
-       *     follow-up patch's `git apply --3way` see clean OURS content,
-       *     which is what the silent-loss fix (PR #73) relies on. The replay
-       *     pipeline calls `revertConflictingFiles` after the loop to clean
-       *     any markers that survive.
-       *   - `"resolve"`: keep markers on disk. The resolve command needs the
-       *     customer to see them. Slow-path 3-way merge naturally preserves
-       *     A's markers and B's clean writes when their regions don't overlap;
-       *     when they do overlap, the customer gets nested markers and
-       *     resolves manually. Either way they aren't silently dropped.
-       */
-      async applyPatches(patches, opts) {
-        const applyMode = opts?.applyMode ?? "replay";
-        this.currentApplyMode = applyMode;
-        this.resetAccumulator();
-        const results = [];
-        for (let i = 0; i < patches.length; i++) {
-          const patch = patches[i];
-          if (this.isExcluded(patch)) {
-            results.push({
-              patch,
-              status: "skipped",
-              method: "git-am"
-            });
-            continue;
-          }
-          const result = await this.applyPatchWithFallback(patch);
-          results.push(result);
-          if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
-            const laterFiles = /* @__PURE__ */ new Set();
-            for (let j2 = i + 1; j2 < patches.length; j2++) {
-              for (const f2 of patches[j2].files) {
-                laterFiles.add(f2);
-              }
-            }
-            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_path8.join)(this.outputDir, fileResult.file);
-                try {
-                  const content = await (0, import_promises3.readFile)(filePath, "utf-8");
-                  const stripped = stripConflictMarkers(content);
-                  await (0, import_promises3.writeFile)(filePath, stripped);
-                } catch {
-                }
-              }
+          const result = await this.applyPatchWithFallback(patch);
+          results.push(result);
+          if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
+            const laterFiles = /* @__PURE__ */ new Set();
+            for (let j2 = i + 1; j2 < patches.length; j2++) {
+              for (const f2 of patches[j2].files) {
+                laterFiles.add(f2);
+              }
+            }
+            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_path9.join)(this.outputDir, fileResult.file);
+                try {
+                  const content = await (0, import_promises4.readFile)(filePath, "utf-8");
+                  const stripped = stripConflictMarkers(content);
+                  await (0, import_promises4.writeFile)(filePath, stripped);
+                } catch {
+                }
+              }
             }
           }
         }
@@ -24564,7 +24166,7 @@ var init_dist3 = __esm({
       async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
         const fileResults = [];
         if (!baseGen) return fileResults;
-        const tempDir = await (0, import_promises3.mkdtemp)((0, import_path8.join)((0, import_os.tmpdir)(), "replay-acc-"));
+        const tempDir = await (0, import_promises4.mkdtemp)((0, import_path9.join)((0, import_os2.tmpdir)(), "replay-acc-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir);
         await tempGit.exec(["init"]);
@@ -24575,8 +24177,10 @@ var init_dist3 = __esm({
             if (isBinaryFile(filePath)) continue;
             const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
             const base = await this.git.showFile(baseGen.tree_hash, filePath);
-            const theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
-            const finalOnDisk = await (0, import_promises3.readFile)((0, import_path8.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+            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_promises4.readFile)((0, import_path9.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
             const effectiveTheirs = theirs ?? finalOnDisk;
             if (effectiveTheirs != null) {
               this.fileTheirsAccumulator.set(resolvedPath, {
@@ -24596,7 +24200,7 @@ var init_dist3 = __esm({
             }
           }
         } finally {
-          await (0, import_promises3.rm)(tempDir, { recursive: true }).catch(() => {
+          await (0, import_promises4.rm)(tempDir, { recursive: true }).catch(() => {
           });
         }
         return fileResults;
@@ -24625,8 +24229,8 @@ var init_dist3 = __esm({
         if (!needsAccumulation && !hasGeneratorRename) {
           const snapshots = /* @__PURE__ */ new Map();
           for (const filePath of patch.files) {
-            const fullPath = (0, import_path8.join)(this.outputDir, filePath);
-            snapshots.set(filePath, await (0, import_promises3.readFile)(fullPath, "utf-8").catch(() => null));
+            const fullPath = (0, import_path9.join)(this.outputDir, filePath);
+            snapshots.set(filePath, await (0, import_promises4.readFile)(fullPath, "utf-8").catch(() => null));
           }
           try {
             await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
@@ -24640,11 +24244,11 @@ var init_dist3 = __esm({
             };
           } catch {
             for (const [filePath, content] of snapshots) {
-              const fullPath = (0, import_path8.join)(this.outputDir, filePath);
+              const fullPath = (0, import_path9.join)(this.outputDir, filePath);
               if (content != null) {
-                await (0, import_promises3.writeFile)(fullPath, content);
+                await (0, import_promises4.writeFile)(fullPath, content);
               } else {
-                await (0, import_promises3.unlink)(fullPath).catch(() => {
+                await (0, import_promises4.unlink)(fullPath).catch(() => {
                 });
               }
             }
@@ -24655,7 +24259,7 @@ var init_dist3 = __esm({
       async applyWithThreeWayMerge(patch) {
         const fileResults = [];
         const resolvedFiles = {};
-        const tempDir = await (0, import_promises3.mkdtemp)((0, import_path8.join)((0, import_os.tmpdir)(), "replay-"));
+        const tempDir = await (0, import_promises4.mkdtemp)((0, import_path9.join)((0, import_os2.tmpdir)(), "replay-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir);
         await tempGit.exec(["init"]);
@@ -24678,7 +24282,7 @@ var init_dist3 = __esm({
             fileResults.push(result);
           }
         } finally {
-          await (0, import_promises3.rm)(tempDir, { recursive: true }).catch(() => {
+          await (0, import_promises4.rm)(tempDir, { recursive: true }).catch(() => {
           });
         }
         const conflictFiles = fileResults.filter((r2) => r2.status === "conflict");
@@ -24718,8 +24322,8 @@ var init_dist3 = __esm({
               renameSourcePath = renameSource;
             }
           }
-          const oursPath = (0, import_path8.join)(this.outputDir, resolvedPath);
-          const ours = await (0, import_promises3.readFile)(oursPath, "utf-8").catch(() => null);
+          const oursPath = (0, import_path9.join)(this.outputDir, resolvedPath);
+          const ours = await (0, import_promises4.readFile)(oursPath, "utf-8").catch(() => null);
           let ghostReconstructed = false;
           let theirs = null;
           if (!base && ours && !renameSourcePath) {
@@ -24737,15 +24341,27 @@ var init_dist3 = __esm({
               }
             }
           }
+          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) {
-            theirs = await this.applyPatchToContent(
-              base,
-              patch.patch_content,
-              filePath,
-              tempGit,
-              tempDir,
-              renameSourcePath
-            );
+            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;
+              }
+            }
           }
           const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
           if (theirs) {
@@ -24819,16 +24435,16 @@ var init_dist3 = __esm({
               content: effective_theirs,
               baseGeneration: patch.base_generation
             });
-            const outDir2 = (0, import_path8.dirname)(oursPath);
-            await (0, import_promises3.mkdir)(outDir2, { recursive: true });
-            await (0, import_promises3.writeFile)(oursPath, effective_theirs);
+            const outDir2 = (0, import_path9.dirname)(oursPath);
+            await (0, import_promises4.mkdir)(outDir2, { recursive: true });
+            await (0, import_promises4.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_path8.dirname)(oursPath);
-            await (0, import_promises3.mkdir)(outDir2, { recursive: true });
-            await (0, import_promises3.writeFile)(oursPath, merged2.content);
+            const outDir2 = (0, import_path9.dirname)(oursPath);
+            await (0, import_promises4.mkdir)(outDir2, { recursive: true });
+            await (0, import_promises4.writeFile)(oursPath, merged2.content);
             if (merged2.hasConflicts) {
               return {
                 file: resolvedPath,
@@ -24867,9 +24483,9 @@ var init_dist3 = __esm({
             };
           }
           const merged = threeWayMerge(mergeBase, ours, effective_theirs);
-          const outDir = (0, import_path8.dirname)(oursPath);
-          await (0, import_promises3.mkdir)(outDir, { recursive: true });
-          await (0, import_promises3.writeFile)(oursPath, merged.content);
+          const outDir = (0, import_path9.dirname)(oursPath);
+          await (0, import_promises4.mkdir)(outDir, { recursive: true });
+          await (0, import_promises4.writeFile)(oursPath, merged.content);
           const populateAccumulator = effective_theirs != null && (!merged.hasConflicts || this.currentApplyMode === "resolve");
           if (populateAccumulator) {
             this.fileTheirsAccumulator.set(resolvedPath, {
@@ -24905,171 +24521,734 @@ var init_dist3 = __esm({
           result = await this.git.treeExists(treeHash);
           this.treeExistsCache.set(treeHash, result);
         }
-        return result;
+        return result;
+      }
+      isExcluded(patch) {
+        const config = this.lockManager.getCustomizationsConfig();
+        if (!config.exclude) return false;
+        return patch.files.some((file) => config.exclude.some((pattern) => minimatch(file, pattern)));
+      }
+      async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
+        const config = this.lockManager.getCustomizationsConfig();
+        if (config.moves) {
+          for (const move of config.moves) {
+            if (minimatch(filePath, move.from) || filePath === move.from) {
+              if (filePath === move.from) {
+                return move.to;
+              }
+              const fromBase = move.from.replace(/\*\*.*$/, "");
+              const toBase = move.to.replace(/\*\*.*$/, "");
+              if (filePath.startsWith(fromBase)) {
+                return toBase + filePath.slice(fromBase.length);
+              }
+            }
+          }
+        }
+        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((r2) => r2.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_path9.join)(tempDir, sourceFilePath);
+            await (0, import_promises4.mkdir)((0, import_path9.dirname)(tempSourcePath), { recursive: true });
+            await (0, import_promises4.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_path9.join)(tempDir, filePath);
+            return await (0, import_promises4.readFile)(tempTargetPath, "utf-8");
+          }
+          const tempFilePath = (0, import_path9.join)(tempDir, filePath);
+          await (0, import_promises4.mkdir)((0, import_path9.dirname)(tempFilePath), { recursive: true });
+          await (0, import_promises4.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_promises4.readFile)(tempFilePath, "utf-8");
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * 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 {
+          const tempFilePath = (0, import_path9.join)(tempDir, filePath);
+          await (0, import_promises4.mkdir)((0, import_path9.dirname)(tempFilePath), { recursive: true });
+          await (0, import_promises4.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);
+          }
+        }
+        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);
+            continue;
+          }
+          if (!inTargetFile) continue;
+          if (line.startsWith("@@")) break;
+          if (line.startsWith("rename from ")) {
+            return line.slice("rename from ".length);
+          }
+        }
+        return null;
+      }
+      extractNewFileFromPatch(patchContent, filePath) {
+        const lines = patchContent.split("\n");
+        const addedLines = [];
+        let inTargetFile = false;
+        let inHunk = false;
+        let isNewFile = false;
+        let noTrailingNewline = false;
+        for (const line of lines) {
+          if (line.startsWith("diff --git")) {
+            if (inTargetFile) break;
+            inTargetFile = isDiffLineForFile(line, filePath);
+            inHunk = false;
+            isNewFile = false;
+            continue;
+          }
+          if (!inTargetFile) continue;
+          if (!inHunk) {
+            if (line === "--- /dev/null" || line.startsWith("new file mode")) {
+              isNewFile = true;
+            }
+          }
+          if (line.startsWith("@@")) {
+            if (!isNewFile) return null;
+            inHunk = true;
+            continue;
+          }
+          if (!inHunk) continue;
+          if (line === "\") {
+            noTrailingNewline = true;
+            continue;
+          }
+          if (line.startsWith("+") && !line.startsWith("+++")) {
+            addedLines.push(line.slice(1));
+          }
+        }
+        if (addedLines.length === 0) return null;
+        return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
+      }
+    };
+    INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
+    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 exists2 = await this.git.commitExists(lastGen.commit_sha);
+        if (!exists2) {
+          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);
+      }
+      /**
+       * 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)) {
+            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);
+            }
+            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.`
+            );
+            continue;
+          }
+          let contentHash = this.computeContentHash(patchContent);
+          if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
+            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((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
+          const sensitiveFiles = allFiles.filter((f2) => isSensitiveFile(f2));
+          const files = allFiles.filter((f2) => !isSensitiveFile(f2));
+          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) {
+            continue;
+          }
+          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 (!matchedExisting && revertedMessage) {
+            const existing = lock.patches.find((p) => p.original_message === revertedMessage);
+            if (existing) {
+              revertedPatchIdSet.add(existing.id);
+              revertIndicesToRemove.add(i);
+              matchedExisting = true;
+            }
+          }
+          if (matchedExisting) continue;
+          let matchedNew = false;
+          if (revertedSha) {
+            const idx = survivingPatches.findIndex(
+              (p, j2) => j2 !== i && !revertIndicesToRemove.has(j2) && p.original_commit === revertedSha
+            );
+            if (idx !== -1) {
+              revertIndicesToRemove.add(i);
+              revertIndicesToRemove.add(idx);
+              matchedNew = true;
+            }
+          }
+          if (!matchedNew && revertedMessage) {
+            const idx = survivingPatches.findIndex(
+              (p, j2) => j2 !== i && !revertIndicesToRemove.has(j2) && p.original_message === revertedMessage
+            );
+            if (idx !== -1) {
+              revertIndicesToRemove.add(i);
+              revertIndicesToRemove.add(idx);
+            }
+          }
+          if (!matchedExisting && !matchedNew) {
+            revertIndicesToRemove.add(i);
+          }
+        }
+        const filteredPatches = survivingPatches.filter((_2, i) => !revertIndicesToRemove.has(i));
+        return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
       }
-      isExcluded(patch) {
-        const config = this.lockManager.getCustomizationsConfig();
-        if (!config.exclude) return false;
-        return patch.files.some((file) => config.exclude.some((pattern) => minimatch(file, pattern)));
+      /**
+       * Compute content hash for deduplication.
+       *
+       * Produces a format-agnostic hash so both `git format-patch` output
+       * (email-wrapped) and plain `git diff` output hash to the same value
+       * when the underlying diff hunks are identical.
+       *
+       * Normalization:
+       *   1. Strip email wrapper: everything before the first `diff --git` line
+       *      (From:, Subject:, Date:, diffstat, blank separators).
+       *   2. Strip `index` lines (blob SHA pairs change across rebases).
+       *   3. Strip trailing git version marker (`-- \n<version>`).
+       *
+       * This ensures content hashes match across the no-patches and normal-
+       * regeneration flows, which store formatPatch and git-diff formats
+       * respectively (FER-9850, D5-D9).
+       */
+      computeContentHash(patchContent) {
+        const lines = patchContent.split("\n");
+        const diffStart = lines.findIndex((l) => l.startsWith("diff --git "));
+        const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
+        const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
+        return `sha256:${(0, import_crypto.createHash)("sha256").update(normalized).digest("hex")}`;
       }
-      async resolveFilePath(filePath, baseTreeHash, currentTreeHash) {
-        const config = this.lockManager.getCustomizationsConfig();
-        if (config.moves) {
-          for (const move of config.moves) {
-            if (minimatch(filePath, move.from) || filePath === move.from) {
-              if (filePath === move.from) {
-                return move.to;
-              }
-              const fromBase = move.from.replace(/\*\*.*$/, "");
-              const toBase = move.to.replace(/\*\*.*$/, "");
-              if (filePath.startsWith(fromBase)) {
-                return toBase + filePath.slice(fromBase.length);
-              }
-            }
+      /**
+       * FER-9805 — Drop patches whose files were transiently created and then
+       * deleted within the current linear detection window, and are absent from
+       * HEAD at the end of the window.
+       *
+       * Rationale: on a merge commit, createMergeCompositePatch already diffs
+       * firstParent..mergeCommit so net-zero files never enter the composite. On
+       * linear history each commit becomes its own patch, so a file that was
+       * briefly added and later removed survives as a create+delete pair whose
+       * cumulative diff is empty. We drop such patches before they reach the
+       * lockfile.
+       *
+       * A file is "transient" when:
+       *   1. some patch in the window sets `new file mode` for it (a creation), AND
+       *   2. some patch in the window sets `deleted file mode` for it (a deletion), AND
+       *   3. it is absent from HEAD's tree.
+       *
+       * The HEAD guard (#3) prevents false positives when a file is deleted
+       * and then recreated with different content — the cumulative diff of
+       * such a pair is non-empty and must be preserved.
+       *
+       * This only drops patches whose `files` are a subset of the transient
+       * set. A partial-transient patch (one that touches a transient file
+       * alongside a persistent one) is left unmodified; surgical stripping of
+       * single files from a multi-file patch would require a follow-up that
+       * regenerates the patch content via `git format-patch -- <files>`. No
+       * current failing test exercises this, and leaving the patch intact
+       * preserves today's behaviour. TODO(FER-9805): revisit if a future
+       * adversarial test demands per-file stripping.
+       */
+      async collapseNetZeroFiles(patches) {
+        if (patches.length === 0) return patches;
+        const stateByFile = /* @__PURE__ */ new Map();
+        for (const patch of patches) {
+          for (const header of parsePatchFileHeaders(patch.patch_content)) {
+            if (!header.isCreate && !header.isDelete) continue;
+            const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
+            if (header.isCreate) prior.created = true;
+            if (header.isDelete) prior.deleted = true;
+            stateByFile.set(header.path, prior);
           }
         }
-        const cacheKey = `${baseTreeHash}:${currentTreeHash}`;
-        let renames = this.renameCache.get(cacheKey);
-        if (!renames) {
-          renames = await this.git.detectRenames(baseTreeHash, currentTreeHash);
-          this.renameCache.set(cacheKey, renames);
+        let anyCandidate = false;
+        for (const state of stateByFile.values()) {
+          if (state.created && state.deleted) {
+            anyCandidate = true;
+            break;
+          }
         }
-        const gitRename = renames.find((r2) => r2.from === filePath);
-        if (gitRename) {
-          return gitRename.to;
+        if (!anyCandidate) return patches;
+        const headFiles = await this.listHeadFiles();
+        const transient = /* @__PURE__ */ new Set();
+        for (const [file, state] of stateByFile) {
+          if (state.created && state.deleted && !headFiles.has(file)) {
+            transient.add(file);
+          }
         }
-        return filePath;
+        if (transient.size === 0) return patches;
+        return patches.filter((patch) => !patch.files.every((f2) => transient.has(f2)));
       }
-      async applyPatchToContent(base, patchContent, filePath, tempGit, tempDir, sourceFilePath) {
-        if (!base) {
-          return this.extractNewFileFromPatch(patchContent, filePath);
-        }
-        const fileDiff = this.extractFileDiff(patchContent, filePath);
-        if (!fileDiff) return null;
+      /**
+       * List every tracked path at HEAD (one `git ls-tree -r` invocation).
+       * Returns an empty Set if HEAD is unborn or the invocation fails — the
+       * caller then treats every candidate as "not in HEAD" and may collapse
+       * more aggressively. On typical SDK repos this is a single sub-10ms call.
+       */
+      async listHeadFiles() {
         try {
-          if (sourceFilePath) {
-            const tempSourcePath = (0, import_path8.join)(tempDir, sourceFilePath);
-            await (0, import_promises3.mkdir)((0, import_path8.dirname)(tempSourcePath), { recursive: true });
-            await (0, import_promises3.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_path8.join)(tempDir, filePath);
-            return await (0, import_promises3.readFile)(tempTargetPath, "utf-8");
-          }
-          const tempFilePath = (0, import_path8.join)(tempDir, filePath);
-          await (0, import_promises3.mkdir)((0, import_path8.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");
+          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();
+        }
+      }
+      /**
+       * 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((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
+        const sensitiveMergeFiles = allMergeFiles.filter((f2) => isSensitiveFile(f2));
+        const files = allMergeFiles.filter((f2) => !isSensitiveFile(f2));
+        if (sensitiveMergeFiles.length > 0) {
+          this.warnings.push(
+            `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveMergeFiles.join(", ")}. These files will not be tracked by replay.`
+          );
+        }
+        if (files.length === 0) return null;
+        const diff = await this.git.exec([
+          "diff",
+          firstParent,
+          mergeCommit.sha,
+          "--",
+          ...files
+        ]);
+        if (!diff.trim()) return null;
+        const contentHash = this.computeContentHash(diff);
+        if (lock.patches.some((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
           return null;
         }
+        const theirsSnapshot = {};
+        for (const file of files) {
+          if (isBinaryFile(file)) continue;
+          const content = await this.git.showFile(mergeCommit.sha, file).catch(() => null);
+          if (content != null) theirsSnapshot[file] = content;
+        }
+        return {
+          id: `patch-merge-${mergeCommit.sha.slice(0, 8)}`,
+          content_hash: contentHash,
+          original_commit: mergeCommit.sha,
+          original_message: mergeCommit.message,
+          original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
+          base_generation: lastGen.commit_sha,
+          files,
+          patch_content: diff,
+          ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+          ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
+        };
       }
       /**
-       * 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.
+       * 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 isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
-        const fileDiff = this.extractFileDiff(patchContent, filePath);
-        if (!fileDiff) return false;
-        try {
-          const tempFilePath = (0, import_path8.join)(tempDir, filePath);
-          await (0, import_promises3.mkdir)((0, import_path8.dirname)(tempFilePath), { recursive: true });
-          await (0, import_promises3.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 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((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
+        const sensitiveTreeFiles = allTreeFiles.filter((f2) => isSensitiveFile(f2));
+        const files = allTreeFiles.filter((f2) => !isSensitiveFile(f2));
+        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: [] };
       }
-      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);
-            }
+      /**
+       * Last-resort detection when both generation commit and tree are unreachable.
+       * Scans all commits from HEAD, filters against known lockfile patches, and
+       * skips creation-only commits (squashed history after force push).
+       *
+       * Detected patches use the commit's parent as base_generation so the applicator
+       * can find base file content from the parent's tree (which IS reachable).
+       */
+      async detectPatchesViaCommitScan() {
+        const lock = this.lockManager.read();
+        const log = await this.git.exec([
+          "log",
+          "--max-count=200",
+          "--format=%H%x00%an%x00%ae%x00%s",
+          "HEAD",
+          "--",
+          this.sdkOutputDir
+        ]);
+        if (!log.trim()) {
+          return { patches: [], revertedPatchIds: [] };
+        }
+        const commits = this.parseGitLog(log);
+        const newPatches = [];
+        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+        const existingHashes = new Set(lock.patches.map((p) => p.content_hash));
+        const existingCommits = new Set(lock.patches.map((p) => p.original_commit));
+        for (const commit of commits) {
+          if (isGenerationCommit(commit)) {
             continue;
           }
-          if (inTargetFile) {
-            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((f2) => !INFRASTRUCTURE_FILES.has(f2));
+          const sensitiveScanFiles = allScanFiles.filter((f2) => isSensitiveFile(f2));
+          const files = allScanFiles.filter((f2) => !isSensitiveFile(f2));
+          if (sensitiveScanFiles.length > 0) {
+            this.warnings.push(
+              `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveScanFiles.join(", ")}. These files will not be tracked by replay.`
+            );
+            if (files.length > 0) {
+              if (parents.length === 0) {
+                continue;
+              }
+              try {
+                patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
+              } catch {
+                continue;
+              }
+              if (!patchContent.trim()) continue;
+              contentHash = this.computeContentHash(patchContent);
             }
           }
-          if (line.startsWith("@@")) {
-            if (!isNewFile) return null;
-            inHunk = true;
+          if (files.length === 0) {
             continue;
           }
-          if (!inHunk) continue;
-          if (line === "\") {
-            noTrailingNewline = true;
+          if (parents.length === 0) {
             continue;
           }
-          if (line.startsWith("+") && !line.startsWith("+++")) {
-            addedLines.push(line.slice(1));
+          const parentSha = parents[0];
+          const theirsSnapshot = {};
+          for (const file of files) {
+            if (isBinaryFile(file)) continue;
+            const content = await this.git.showFile(commit.sha, file).catch(() => null);
+            if (content != null) theirsSnapshot[file] = content;
           }
+          newPatches.push({
+            id: `patch-${commit.sha.slice(0, 8)}`,
+            content_hash: contentHash,
+            original_commit: commit.sha,
+            original_message: commit.message,
+            original_author: `${commit.authorName} <${commit.authorEmail}>`,
+            base_generation: parentSha,
+            files,
+            patch_content: patchContent,
+            ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
+          });
         }
-        if (addedLines.length === 0) return null;
-        return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
+        newPatches.reverse();
+        return { patches: newPatches, revertedPatchIds: [] };
+      }
+      /**
+       * Check if a format-patch consists entirely of new-file creations.
+       * Used to identify squashed commits after force push, which create all files
+       * from scratch (--- /dev/null) rather than modifying existing files.
+       */
+      isCreationOnlyPatch(patchContent) {
+        const diffOldHeaders = patchContent.split("\n").filter((l) => l.startsWith("--- "));
+        if (diffOldHeaders.length === 0) {
+          return false;
+        }
+        return diffOldHeaders.every((l) => l === "--- /dev/null");
+      }
+      /**
+       * 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((g2) => g2.commit_sha === lock.current_generation);
       }
     };
     ReplayCommitter = class {
@@ -25653,19 +25832,14 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         existingPatches = this.lockManager.getPatches();
         const seenHashes = /* @__PURE__ */ new Map();
         for (const p of existingPatches) {
-          const priorOrigin = seenHashes.get(p.content_hash);
-          if (priorOrigin !== void 0) {
-            const provenanceMissing = !priorOrigin || !p.original_commit;
-            const sameOrigin = priorOrigin === p.original_commit;
-            if (sameOrigin && !provenanceMissing) {
-              this.lockManager.removePatch(p.id);
-            } else {
-              this.warnings.push(
-                `Preserving patch ${p.id} (commit ${(p.original_commit || "<missing>").slice(0, 7)}): shares content_hash with a prior patch ${provenanceMissing ? "(provenance missing on at least one side)" : "from a different source commit"}. Both retained to avoid silent customization loss (FER-9983).`
-              );
-            }
+          const priorPatchId = seenHashes.get(p.content_hash);
+          if (priorPatchId !== void 0) {
+            this.lockManager.removePatch(p.id);
+            this.warnings.push(
+              `Consolidated patch ${p.id} (commit ${(p.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content. Per-commit attribution preserved in git log; lockfile collapsed to avoid duplicate-apply corruption on next regen.`
+            );
           } else {
-            seenHashes.set(p.content_hash, p.original_commit);
+            seenHashes.set(p.content_hash, p.id);
           }
         }
         existingPatches = this.lockManager.getPatches();
@@ -25846,17 +26020,27 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
             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 {
               }
@@ -25904,30 +26088,34 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
               continue;
             }
             const newContentHash = this.detector.computeContentHash(diff);
-            const priorOrigin = seenContentHashes.get(newContentHash);
-            if (priorOrigin !== void 0) {
-              const provenanceMissing = !priorOrigin || !patch.original_commit;
-              const sameOrigin = priorOrigin === patch.original_commit;
-              if (sameOrigin && !provenanceMissing) {
-                this.lockManager.removePatch(patch.id);
-                absorbedPatchIds.add(patch.id);
-                absorbed++;
-                continue;
+            const priorPatchId = seenContentHashes.get(newContentHash);
+            if (priorPatchId !== void 0) {
+              this.lockManager.removePatch(patch.id);
+              absorbedPatchIds.add(patch.id);
+              absorbed++;
+              if (priorPatchId !== patch.id) {
+                this.warnings.push(
+                  `Consolidated patch ${patch.id} (commit ${(patch.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content after rebase. Per-commit attribution preserved in git log.`
+                );
               }
-              this.warnings.push(
-                `Preserving patch ${patch.id} (commit ${(patch.original_commit || "<missing>").slice(0, 7)}): shares content_hash with a prior patch ${provenanceMissing ? "(provenance missing on at least one side)" : "from a different source commit"}. Both retained to avoid silent customization loss (FER-9983).`
-              );
+              continue;
             } else {
-              seenContentHashes.set(newContentHash, patch.original_commit);
+              seenContentHashes.set(newContentHash, patch.id);
             }
             patch.base_generation = currentGenSha;
             patch.patch_content = diff;
             patch.content_hash = newContentHash;
+            const snapshot = await this.readSnapshotFromDisk(patch.files);
+            const snapshotIsNonEmpty = Object.keys(snapshot).length > 0;
+            if (snapshotIsNonEmpty) {
+              patch.theirs_snapshot = snapshot;
+            }
             try {
               this.lockManager.updatePatch(patch.id, {
                 base_generation: currentGenSha,
                 patch_content: diff,
-                content_hash: newContentHash
+                content_hash: newContentHash,
+                ...snapshotIsNonEmpty ? { theirs_snapshot: snapshot } : {}
               });
             } catch {
             }
@@ -25937,6 +26125,112 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         }
         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_promises5.readFile)((0, import_path10.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 f2 of p.files) {
+            fileFreq.set(f2, (fileFreq.get(f2) ?? 0) + 1);
+          }
+        }
+        let migrated = 0;
+        let skipped = 0;
+        for (const patch of patches) {
+          if (patch.theirs_snapshot != null) continue;
+          const sharesAnyFile = patch.files.some((f2) => (fileFreq.get(f2) ?? 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).
        *
@@ -26057,6 +26351,20 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           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;
@@ -26093,6 +26401,13 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
             delete patch.status;
             continue;
           }
+          if (headIsGeneration) {
+            const parentChangedFiles = await headParentChangedFiles(patch.files);
+            const headTouchedSource = patch.files.some((f2) => parentChangedFiles.has(f2));
+            if (headTouchedSource) {
+              continue;
+            }
+          }
           if (patch.base_generation === currentGen) {
             try {
               const ppResult = await computePerPatchDiffWithFallback(
@@ -26129,10 +26444,12 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
                 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++;
@@ -26165,10 +26482,12 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
               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 {
@@ -26211,7 +26530,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
           if (result.status !== "conflict" || !result.fileResults) continue;
           for (const fileResult of result.fileResults) {
             if (fileResult.status !== "conflict") continue;
-            const filePath = (0, import_path9.join)(this.outputDir, fileResult.file);
+            const filePath = (0, import_path10.join)(this.outputDir, fileResult.file);
             try {
               const content = (0, import_fs7.readFileSync)(filePath, "utf-8");
               const stripped = stripConflictMarkers(content);
@@ -26241,7 +26560,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         }
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_path9.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_path10.join)(this.outputDir, ".fernignore");
         if (!(0, import_fs7.existsSync)(fernignorePath)) return [];
         return (0, import_fs7.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       }
@@ -26299,10 +26618,10 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         this.outputDir = outputDir;
       }
       fernignoreExists() {
-        return (0, import_fs8.existsSync)((0, import_path11.join)(this.outputDir, ".fernignore"));
+        return (0, import_fs8.existsSync)((0, import_path12.join)(this.outputDir, ".fernignore"));
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_path11.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_path12.join)(this.outputDir, ".fernignore");
         if (!(0, import_fs8.existsSync)(fernignorePath)) {
           return [];
         }
@@ -26354,6 +26673,12 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
             if (patchFiles.length > 0) {
               const patchContent = diffParts.join("\n");
               const contentHash = `sha256:${(0, import_crypto2.createHash)("sha256").update(patchContent).digest("hex")}`;
+              const theirsSnapshot = {};
+              for (const filePath of patchFiles) {
+                if (isBinaryFile(filePath)) continue;
+                const c2 = this.readFileContent(filePath);
+                if (c2 != null) theirsSnapshot[filePath] = c2;
+              }
               syntheticPatches.push({
                 id: `patch-fernignore-${(0, import_crypto2.createHash)("sha256").update(pattern).digest("hex").slice(0, 8)}`,
                 content_hash: contentHash,
@@ -26363,6 +26688,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
                 base_generation: currentGen.commit_sha,
                 files: patchFiles,
                 patch_content: patchContent,
+                ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
                 // Synthetic patches captured from .fernignore-protected files
                 // are user-owned by definition — the customer's content
                 // diverges from the generator's pristine output, and the
@@ -26404,7 +26730,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         return results;
       }
       readFileContent(filePath) {
-        const fullPath = (0, import_path11.join)(this.outputDir, filePath);
+        const fullPath = (0, import_path12.join)(this.outputDir, filePath);
         if (!(0, import_fs8.existsSync)(fullPath)) {
           return null;
         }
@@ -26469,7 +26795,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         };
       }
       movePatternsToReplayYml(patterns) {
-        const replayYmlPath = (0, import_path11.join)(this.outputDir, ".fern", "replay.yml");
+        const replayYmlPath = (0, import_path12.join)(this.outputDir, ".fern", "replay.yml");
         let config = {};
         if ((0, import_fs8.existsSync)(replayYmlPath)) {
           const content = (0, import_fs8.readFileSync)(replayYmlPath, "utf-8");
@@ -26478,7 +26804,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         const existing = config.exclude ?? [];
         const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
         config.exclude = merged;
-        const dir = (0, import_path11.dirname)(replayYmlPath);
+        const dir = (0, import_path12.dirname)(replayYmlPath);
         if (!(0, import_fs8.existsSync)(dir)) {
           (0, import_fs8.mkdirSync)(dir, { recursive: true });
         }
@@ -29034,8 +29360,8 @@ function resolve(...paths) {
 
 // src/cli.ts
 var import_fs15 = __toESM(require("fs"));
-var import_promises13 = require("fs/promises");
-var import_path20 = __toESM(require("path"));
+var import_promises15 = require("fs/promises");
+var import_path21 = __toESM(require("path"));
 
 // ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/yerror.js
 var YError = class _YError extends Error {
@@ -38736,42 +39062,42 @@ function replayForget(params) {
 // src/replay/replay-init.ts
 init_dist3();
 var import_fs11 = require("fs");
-var import_path15 = require("path");
+var import_path16 = require("path");
 var import_tmp_promise2 = __toESM(require_tmp_promise());
 
 // src/replay/fernignore.ts
-var import_promises6 = require("fs/promises");
-var import_path14 = require("path");
+var import_promises8 = require("fs/promises");
+var import_path15 = require("path");
 var REPLAY_FERNIGNORE_ENTRIES2 = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
 var GITATTRIBUTES_ENTRIES2 = [".fern/replay.lock linguist-generated=true"];
 async function ensureReplayFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_path14.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_path15.join)(outputDir, ".fernignore");
   let content = "";
   try {
-    content = await (0, import_promises6.readFile)(fernignorePath, "utf-8");
+    content = await (0, import_promises8.readFile)(fernignorePath, "utf-8");
   } catch {
   }
   const lines = content.split("\n");
   const toAdd = REPLAY_FERNIGNORE_ENTRIES2.filter((entry) => !lines.some((line) => line.trim() === entry));
   if (toAdd.length > 0) {
     const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    await (0, import_promises6.writeFile)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+    await (0, import_promises8.writeFile)(fernignorePath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
     return true;
   }
   return false;
 }
 async function ensureGitattributesEntries2(outputDir) {
-  const gitattributesPath = (0, import_path14.join)(outputDir, ".gitattributes");
+  const gitattributesPath = (0, import_path15.join)(outputDir, ".gitattributes");
   let content = "";
   try {
-    content = await (0, import_promises6.readFile)(gitattributesPath, "utf-8");
+    content = await (0, import_promises8.readFile)(gitattributesPath, "utf-8");
   } catch {
   }
   const lines = content.split("\n");
   const toAdd = GITATTRIBUTES_ENTRIES2.filter((entry) => !lines.some((line) => line.trim() === entry));
   if (toAdd.length > 0) {
     const suffix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-    await (0, import_promises6.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+    await (0, import_promises8.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
   }
 }
 
@@ -38798,7 +39124,7 @@ async function replayInit(params) {
   if (dryRun) {
     return { bootstrap: bootstrapResult, fernignoreEntries: [], gitattributesEntries: [] };
   }
-  const lockfilePath = (0, import_path15.join)(repoPath, ".fern", "replay.lock");
+  const lockfilePath = (0, import_path16.join)(repoPath, ".fern", "replay.lock");
   const lockfileContent = (0, import_fs11.existsSync)(lockfilePath) ? (0, import_fs11.readFileSync)(lockfilePath, "utf-8") : void 0;
   return {
     bootstrap: bootstrapResult,
@@ -38921,7 +39247,7 @@ init_dist3();
 init_dist3();
 var import_child_process4 = require("child_process");
 var import_fs12 = require("fs");
-var import_path16 = require("path");
+var import_path17 = require("path");
 async function replayPrepare(params) {
   const {
     outputDir,
@@ -38932,7 +39258,7 @@ async function replayPrepare(params) {
     skipApplication,
     logger
   } = params;
-  const lockfilePath = (0, import_path16.join)(outputDir, ".fern", "replay.lock");
+  const lockfilePath = (0, import_path17.join)(outputDir, ".fern", "replay.lock");
   if (!(0, import_fs12.existsSync)(lockfilePath)) {
     return null;
   }
@@ -39117,29 +39443,29 @@ function replayStatus(params) {
 }
 
 // src/configuration/loadGitHubConfig.ts
-var import_promises7 = require("fs/promises");
+var import_promises9 = require("fs/promises");
 async function loadGitHubConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises7.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises9.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
 // src/configuration/loadReadmeConfig.ts
-var import_promises8 = require("fs/promises");
+var import_promises10 = require("fs/promises");
 async function loadReadmeConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises8.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises10.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
 // src/configuration/loadReferenceConfig.ts
-var import_promises9 = require("fs/promises");
+var import_promises11 = require("fs/promises");
 async function loadReferenceConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises9.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises11.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
@@ -39166,8 +39492,8 @@ var FERN_BOT_LOGIN2 = "fern-api[bot]";
 // src/pipeline/steps/AutoVersionStep.ts
 var import_child_process5 = require("child_process");
 var import_fs14 = require("fs");
-var import_promises11 = require("fs/promises");
-var import_path18 = require("path");
+var import_promises13 = require("fs/promises");
+var import_path19 = require("path");
 
 // ../commons/logging-execa/lib/loggingExeca.js
 var import_execa = __toESM(require_execa(), 1);
@@ -39226,8 +39552,8 @@ async function loggingExeca(logger, executable, args = [], { doNotPipeOutput = f
 
 // src/autoversion/AutoVersioningService.ts
 var import_fs13 = require("fs");
-var import_promises10 = require("fs/promises");
-var import_path17 = require("path");
+var import_promises12 = require("fs/promises");
+var import_path18 = require("path");
 var import_semver = __toESM(require_semver2());
 var AutoVersioningException = class extends Error {
   /**
@@ -39914,7 +40240,7 @@ var AutoVersioningService = class _AutoVersioningService {
       );
       return;
     }
-    const goModPath = (0, import_path17.join)(workingDirectory, "go.mod");
+    const goModPath = (0, import_path18.join)(workingDirectory, "go.mod");
     if (!(0, import_fs13.existsSync)(goModPath)) {
       this.logger.debug(`No go.mod found in ${workingDirectory}, skipping Go module path update`);
       return;
@@ -39948,7 +40274,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Reads the module path from a go.mod file.
    */
   async readGoModulePath(goModPath) {
-    const content = await (0, import_promises10.readFile)(goModPath, "utf-8");
+    const content = await (0, import_promises12.readFile)(goModPath, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed2 = line.trim();
       if (trimmed2.startsWith("module ")) {
@@ -39961,7 +40287,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Adds a version suffix to the module line in go.mod.
    */
   async addSuffixToGoMod(goModPath, modulePath, suffix) {
-    const content = await (0, import_promises10.readFile)(goModPath, "utf-8");
+    const content = await (0, import_promises12.readFile)(goModPath, "utf-8");
     const lines = content.split("\n");
     let changed = false;
     for (let i = 0; i < lines.length; i++) {
@@ -39973,7 +40299,7 @@ var AutoVersioningService = class _AutoVersioningService {
       }
     }
     if (changed) {
-      await (0, import_promises10.writeFile)(goModPath, lines.join("\n"), "utf-8");
+      await (0, import_promises12.writeFile)(goModPath, lines.join("\n"), "utf-8");
       this.logger.debug(`Updated go.mod: added ${suffix} to module path`);
     }
   }
@@ -39982,10 +40308,10 @@ var AutoVersioningService = class _AutoVersioningService {
    */
   async walkDirectory(dir, filter2) {
     const results = [];
-    const entries2 = await (0, import_promises10.readdir)(dir);
+    const entries2 = await (0, import_promises12.readdir)(dir);
     for (const entry of entries2) {
-      const fullPath = (0, import_path17.join)(dir, entry);
-      const entryStat = await (0, import_promises10.stat)(fullPath);
+      const fullPath = (0, import_path18.join)(dir, entry);
+      const entryStat = await (0, import_promises12.stat)(fullPath);
       if (entryStat.isDirectory()) {
         if (entry === ".git" || entry === "vendor") {
           continue;
@@ -40002,7 +40328,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Adds a version suffix to import paths in all .go files in the repository.
    */
   async addSuffixToGoFiles(repoRoot, modulePath, suffix) {
-    const goFiles = await this.walkDirectory(repoRoot, (filePath) => (0, import_path17.extname)(filePath) === ".go");
+    const goFiles = await this.walkDirectory(repoRoot, (filePath) => (0, import_path18.extname)(filePath) === ".go");
     for (const filePath of goFiles) {
       await this.addSuffixToGoFile(filePath, modulePath, suffix);
     }
@@ -40012,7 +40338,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Replaces occurrences of the module path with modulePath + suffix in import statements.
    */
   async addSuffixToGoFile(filePath, modulePath, suffix) {
-    const content = await (0, import_promises10.readFile)(filePath, "utf-8");
+    const content = await (0, import_promises12.readFile)(filePath, "utf-8");
     const lines = content.split("\n");
     let changed = false;
     let inImportBlock = false;
@@ -40041,7 +40367,7 @@ var AutoVersioningService = class _AutoVersioningService {
       }
     }
     if (changed) {
-      await (0, import_promises10.writeFile)(filePath, lines.join("\n"), "utf-8");
+      await (0, import_promises12.writeFile)(filePath, lines.join("\n"), "utf-8");
       this.logger.debug(`Updated Go imports in ${filePath}`);
     }
   }
@@ -40446,7 +40772,7 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
   }
   async prependChangelogEntry(params) {
     const { version: version2, entry } = params;
-    const changelogPath = (0, import_path18.join)(this.outputDir, "changelog.md");
+    const changelogPath = (0, import_path19.join)(this.outputDir, "changelog.md");
     const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const header = `## [${version2}] - ${now}
 `;
@@ -40455,7 +40781,7 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
 `;
     let existing = "";
     if ((0, import_fs14.existsSync)(changelogPath)) {
-      existing = await (0, import_promises11.readFile)(changelogPath, "utf-8");
+      existing = await (0, import_promises13.readFile)(changelogPath, "utf-8");
     }
     let output;
     if (existing.trim().length === 0) {
@@ -40472,7 +40798,7 @@ ${newBlock}${remainder}`;
     } else {
       output = `${newBlock}${existing}`;
     }
-    await (0, import_promises11.writeFile)(changelogPath, output, "utf-8");
+    await (0, import_promises13.writeFile)(changelogPath, output, "utf-8");
   }
   brandMessage(message) {
     if (this.config.isWhitelabel) {
@@ -40654,8 +40980,8 @@ var GenerationCommitStep = class extends BaseStep {
 };
 
 // src/pipeline/steps/GithubStep.ts
-var import_promises12 = require("fs/promises");
-var import_path19 = require("path");
+var import_promises14 = require("fs/promises");
+var import_path20 = require("path");
 
 // src/pipeline/github/createReplayBranch.ts
 async function createReplayBranch(repository, branchName, commitMessage, replayConflictInfo, logger) {
@@ -41272,13 +41598,13 @@ var GithubStep = class extends BaseStep {
   }
   async ensureFernignore() {
     this.logger.debug("Checking for .fernignore file...");
-    const fernignorePath = (0, import_path19.join)(this.outputDir, ".fernignore");
+    const fernignorePath = (0, import_path20.join)(this.outputDir, ".fernignore");
     try {
-      await (0, import_promises12.access)(fernignorePath);
+      await (0, import_promises14.access)(fernignorePath);
       this.logger.debug(".fernignore already exists");
     } catch {
       this.logger.debug("Creating .fernignore file...");
-      await (0, import_promises12.writeFile)(fernignorePath, "# Specify files that shouldn't be modified by Fern\n", "utf-8");
+      await (0, import_promises14.writeFile)(fernignorePath, "# Specify files that shouldn't be modified by Fern\n", "utf-8");
     }
   }
   deriveSkipCommit(replayResult) {
@@ -41571,7 +41897,7 @@ void yargs_default(hideBin(process.argv)).scriptName(process.env.CLI_NAME ?? "ge
     const readmeConfig = await loadReadmeConfig({
       absolutePathToConfig: resolve(wd, argv.config)
     });
-    const originalReadmeContent = argv.originalReadme != null ? await (0, import_promises13.readFile)(argv.originalReadme, "utf8") : void 0;
+    const originalReadmeContent = argv.originalReadme != null ? await (0, import_promises15.readFile)(argv.originalReadme, "utf8") : void 0;
     await generateReadmeToStream({
       originalReadmeContent,
       readmeConfig,
@@ -41699,7 +42025,7 @@ void yargs_default(hideBin(process.argv)).scriptName(process.env.CLI_NAME ?? "ge
       try {
         const wd = cwd();
         const configValue = argv.config;
-        const configContent = configValue === STDIN_MARKER ? await readStdin() : configValue.trimStart().startsWith("{") ? configValue : await (0, import_promises13.readFile)(resolve(wd, configValue), "utf-8");
+        const configContent = configValue === STDIN_MARKER ? await readStdin() : configValue.trimStart().startsWith("{") ? configValue : await (0, import_promises15.readFile)(resolve(wd, configValue), "utf-8");
         let config;
         try {
           config = JSON.parse(configContent);
@@ -41995,7 +42321,7 @@ async function createWriteStream(outputPath) {
 }
 async function createWriteStreamFromFile(filepath) {
   if (!await doesPathExist(filepath)) {
-    await (0, import_promises13.mkdir)(import_path20.default.dirname(filepath), { recursive: true });
+    await (0, import_promises15.mkdir)(import_path21.default.dirname(filepath), { recursive: true });
   }
   return import_fs15.default.createWriteStream(filepath);
 }