@fern-api/generator-cli 0.9.20 → 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 join12 = 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 = join12(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) {
@@ -18885,7 +18885,7 @@ var require_resolve_block_scalar = __commonJS({
       if (!header)
         return { value: "", type: null, comment: "", range: [start, start, start] };
       const type = header.mode === ">" ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL;
-      const lines = scalar.source ? splitLines(scalar.source) : [];
+      const lines = scalar.source ? splitLines2(scalar.source) : [];
       let chompStart = lines.length;
       for (let i = lines.length - 1; i >= 0; --i) {
         const content = lines[i][1];
@@ -19043,7 +19043,7 @@ var require_resolve_block_scalar = __commonJS({
       }
       return { mode, indent, chomp, comment, length };
     }
-    function splitLines(source) {
+    function splitLines2(source) {
       const split = source.split(/\n( *)/);
       const first2 = split[0];
       const m = first2.match(/^( *)/);
@@ -22028,7 +22028,7 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.13.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");
@@ -22401,11 +22480,43 @@ function threeWayMerge(base, ours, theirs) {
       }
     }
   }
-  return {
+  const result = {
     content: outputLines.join("\n"),
     hasConflicts: conflicts2.length > 0,
     conflicts: conflicts2
   };
+  if (conflicts2.length === 0) {
+    const dropped = computeDroppedContextLines(baseLines, theirsLines, outputLines);
+    if (dropped.length > 0) {
+      result.droppedContextLines = dropped;
+    }
+  }
+  return result;
+}
+function computeDroppedContextLines(baseLines, theirsLines, mergedLines) {
+  const baseCounts = countLines(baseLines);
+  const theirsCounts = countLines(theirsLines);
+  const mergedCounts = countLines(mergedLines);
+  const dropped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of baseLines) {
+    if (seen.has(line)) continue;
+    const inBase = baseCounts.get(line) ?? 0;
+    const inTheirs = theirsCounts.get(line) ?? 0;
+    const inMerged = mergedCounts.get(line) ?? 0;
+    if (inBase > 0 && inTheirs > 0 && inMerged < Math.min(inBase, inTheirs)) {
+      dropped.push(line);
+      seen.add(line);
+    }
+  }
+  return dropped;
+}
+function countLines(lines) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    counts.set(line, (counts.get(line) ?? 0) + 1);
+  }
+  return counts;
 }
 function tryResolveConflict(oursLines, baseLines, theirsLines) {
   if (baseLines.length === 0) {
@@ -22463,81 +22574,380 @@ function applyBothPatches(baseLines, oursPatches, theirsPatches) {
   }
   return result;
 }
-function trimCR(line) {
-  return line.endsWith("\r") ? line.slice(0, -1) : line;
+function isBinaryFile(filePath) {
+  const ext2 = (0, import_path9.extname)(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext2);
 }
-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++;
+function computeDroppedContextLinesForFile(base, theirs, finalContent) {
+  const baseLines = base.split("\n");
+  const theirsLines = theirs.split("\n");
+  const finalLines = finalContent.split("\n");
+  const baseCounts = /* @__PURE__ */ new Map();
+  const theirsCounts = /* @__PURE__ */ new Map();
+  const finalCounts = /* @__PURE__ */ new Map();
+  for (const l of baseLines) baseCounts.set(l, (baseCounts.get(l) ?? 0) + 1);
+  for (const l of theirsLines) theirsCounts.set(l, (theirsCounts.get(l) ?? 0) + 1);
+  for (const l of finalLines) finalCounts.set(l, (finalCounts.get(l) ?? 0) + 1);
+  const dropped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of baseLines) {
+    if (seen.has(line)) continue;
+    const inBase = baseCounts.get(line) ?? 0;
+    const inTheirs = theirsCounts.get(line) ?? 0;
+    const inFinal = finalCounts.get(line) ?? 0;
+    if (inBase > 0 && inTheirs > 0 && inFinal < Math.min(inBase, inTheirs)) {
+      dropped.push(line);
+      seen.add(line);
+    }
+  }
+  return dropped;
+}
+function isDiffLineForFile(diffLine, filePath) {
+  const 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;
       }
-      if (!found) {
-        i++;
-        continue;
+    } else if (currentPath !== null) {
+      if (line.startsWith("new file mode ")) {
+        currentIsCreate = true;
+      } else if (line.startsWith("deleted file mode ")) {
+        currentIsDelete = true;
       }
     }
-    i++;
   }
-  return ranges;
+  flush2();
+  return results;
 }
-function stripConflictMarkers(content) {
-  const lines = content.split(/\r?\n/);
-  const ranges = findConflictRanges(lines);
-  if (ranges.length === 0) {
-    return content;
+function normalizeHunkBody(hunk) {
+  let contextC = 0;
+  let removeC = 0;
+  let addC = 0;
+  const trimmed2 = [];
+  for (const line of hunk.lines) {
+    const oldUsed = contextC + removeC;
+    const newUsed = contextC + addC;
+    if (oldUsed >= hunk.oldCount && newUsed >= hunk.newCount) break;
+    trimmed2.push(line);
+    if (line.type === "context") contextC++;
+    else if (line.type === "remove") removeC++;
+    else if (line.type === "add") addC++;
   }
-  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;
+  return { ...hunk, lines: trimmed2 };
+}
+function extractFileDiffForFile(patchContent, filePath) {
+  const lines = patchContent.split("\n");
+  const out = [];
+  let inTarget = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      if (inTarget) break;
+      if (isDiffLineForFile2(line, filePath)) {
+        inTarget = true;
+        out.push(line);
       }
-      if (i > range2.start && i < range2.separator) {
-        result.push(lines[i]);
+      continue;
+    }
+    if (inTarget) out.push(line);
+  }
+  return out.length > 0 ? out.join("\n") + "\n" : null;
+}
+function isDiffLineForFile2(line, filePath) {
+  const match2 = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+  return match2 !== null && (match2[2] === filePath || match2[1] === filePath);
+}
+async function computePerPatchDiff(patch, getCurrentGenContent, getWorkingTreeContent) {
+  const fragments = [];
+  const unlocatableFiles = [];
+  for (const file of patch.files) {
+    const fileDiff = extractFileDiffForFile(patch.patch_content, file);
+    if (fileDiff == null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    const hunksRaw = parseHunks(fileDiff).map(normalizeHunkBody);
+    const hunks = hunksRaw.filter((h) => {
+      if (h.lines.length === 0) return false;
+      let ctx = 0, rm4 = 0, add = 0;
+      for (const ln of h.lines) {
+        if (ln.type === "context") ctx++;
+        else if (ln.type === "remove") rm4++;
+        else if (ln.type === "add") add++;
+      }
+      return ctx + rm4 === h.oldCount && ctx + add === h.newCount;
+    });
+    if (hunks.length === 0) {
+      if (hunksRaw.length > 0) unlocatableFiles.push(file);
+      continue;
+    }
+    const currentGen = await getCurrentGenContent(file);
+    const workingTree = await getWorkingTreeContent(file);
+    const isPureNewFile = hunks.every((h) => h.oldCount === 0);
+    const isPureDelete = hunks.every((h) => h.newCount === 0);
+    if (currentGen == null) {
+      if (!isPureNewFile) {
+        unlocatableFiles.push(file);
         continue;
       }
-      if (i === range2.separator) {
+      if (workingTree == null) continue;
+      fragments.push(synthesizeNewFileDiff(file, workingTree));
+      continue;
+    }
+    if (isPureNewFile) {
+      if (workingTree == null) {
+        fragments.push(synthesizeDeleteFileDiff(file, currentGen));
         continue;
       }
-      if (i > range2.separator && i < range2.end) {
+      if (workingTree === currentGen) {
         continue;
       }
-      if (i === range2.end) {
-        rangeIdx++;
+      const fullDiff = await unifiedDiff(currentGen, workingTree, file);
+      if (fullDiff && fullDiff.trim()) fragments.push(fullDiff);
+      continue;
+    }
+    if (workingTree == null) {
+      if (!isPureDelete) {
+        unlocatableFiles.push(file);
         continue;
       }
+      fragments.push(synthesizeDeleteFileDiff(file, currentGen));
+      continue;
+    }
+    const currentGenLines = splitLines(currentGen);
+    const workingTreeLines = splitLines(workingTree);
+    const locInCurrentGenRaw = locateHunksInOurs(hunks, currentGenLines);
+    const locInWorkingTreeRaw = locateHunksInOurs(hunks, workingTreeLines);
+    if (locInCurrentGenRaw == null || locInWorkingTreeRaw == null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    const locInCurrentGen = locInCurrentGenRaw.map(
+      (l) => resolveSpan(l, currentGenLines, "old")
+    );
+    const locInWorkingTree = locInWorkingTreeRaw.map(
+      (l) => resolveSpan(l, workingTreeLines, "new")
+    );
+    const overlay = overlayRegions(
+      currentGenLines,
+      locInCurrentGen,
+      workingTreeLines,
+      locInWorkingTree
+    );
+    if (overlay === null) {
+      unlocatableFiles.push(file);
+      continue;
+    }
+    if (overlay === currentGen) {
+      continue;
+    }
+    const fileUnifiedDiff = await unifiedDiff(currentGen, overlay, file);
+    if (fileUnifiedDiff && fileUnifiedDiff.trim()) {
+      fragments.push(fileUnifiedDiff);
     }
-    result.push(lines[i]);
   }
-  return result.join("\n");
+  return {
+    diff: fragments.join(""),
+    unlocatableFiles
+  };
 }
-function isBinaryFile(filePath) {
-  const ext2 = (0, import_path8.extname)(filePath).toLowerCase();
-  return BINARY_EXTENSIONS.has(ext2);
+async function computePerPatchDiffWithFallback(patch, getCurrentGenContent, getWorkingTreeContent, runCumulativeDiff) {
+  const ppDiff = await computePerPatchDiff(
+    patch,
+    getCurrentGenContent,
+    getWorkingTreeContent
+  );
+  if (ppDiff.unlocatableFiles.length === 0) {
+    return { diff: ppDiff.diff, hadFallback: false, fallbackFiles: [] };
+  }
+  const cumulative = await runCumulativeDiff(ppDiff.unlocatableFiles);
+  if (cumulative === null) {
+    return null;
+  }
+  const merged = ppDiff.diff + (cumulative.trim() ? cumulative : "");
+  return { diff: merged, hadFallback: true, fallbackFiles: ppDiff.unlocatableFiles };
 }
-function isDiffLineForFile(diffLine, filePath) {
-  const match2 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
-  return match2 !== null && match2[1] === filePath;
+function splitLines(content) {
+  return content.split("\n");
+}
+function resolveSpan(loc, oursLines, prefer) {
+  const { hunk, oursOffset } = loc;
+  const oldSide = [];
+  const newSide = [];
+  for (const line of hunk.lines) {
+    if (line.type === "context") {
+      oldSide.push(line.content);
+      newSide.push(line.content);
+    } else if (line.type === "remove") {
+      oldSide.push(line.content);
+    } else if (line.type === "add") {
+      newSide.push(line.content);
+    }
+  }
+  const oldFits = sequenceMatches(oldSide, oursLines, oursOffset);
+  const newFits = sequenceMatches(newSide, oursLines, oursOffset);
+  if (prefer === "old") {
+    if (oldFits) return { ...loc, oursSpan: hunk.oldCount };
+    if (newFits) return { ...loc, oursSpan: hunk.newCount };
+  } else {
+    if (newFits) return { ...loc, oursSpan: hunk.newCount };
+    if (oldFits) return { ...loc, oursSpan: hunk.oldCount };
+  }
+  return loc;
+}
+function sequenceMatches(needle, haystack, offset) {
+  if (offset + needle.length > haystack.length) return false;
+  for (let i = 0; i < needle.length; i++) {
+    if (haystack[offset + i] !== needle[i]) return false;
+  }
+  return true;
+}
+function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locInWorkingTree) {
+  if (locInCurrentGen.length !== locInWorkingTree.length) {
+    return null;
+  }
+  const out = [];
+  let cursor = 0;
+  for (let i = 0; i < locInCurrentGen.length; i++) {
+    const cg = locInCurrentGen[i];
+    const wt = locInWorkingTree[i];
+    if (cg.oursOffset > cursor) {
+      out.push(...currentGenLines.slice(cursor, cg.oursOffset));
+    }
+    out.push(...workingTreeLines.slice(wt.oursOffset, wt.oursOffset + wt.oursSpan));
+    cursor = cg.oursOffset + cg.oursSpan;
+  }
+  if (cursor < currentGenLines.length) {
+    out.push(...currentGenLines.slice(cursor));
+  }
+  return out.join("\n");
+}
+async function unifiedDiff(beforeContent, afterContent, filePath) {
+  if (beforeContent === afterContent) return "";
+  const tmp3 = await (0, import_promises6.mkdtemp)((0, import_path11.join)((0, import_os3.tmpdir)(), "fern-replay-pp-"));
+  try {
+    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_promises6.rm)(tmp3, { recursive: true, force: true });
+  }
+}
+function runGitDiffNoIndex(beforePath, afterPath) {
+  return new Promise((resolve22, reject) => {
+    const proc = (0, import_child_process3.spawn)("git", ["diff", "--no-index", "--", beforePath, afterPath]);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d) => stdout += d.toString());
+    proc.stderr.on("data", (d) => stderr += d.toString());
+    proc.on("close", (code) => {
+      if (code === 0 || code === 1) resolve22(stdout);
+      else reject(new Error(`git diff --no-index failed (code ${code}): ${stderr}`));
+    });
+  });
+}
+function rewriteDiffHeaders(raw, filePath) {
+  const lines = raw.split("\n");
+  const out = [];
+  let seenFirstHeader = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      out.push(`diff --git a/${filePath} b/${filePath}`);
+      seenFirstHeader = true;
+      continue;
+    }
+    if (!seenFirstHeader) {
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      out.push(`--- a/${filePath}`);
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      out.push(`+++ b/${filePath}`);
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function synthesizeNewFileDiff(file, content) {
+  const lines = content.split("\n");
+  const hasTrailingNewline = content.endsWith("\n");
+  const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const header = [
+    `diff --git a/${file} b/${file}`,
+    "new file mode 100644",
+    "--- /dev/null",
+    `+++ b/${file}`,
+    `@@ -0,0 +1,${bodyLines.length} @@`
+  ].join("\n");
+  const body = bodyLines.map((l) => `+${l}`).join("\n");
+  const trailer = hasTrailingNewline ? "" : "\n\";
+  return header + "\n" + body + trailer + "\n";
+}
+function synthesizeDeleteFileDiff(file, content) {
+  const lines = content.split("\n");
+  const hasTrailingNewline = content.endsWith("\n");
+  const bodyLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
+  const header = [
+    `diff --git a/${file} b/${file}`,
+    "deleted file mode 100644",
+    `--- a/${file}`,
+    "+++ /dev/null",
+    `@@ -1,${bodyLines.length} +0,0 @@`
+  ].join("\n");
+  const body = bodyLines.map((l) => `-${l}`).join("\n");
+  const trailer = hasTrailingNewline ? "" : "\n\";
+  return header + "\n" + body + trailer + "\n";
+}
+function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit) {
+  const resultByPatchId = /* @__PURE__ */ new Map();
+  for (const r2 of results) resultByPatchId.set(r2.patch.id, r2);
+  const applied = [];
+  const unresolved = [];
+  const absorbed = [];
+  for (const patch of patchesPassedToCommit) {
+    if (absorbedPatchIds.has(patch.id)) {
+      absorbed.push(patch);
+      continue;
+    }
+    const r2 = resultByPatchId.get(patch.id);
+    if (!r2) {
+      applied.push(patch);
+      continue;
+    }
+    if (r2.status === "conflict" || patch.status === "unresolved") {
+      unresolved.push(patch);
+      continue;
+    }
+    if (r2.status === "applied") {
+      applied.push(patch);
+      continue;
+    }
+  }
+  return { applied, unresolved, absorbed };
 }
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
@@ -22703,7 +23113,7 @@ function parseGitLog(log) {
   });
 }
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_path11.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");
@@ -22726,7 +23136,7 @@ function ensureFernignoreEntries(outputDir) {
   return true;
 }
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = (0, import_path11.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");
@@ -22921,7 +23331,7 @@ async function resolve7(outputDir, options) {
   const resolvingPatches = lockManager.getResolvingPatches();
   if (unresolvedPatches.length > 0) {
     const applicator = new ReplayApplicator(git, lockManager, outputDir);
-    await applicator.applyPatches(unresolvedPatches);
+    await applicator.applyPatches(unresolvedPatches, { applyMode: "resolve" });
     const markerFiles = await findConflictMarkerFiles(git);
     if (markerFiles.length > 0) {
       for (const patch of unresolvedPatches) {
@@ -22947,20 +23357,80 @@ async function resolve7(outputDir, options) {
   if (patchesToCommit.length > 0) {
     const currentGen = lock.current_generation;
     const detector = new ReplayDetector(git, lockManager, outputDir);
+    const warnings = [];
     let patchesResolved = 0;
+    const pass1 = [];
     for (const patch of patchesToCommit) {
-      const diff = await git.exec(["diff", currentGen, "--", ...patch.files]).catch(() => null);
-      if (!diff || !diff.trim()) {
+      const result = await computePerPatchDiffWithFallback(
+        patch,
+        (f2) => git.showFile(currentGen, f2),
+        (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;
       }
-      const newContentHash = detector.computeContentHash(diff);
-      const changedFiles = await getChangedFiles(git, currentGen, patch.files);
+      if (r2.hadFallback) {
+        warnings.push(
+          `Patch ${patch.id}: ${r2.fallbackFiles.join(", ")} could not be anchored; cumulative-diff fallback applied for those files`
+        );
+      }
+      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
+        files: filesForSnapshot,
+        ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
       });
       patchesResolved++;
     }
@@ -22976,7 +23446,8 @@ async function resolve7(outputDir, options) {
       success: true,
       commitSha: commitSha2,
       phase: "committed",
-      patchesResolved
+      patchesResolved,
+      warnings: warnings.length > 0 ? warnings : void 0
     };
   }
   const committer = new ReplayCommitter(git, outputDir);
@@ -22994,6 +23465,24 @@ async function getChangedFiles(git, currentGen, files) {
   const changed = filesOutput.trim().split("\n").filter(Boolean).filter((f2) => !f2.startsWith(".fern/"));
   return changed.length > 0 ? changed : files;
 }
+function extractFilesFromDiff(unifiedDiff2) {
+  const out = /* @__PURE__ */ new Set();
+  const renameSources = /* @__PURE__ */ new Set();
+  let currentTarget = null;
+  for (const line of unifiedDiff2.split("\n")) {
+    const headerMatch = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+    if (headerMatch) {
+      currentTarget = headerMatch[2];
+      if (!currentTarget.startsWith(".fern/")) out.add(currentTarget);
+      continue;
+    }
+    if (currentTarget && line.startsWith("rename from ")) {
+      renameSources.add(line.slice("rename from ".length));
+    }
+  }
+  for (const src of renameSources) out.delete(src);
+  return Array.from(out);
+}
 function status(outputDir) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
@@ -23041,33 +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_crypto2, import_fs8, import_path10, import_yaml2, import_crypto3, import_fs9, import_path11, import_fs10, __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.13.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");
+    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_path9 = require("path");
+    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_path10 = require("path");
+    import_path12 = require("path");
     init_esm3();
     import_yaml2 = __toESM(require_dist3(), 1);
     import_crypto3 = require("crypto");
     import_fs9 = require("fs");
-    import_path11 = require("path");
+    import_path13 = require("path");
     init_esm3();
     import_fs10 = require("fs");
+    import_promises7 = require("fs/promises");
+    import_path14 = require("path");
     __defProp3 = Object.defineProperty;
     __getOwnPropNames3 = Object.getOwnPropertyNames;
     __esm3 = (fn, res) => function __init() {
@@ -23095,9 +23594,9 @@ var init_dist3 = __esm({
             return this.git.raw(args);
           }
           async execWithInput(args, input) {
-            const { spawn: spawn2 } = await import("child_process");
+            const { spawn: spawn22 } = await import("child_process");
             return new Promise((resolve22, reject) => {
-              const proc = spawn2("git", args, { cwd: this.repoPath });
+              const proc = spawn22("git", args, { cwd: this.repoPath });
               let stdout = "";
               let stderr = "";
               proc.stdout.on("data", (data) => {
@@ -23223,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-----/ },
@@ -23262,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);
@@ -23309,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 = [];
@@ -23327,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 });
         }
@@ -23427,879 +23946,440 @@ 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;
-          }
-          if (lock.patches.find((p) => p.original_commit === commit.sha)) {
-            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);
           }
-          const parents = await this.git.getCommitParents(commit.sha);
-          if (parents.length > 1) {
-            const compositePatch = await this.createMergeCompositePatch({
-              mergeCommit: commit,
-              firstParent: parents[0],
-              lastGen,
-              lock
+        }
+        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"
             });
-            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) {
+          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 {
-                  patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
+                  const content = await (0, import_promises4.readFile)(filePath, "utf-8");
+                  const stripped = stripConflictMarkers(content);
+                  await (0, import_promises4.writeFile)(filePath, stripped);
                 } catch {
-                  continue;
                 }
-                if (!patchContent.trim()) continue;
-                contentHash = this.computeContentHash(patchContent);
               }
             }
           }
-          if (files.length === 0) {
-            continue;
+        }
+        return results;
+      }
+      /**
+       * Populate accumulator after git apply succeeds, AND collect per-file
+       * results including any "dropped context lines" — lines that were
+       * present in BASE and THEIRS (unchanged context) but absent from the
+       * final on-disk state because OURS deleted them. This is the fast-path
+       * counterpart to ThreeWayMerge.computeDroppedContextLines used by the
+       * 3-way slow path; both must surface the same warning.
+       */
+      async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
+        const fileResults = [];
+        if (!baseGen) return fileResults;
+        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"]);
+        await tempGit.exec(["config", "user.email", "replay@fern.com"]);
+        await tempGit.exec(["config", "user.name", "Fern Replay"]);
+        try {
+          for (const filePath of patch.files) {
+            if (isBinaryFile(filePath)) continue;
+            const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
+            const base = await this.git.showFile(baseGen.tree_hash, filePath);
+            const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
+            const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
+            const theirs = !fileIsShared && snapshotForFile != null ? snapshotForFile : await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
+            const finalOnDisk = await (0, import_promises4.readFile)((0, import_path9.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+            const effectiveTheirs = theirs ?? finalOnDisk;
+            if (effectiveTheirs != null) {
+              this.fileTheirsAccumulator.set(resolvedPath, {
+                content: effectiveTheirs,
+                baseGeneration: patch.base_generation
+              });
+            }
+            if (base != null && effectiveTheirs != null && finalOnDisk != null) {
+              const dropped = computeDroppedContextLinesForFile(base, effectiveTheirs, finalOnDisk);
+              if (dropped.length > 0) {
+                fileResults.push({
+                  file: resolvedPath,
+                  status: "merged",
+                  droppedContextLines: dropped
+                });
+              }
+            }
           }
-          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 } : {}
+        } finally {
+          await (0, import_promises4.rm)(tempDir, { recursive: true }).catch(() => {
           });
         }
-        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 = "";
+        return fileResults;
+      }
+      async applyPatchWithFallback(patch) {
+        const baseGen = await this.resolveBaseGeneration(patch.base_generation);
+        const lock = this.lockManager.read();
+        const currentGen = lock.generations.find((g2) => g2.commit_sha === lock.current_generation);
+        const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
+        const needsAccumulation = await Promise.all(
+          patch.files.map(async (f2) => {
+            if (!baseGen) return false;
+            const resolved = await this.resolveFilePath(f2, baseGen.tree_hash, currentTreeHash);
+            return this.fileTheirsAccumulator.has(resolved);
+          })
+        ).then((results) => results.some(Boolean));
+        const resolvedFiles = {};
+        for (const filePath of patch.files) {
+          const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
+          if (resolvedPath !== filePath) {
+            resolvedFiles[filePath] = resolvedPath;
+          }
+        }
+        const patchIsRenameAware = /^rename from /m.test(patch.patch_content);
+        const hasGeneratorRename = Object.keys(resolvedFiles).length > 0 && !patchIsRenameAware;
+        if (!needsAccumulation && !hasGeneratorRename) {
+          const snapshots = /* @__PURE__ */ new Map();
+          for (const filePath of patch.files) {
+            const fullPath = (0, import_path9.join)(this.outputDir, filePath);
+            snapshots.set(filePath, await (0, import_promises4.readFile)(fullPath, "utf-8").catch(() => null));
+          }
           try {
-            body = await this.git.getCommitBody(patch.original_commit);
+            await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
+            const fastPathFileResults = await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
+            return {
+              patch,
+              status: "applied",
+              method: "git-am",
+              ...fastPathFileResults.length > 0 && { fileResults: fastPathFileResults },
+              ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+            };
           } catch {
+            for (const [filePath, content] of snapshots) {
+              const fullPath = (0, import_path9.join)(this.outputDir, filePath);
+              if (content != null) {
+                await (0, import_promises4.writeFile)(fullPath, content);
+              } else {
+                await (0, import_promises4.unlink)(fullPath).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;
+        }
+        return this.applyWithThreeWayMerge(patch);
+      }
+      async applyWithThreeWayMerge(patch) {
+        const fileResults = [];
+        const resolvedFiles = {};
+        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"]);
+        await tempGit.exec(["config", "user.email", "replay@fern.com"]);
+        await tempGit.exec(["config", "user.name", "Fern Replay"]);
+        try {
+          for (const filePath of patch.files) {
+            if (isBinaryFile(filePath)) {
+              fileResults.push({
+                file: filePath,
+                status: "skipped",
+                reason: "binary-file"
+              });
+              continue;
+            }
+            const result = await this.mergeFile(patch, filePath, tempGit, tempDir);
+            if (result.file !== filePath) {
+              resolvedFiles[filePath] = result.file;
             }
+            fileResults.push(result);
           }
-          if (!matchedExisting && revertedMessage) {
-            const existing = lock.patches.find((p) => p.original_message === revertedMessage);
-            if (existing) {
-              revertedPatchIdSet.add(existing.id);
-              revertIndicesToRemove.add(i);
-              matchedExisting = true;
+        } finally {
+          await (0, import_promises4.rm)(tempDir, { recursive: true }).catch(() => {
+          });
+        }
+        const conflictFiles = fileResults.filter((r2) => r2.status === "conflict");
+        const hasConflicts = conflictFiles.length > 0;
+        const conflictReason = hasConflicts ? conflictFiles.some((f2) => f2.conflictReason === "base-generation-mismatch") ? "base-generation-mismatch" : conflictFiles[0]?.conflictReason : void 0;
+        return {
+          patch,
+          status: hasConflicts ? "conflict" : "applied",
+          method: "3way-merge",
+          fileResults,
+          conflictReason,
+          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+        };
+      }
+      async mergeFile(patch, filePath, tempGit, tempDir) {
+        try {
+          const baseGen = await this.resolveBaseGeneration(patch.base_generation);
+          if (!baseGen) {
+            return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
+          }
+          const lock = this.lockManager.read();
+          const currentGen = lock.generations.find((g2) => g2.commit_sha === lock.current_generation);
+          const currentTreeHash = currentGen?.tree_hash ?? baseGen.tree_hash;
+          const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
+          const metadata = {
+            patchId: patch.id,
+            patchMessage: patch.original_message,
+            baseGeneration: patch.base_generation,
+            currentGeneration: lock.current_generation
+          };
+          let base = await this.git.showFile(baseGen.tree_hash, filePath);
+          let renameSourcePath;
+          if (!base) {
+            const renameSource = this.extractRenameSource(patch.patch_content, filePath);
+            if (renameSource) {
+              base = await this.git.showFile(baseGen.tree_hash, renameSource);
+              renameSourcePath = renameSource;
             }
           }
-          if (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;
+          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) {
+            const treeReachable = await this.isTreeReachable(baseGen.tree_hash);
+            if (!treeReachable) {
+              const fileDiff = this.extractFileDiff(patch.patch_content, filePath);
+              if (fileDiff) {
+                const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
+                const result = reconstructFromGhostPatch2(fileDiff, ours);
+                if (result) {
+                  base = result.base;
+                  theirs = result.theirs;
+                  ghostReconstructed = true;
+                }
+              }
             }
           }
-          if (!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);
+          const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
+          const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
+          const useSnapshotAsPrimary = !fileIsShared && snapshotForFile != null;
+          if (!ghostReconstructed) {
+            if (useSnapshotAsPrimary) {
+              theirs = snapshotForFile;
+            } else {
+              theirs = await this.applyPatchToContent(
+                base,
+                patch.patch_content,
+                filePath,
+                tempGit,
+                tempDir,
+                renameSourcePath
+              );
+              const reconstructionHasMarkers = theirs != null && (theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization"));
+              const baseHadMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
+              if (reconstructionHasMarkers && !baseHadMarkers && snapshotForFile != null) {
+                theirs = snapshotForFile;
+              }
             }
           }
-          if (!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();
-      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
-       */
-      async applyPatches(patches) {
-        this.resetAccumulator();
-        const results = [];
-        for (let i = 0; i < patches.length; i++) {
-          const patch = patches[i];
-          if (this.isExcluded(patch)) {
-            results.push({
-              patch,
-              status: "skipped",
-              method: "git-am"
-            });
-            continue;
-          }
-          const result = await this.applyPatchWithFallback(patch);
-          results.push(result);
-          if (result.status === "conflict" && result.fileResults) {
-            const laterFiles = /* @__PURE__ */ new Set();
-            for (let 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 {
-                }
-              }
-            }
-          }
-        }
-        return results;
-      }
-      /** Populate accumulator after git apply succeeds. */
-      async populateAccumulatorForPatch(patch, baseGen, currentTreeHash) {
-        if (!baseGen) return;
-        const tempDir = await (0, import_promises3.mkdtemp)((0, import_path8.join)((0, import_os.tmpdir)(), "replay-acc-"));
-        const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
-        const tempGit = new GitClient2(tempDir);
-        await tempGit.exec(["init"]);
-        await tempGit.exec(["config", "user.email", "replay@fern.com"]);
-        await tempGit.exec(["config", "user.name", "Fern Replay"]);
-        try {
-          for (const filePath of patch.files) {
-            if (isBinaryFile(filePath)) continue;
-            const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
-            const base = await this.git.showFile(baseGen.tree_hash, filePath);
-            const theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
-            const effectiveTheirs = theirs ?? await (0, import_promises3.readFile)((0, import_path8.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
-            if (effectiveTheirs != null) {
-              this.fileTheirsAccumulator.set(resolvedPath, {
-                content: effectiveTheirs,
-                baseGeneration: patch.base_generation
-              });
-            }
-          }
-        } finally {
-          await (0, import_promises3.rm)(tempDir, { recursive: true }).catch(() => {
-          });
-        }
-      }
-      async applyPatchWithFallback(patch) {
-        const baseGen = await this.resolveBaseGeneration(patch.base_generation);
-        const lock = this.lockManager.read();
-        const currentGen = lock.generations.find((g2) => g2.commit_sha === lock.current_generation);
-        const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
-        const needsAccumulation = await Promise.all(
-          patch.files.map(async (f2) => {
-            if (!baseGen) return false;
-            const resolved = await this.resolveFilePath(f2, baseGen.tree_hash, currentTreeHash);
-            return this.fileTheirsAccumulator.has(resolved);
-          })
-        ).then((results) => results.some(Boolean));
-        const resolvedFiles = {};
-        for (const filePath of patch.files) {
-          const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
-          if (resolvedPath !== filePath) {
-            resolvedFiles[filePath] = resolvedPath;
-          }
-        }
-        const patchIsRenameAware = /^rename from /m.test(patch.patch_content);
-        const hasGeneratorRename = Object.keys(resolvedFiles).length > 0 && !patchIsRenameAware;
-        if (!needsAccumulation && !hasGeneratorRename) {
-          const snapshots = /* @__PURE__ */ new Map();
-          for (const filePath of patch.files) {
-            const fullPath = (0, import_path8.join)(this.outputDir, filePath);
-            snapshots.set(filePath, await (0, import_promises3.readFile)(fullPath, "utf-8").catch(() => null));
-          }
-          try {
-            await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
-            await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
-            return {
-              patch,
-              status: "applied",
-              method: "git-am",
-              ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
-            };
-          } catch {
-            for (const [filePath, content] of snapshots) {
-              const fullPath = (0, import_path8.join)(this.outputDir, filePath);
-              if (content != null) {
-                await (0, import_promises3.writeFile)(fullPath, content);
-              } else {
-                await (0, import_promises3.unlink)(fullPath).catch(() => {
-                });
-              }
-            }
-          }
-        }
-        return this.applyWithThreeWayMerge(patch);
-      }
-      async applyWithThreeWayMerge(patch) {
-        const fileResults = [];
-        const resolvedFiles = {};
-        const tempDir = await (0, import_promises3.mkdtemp)((0, import_path8.join)((0, import_os.tmpdir)(), "replay-"));
-        const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
-        const tempGit = new GitClient2(tempDir);
-        await tempGit.exec(["init"]);
-        await tempGit.exec(["config", "user.email", "replay@fern.com"]);
-        await tempGit.exec(["config", "user.name", "Fern Replay"]);
-        try {
-          for (const filePath of patch.files) {
-            if (isBinaryFile(filePath)) {
-              fileResults.push({
-                file: filePath,
-                status: "skipped",
-                reason: "binary-file"
-              });
-              continue;
-            }
-            const result = await this.mergeFile(patch, filePath, tempGit, tempDir);
-            if (result.file !== filePath) {
-              resolvedFiles[filePath] = result.file;
-            }
-            fileResults.push(result);
-          }
-        } finally {
-          await (0, import_promises3.rm)(tempDir, { recursive: true }).catch(() => {
-          });
-        }
-        const conflictFiles = fileResults.filter((r2) => r2.status === "conflict");
-        const hasConflicts = conflictFiles.length > 0;
-        const conflictReason = hasConflicts ? conflictFiles.some((f2) => f2.conflictReason === "base-generation-mismatch") ? "base-generation-mismatch" : conflictFiles[0]?.conflictReason : void 0;
-        return {
-          patch,
-          status: hasConflicts ? "conflict" : "applied",
-          method: "3way-merge",
-          fileResults,
-          conflictReason,
-          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
-        };
-      }
-      async mergeFile(patch, filePath, tempGit, tempDir) {
-        try {
-          const baseGen = await this.resolveBaseGeneration(patch.base_generation);
-          if (!baseGen) {
-            return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
-          }
-          const lock = this.lockManager.read();
-          const currentGen = lock.generations.find((g2) => g2.commit_sha === lock.current_generation);
-          const currentTreeHash = currentGen?.tree_hash ?? baseGen.tree_hash;
-          const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
-          const metadata = {
-            patchId: patch.id,
-            patchMessage: patch.original_message,
-            baseGeneration: patch.base_generation,
-            currentGeneration: lock.current_generation
-          };
-          let base = await this.git.showFile(baseGen.tree_hash, filePath);
-          let renameSourcePath;
-          if (!base) {
-            const renameSource = this.extractRenameSource(patch.patch_content, filePath);
-            if (renameSource) {
-              base = await this.git.showFile(baseGen.tree_hash, renameSource);
-              renameSourcePath = renameSource;
-            }
-          }
-          const oursPath = (0, import_path8.join)(this.outputDir, resolvedPath);
-          const ours = await (0, import_promises3.readFile)(oursPath, "utf-8").catch(() => null);
-          let ghostReconstructed = false;
-          let theirs = null;
-          if (!base && ours && !renameSourcePath) {
-            const treeReachable = await this.isTreeReachable(baseGen.tree_hash);
-            if (!treeReachable) {
-              const fileDiff = this.extractFileDiff(patch.patch_content, filePath);
-              if (fileDiff) {
-                const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
-                const result = reconstructFromGhostPatch2(fileDiff, ours);
-                if (result) {
-                  base = result.base;
-                  theirs = result.theirs;
-                  ghostReconstructed = true;
-                }
-              }
-            }
-          }
-          if (!ghostReconstructed) {
-            theirs = await this.applyPatchToContent(
-              base,
-              patch.patch_content,
-              filePath,
-              tempGit,
-              tempDir,
-              renameSourcePath
-            );
-          }
-          if (theirs) {
-            const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
-            const baseHasMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
-            if (theirsHasMarkers && !baseHasMarkers) {
-              return {
-                file: resolvedPath,
-                status: "skipped",
-                reason: "stale-conflict-markers"
-              };
-            }
+          const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
+          if (theirs) {
+            const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
+            const baseHasMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
+            if (theirsHasMarkers && !baseHasMarkers) {
+              if (accumulatorEntry) {
+                theirs = null;
+              } else {
+                return {
+                  file: resolvedPath,
+                  status: "skipped",
+                  reason: "stale-conflict-markers"
+                };
+              }
+            }
           }
           let useAccumulatorAsMergeBase = false;
-          const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
           if (accumulatorEntry && (theirs == null || base == null)) {
             theirs = await this.applyPatchToContent(
               accumulatorEntry.content,
@@ -24355,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,
@@ -24402,205 +24482,773 @@ var init_dist3 = __esm({
               reason: "missing-content"
             };
           }
-          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);
-          if (effective_theirs != null && !merged.hasConflicts) {
-            this.fileTheirsAccumulator.set(resolvedPath, {
-              content: effective_theirs,
-              baseGeneration: patch.base_generation
-            });
+          const merged = threeWayMerge(mergeBase, ours, effective_theirs);
+          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, {
+              content: effective_theirs,
+              baseGeneration: patch.base_generation
+            });
+          }
+          if (merged.hasConflicts) {
+            return {
+              file: resolvedPath,
+              status: "conflict",
+              conflicts: merged.conflicts,
+              conflictReason: baseMismatchSkipped ? "base-generation-mismatch" : "same-line-edit",
+              conflictMetadata: metadata
+            };
+          }
+          return {
+            file: resolvedPath,
+            status: "merged",
+            ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
+          };
+        } catch (error) {
+          return {
+            file: filePath,
+            status: "skipped",
+            reason: `error: ${error instanceof Error ? error.message : String(error)}`
+          };
+        }
+      }
+      async isTreeReachable(treeHash) {
+        let result = this.treeExistsCache.get(treeHash);
+        if (result === void 0) {
+          result = await this.git.treeExists(treeHash);
+          this.treeExistsCache.set(treeHash, result);
+        }
+        return result;
+      }
+      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] };
+      }
+      /**
+       * 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 (merged.hasConflicts) {
-            return {
-              file: resolvedPath,
-              status: "conflict",
-              conflicts: merged.conflicts,
-              conflictReason: baseMismatchSkipped ? "base-generation-mismatch" : "same-line-edit",
-              conflictMetadata: metadata
-            };
+        }
+        if (!anyCandidate) return patches;
+        const headFiles = await this.listHeadFiles();
+        const transient = /* @__PURE__ */ new Set();
+        for (const [file, state] of stateByFile) {
+          if (state.created && state.deleted && !headFiles.has(file)) {
+            transient.add(file);
           }
-          return { file: resolvedPath, status: "merged" };
-        } catch (error) {
-          return {
-            file: filePath,
-            status: "skipped",
-            reason: `error: ${error instanceof Error ? error.message : String(error)}`
-          };
         }
+        if (transient.size === 0) return patches;
+        return patches.filter((patch) => !patch.files.every((f2) => transient.has(f2)));
       }
-      async isTreeReachable(treeHash) {
-        let result = this.treeExistsCache.get(treeHash);
-        if (result === void 0) {
-          result = await this.git.treeExists(treeHash);
-          this.treeExistsCache.set(treeHash, result);
+      /**
+       * List every tracked path at HEAD (one `git ls-tree -r` invocation).
+       * Returns an empty Set if HEAD is unborn or the invocation fails — the
+       * caller then treats every candidate as "not in HEAD" and may collapse
+       * more aggressively. On typical SDK repos this is a single sub-10ms call.
+       */
+      async listHeadFiles() {
+        try {
+          const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
+          return new Set(out.split("\n").map((l) => l.trim()).filter(Boolean));
+        } catch {
+          return /* @__PURE__ */ new Set();
         }
-        return result;
-      }
-      isExcluded(patch) {
-        const config = this.lockManager.getCustomizationsConfig();
-        if (!config.exclude) return false;
-        return patch.files.some((file) => config.exclude.some((pattern) => 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);
-              }
-            }
-          }
+      /**
+       * 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.`
+          );
         }
-        const cacheKey = `${baseTreeHash}:${currentTreeHash}`;
-        let renames = this.renameCache.get(cacheKey);
-        if (!renames) {
-          renames = await this.git.detectRenames(baseTreeHash, currentTreeHash);
-          this.renameCache.set(cacheKey, renames);
+        if (files.length === 0) return null;
+        const diff = await this.git.exec([
+          "diff",
+          firstParent,
+          mergeCommit.sha,
+          "--",
+          ...files
+        ]);
+        if (!diff.trim()) return null;
+        const contentHash = this.computeContentHash(diff);
+        if (lock.patches.some((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
+          return null;
         }
-        const gitRename = renames.find((r2) => r2.from === filePath);
-        if (gitRename) {
-          return gitRename.to;
+        const theirsSnapshot = {};
+        for (const file of files) {
+          if (isBinaryFile(file)) continue;
+          const content = await this.git.showFile(mergeCommit.sha, file).catch(() => null);
+          if (content != null) theirsSnapshot[file] = content;
         }
-        return filePath;
+        return {
+          id: `patch-merge-${mergeCommit.sha.slice(0, 8)}`,
+          content_hash: contentHash,
+          original_commit: mergeCommit.sha,
+          original_message: mergeCommit.message,
+          original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
+          base_generation: lastGen.commit_sha,
+          files,
+          patch_content: diff,
+          ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+          ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
+        };
       }
-      async applyPatchToContent(base, patchContent, filePath, tempGit, tempDir, sourceFilePath) {
-        if (!base) {
-          return this.extractNewFileFromPatch(patchContent, filePath);
+      /**
+       * Detect patches via tree diff for non-linear history. Returns a composite patch.
+       * Revert reconciliation is skipped here because tree-diff produces a single composite
+       * patch from the aggregate diff — individual revert commits are not distinguishable.
+       */
+      async detectPatchesViaTreeDiff(lastGen, commitKnownMissing) {
+        const diffBase = await this.resolveDiffBase(lastGen, commitKnownMissing);
+        if (!diffBase) {
+          return this.detectPatchesViaCommitScan();
         }
-        const fileDiff = this.extractFileDiff(patchContent, filePath);
-        if (!fileDiff) return null;
-        try {
-          if (sourceFilePath) {
-            const tempSourcePath = (0, import_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");
-        } catch {
-          return null;
+        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: [] };
       }
       /**
-       * Detects whether a patch's additions are already present in `content`.
-       * Uses `git apply --reverse --check` — if the reverse patch applies cleanly,
-       * the forward patch is effectively a no-op (its +lines are already there and
-       * its -lines are already gone). Used to distinguish "patch already applied"
-       * from "patch base mismatch" after a forward-apply fails.
+       * Last-resort detection when both generation commit and tree are unreachable.
+       * Scans all commits from HEAD, filters against known lockfile patches, and
+       * skips creation-only commits (squashed history after force push).
+       *
+       * Detected patches use the commit's parent as base_generation so the applicator
+       * can find base file content from the parent's tree (which IS reachable).
        */
-      async isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
-        const fileDiff = this.extractFileDiff(patchContent, filePath);
-        if (!fileDiff) return false;
-        try {
-          const tempFilePath = (0, import_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 detectPatchesViaCommitScan() {
+        const lock = this.lockManager.read();
+        const log = await this.git.exec([
+          "log",
+          "--max-count=200",
+          "--format=%H%x00%an%x00%ae%x00%s",
+          "HEAD",
+          "--",
+          this.sdkOutputDir
+        ]);
+        if (!log.trim()) {
+          return { patches: [], revertedPatchIds: [] };
         }
-      }
-      extractFileDiff(patchContent, filePath) {
-        const lines = patchContent.split("\n");
-        const diffLines = [];
-        let inTargetFile = false;
-        for (const line of lines) {
-          if (line.startsWith("diff --git")) {
-            if (inTargetFile) {
-              break;
-            }
-            if (isDiffLineForFile(line, filePath)) {
-              inTargetFile = true;
-              diffLines.push(line);
-            }
+        const commits = this.parseGitLog(log);
+        const newPatches = [];
+        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+        const existingHashes = new Set(lock.patches.map((p) => p.content_hash));
+        const existingCommits = new Set(lock.patches.map((p) => p.original_commit));
+        for (const commit of commits) {
+          if (isGenerationCommit(commit)) {
             continue;
           }
-          if (inTargetFile) {
-            diffLines.push(line);
+          const parents = await this.git.getCommitParents(commit.sha);
+          if (parents.length > 1) {
+            continue;
           }
-        }
-        return diffLines.length > 0 ? diffLines.join("\n") + "\n" : null;
-      }
-      extractRenameSource(patchContent, targetFilePath) {
-        const lines = patchContent.split("\n");
-        let inTargetFile = false;
-        for (const line of lines) {
-          if (line.startsWith("diff --git")) {
-            if (inTargetFile) break;
-            inTargetFile = isDiffLineForFile(line, targetFilePath);
+          if (existingCommits.has(commit.sha)) {
             continue;
           }
-          if (!inTargetFile) continue;
-          if (line.startsWith("@@")) break;
-          if (line.startsWith("rename from ")) {
-            return line.slice("rename from ".length);
+          let patchContent;
+          try {
+            patchContent = await this.git.formatPatch(commit.sha);
+          } catch {
+            continue;
           }
-        }
-        return null;
-      }
-      extractNewFileFromPatch(patchContent, filePath) {
-        const lines = patchContent.split("\n");
-        const addedLines = [];
-        let inTargetFile = false;
-        let inHunk = false;
-        let isNewFile = false;
-        let noTrailingNewline = false;
-        for (const line of lines) {
-          if (line.startsWith("diff --git")) {
-            if (inTargetFile) break;
-            inTargetFile = isDiffLineForFile(line, filePath);
-            inHunk = false;
-            isNewFile = false;
+          let contentHash = this.computeContentHash(patchContent);
+          if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
             continue;
           }
-          if (!inTargetFile) continue;
-          if (!inHunk) {
-            if (line === "--- /dev/null" || line.startsWith("new file mode")) {
-              isNewFile = true;
+          if (this.isCreationOnlyPatch(patchContent)) {
+            continue;
+          }
+          const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
+          const allScanFiles = filesOutput.trim().split("\n").filter(Boolean).filter((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 {
@@ -24632,13 +25280,46 @@ CLI Version: ${options.cliVersion}`;
         await this.git.exec(["commit", "-m", fullMessage]);
         return (await this.git.exec(["rev-parse", "HEAD"])).trim();
       }
-      async commitReplay(_patchCount, patches, message) {
+      async commitReplay(_patchCount, patches, message, options) {
         await this.stageAll();
         if (!await this.hasStagedChanges()) {
           return (await this.git.exec(["rev-parse", "HEAD"])).trim();
         }
         let fullMessage = message ?? `[fern-replay] Applied customizations`;
-        if (patches && patches.length > 0) {
+        const buckets = options?.buckets;
+        if (buckets) {
+          if (buckets.applied.length > 0) {
+            fullMessage += `
+
+Patches applied (${buckets.applied.length}):`;
+            for (const p of buckets.applied) {
+              fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+            }
+          }
+          if (buckets.unresolved.length > 0) {
+            fullMessage += `
+
+Patches with unresolved conflicts (${buckets.unresolved.length}):`;
+            for (const p of buckets.unresolved) {
+              fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+            }
+            fullMessage += `
+    Run \`fern-replay resolve\` to apply these customizations.`;
+          }
+          if (buckets.absorbed.length > 0) {
+            fullMessage += `
+
+Patches absorbed by generator (${buckets.absorbed.length}):`;
+            for (const p of buckets.absorbed) {
+              fullMessage += `
+  - ${p.id}: ${p.original_message}`;
+            }
+            fullMessage += `
+    The generator now produces these customizations natively.`;
+          }
+        } else if (patches && patches.length > 0) {
           fullMessage += "\n\nPatches replayed:";
           for (const patch of patches) {
             fullMessage += `
@@ -24672,6 +25353,7 @@ CLI Version: ${options.cliVersion}`;
       }
     };
     init_GitClient();
+    init_HybridReconstruction();
     ReplayService = class {
       git;
       detector;
@@ -25065,6 +25747,7 @@ CLI Version: ${options.cliVersion}`;
         if (newPatches.length > 0) {
           results = await this.applicator.applyPatches(newPatches);
           this._lastApplyResults = results;
+          this.recordDroppedContextLineWarnings(results);
           this.revertConflictingFiles(results);
           for (const result of results) {
             if (result.status === "conflict") {
@@ -25083,7 +25766,8 @@ CLI Version: ${options.cliVersion}`;
         if (newPatches.length > 0) {
           if (!options?.stageOnly) {
             const appliedCount = results.filter((r2) => r2.status === "applied").length;
-            await this.committer.commitReplay(appliedCount, newPatches);
+            const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, newPatches);
+            await this.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
           } else {
             await this.committer.stageAll();
           }
@@ -25146,12 +25830,16 @@ CLI Version: ${options.cliVersion}`;
           (p) => preRebasePatchIds.has(p.id) && !postRebasePatchIds.has(p.id)
         );
         existingPatches = this.lockManager.getPatches();
-        const seenHashes = /* @__PURE__ */ new Set();
+        const seenHashes = /* @__PURE__ */ new Map();
         for (const p of existingPatches) {
-          if (seenHashes.has(p.content_hash)) {
+          const priorPatchId = seenHashes.get(p.content_hash);
+          if (priorPatchId !== void 0) {
             this.lockManager.removePatch(p.id);
+            this.warnings.push(
+              `Consolidated patch ${p.id} (commit ${(p.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content. Per-commit attribution preserved in git log; lockfile collapsed to avoid duplicate-apply corruption on next regen.`
+            );
           } else {
-            seenHashes.add(p.content_hash);
+            seenHashes.set(p.content_hash, p.id);
           }
         }
         existingPatches = this.lockManager.getPatches();
@@ -25212,6 +25900,7 @@ CLI Version: ${options.cliVersion}`;
         const genSha = prep._prepared.genSha;
         const results = await this.applicator.applyPatches(allPatches);
         this._lastApplyResults = results;
+        this.recordDroppedContextLineWarnings(results);
         this.revertConflictingFiles(results);
         for (const result of results) {
           if (result.status === "conflict") {
@@ -25239,7 +25928,8 @@ CLI Version: ${options.cliVersion}`;
           await this.committer.stageAll();
         } else {
           const appliedCount = results.filter((r2) => r2.status === "applied").length;
-          await this.committer.commitReplay(appliedCount, allPatches);
+          const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, allPatches);
+          await this.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
         }
         const warnings = [...detectorWarnings, ...this.warnings];
         return this.buildReport(
@@ -25263,7 +25953,7 @@ CLI Version: ${options.cliVersion}`;
         let repointed = 0;
         let contentRebased = 0;
         let keptAsUserOwned = 0;
-        const seenContentHashes = /* @__PURE__ */ new Set();
+        const seenContentHashes = /* @__PURE__ */ new Map();
         const absorbedPatchIds = /* @__PURE__ */ new Set();
         const fernignorePatterns = this.readFernignorePatterns();
         for (const result of results) {
@@ -25277,6 +25967,23 @@ CLI Version: ${options.cliVersion}`;
             }
           }
         }
+        const conflictedFilePaths = /* @__PURE__ */ new Set();
+        for (const r2 of results) {
+          if (r2.status !== "conflict") continue;
+          if (r2.fileResults) {
+            for (const fr of r2.fileResults) {
+              if (fr.status !== "conflict") continue;
+              conflictedFilePaths.add(fr.file);
+              if (r2.resolvedFiles) {
+                for (const [orig, resolved] of Object.entries(r2.resolvedFiles)) {
+                  if (resolved === fr.file) conflictedFilePaths.add(orig);
+                }
+              }
+            }
+          } else {
+            for (const f2 of r2.patch.files) conflictedFilePaths.add(f2);
+          }
+        }
         for (const result of results) {
           if (result.status === "conflict" && result.fileResults) {
             await this.trimAbsorbedFiles(result, currentGenSha);
@@ -25313,17 +26020,27 @@ CLI Version: ${options.cliVersion}`;
             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 {
               }
@@ -25344,6 +26061,18 @@ CLI Version: ${options.cliVersion}`;
                 keptAsUserOwned++;
                 continue;
               }
+              const overlapsConflicted = patch.files.some((f2) => conflictedFilePaths.has(f2));
+              if (overlapsConflicted) {
+                patch.status = "unresolved";
+                try {
+                  this.lockManager.updatePatch(patch.id, { status: "unresolved" });
+                } catch {
+                }
+                this.warnings.push(
+                  `Patch ${patch.id} (${patch.original_message}) was preserved as unresolved because an earlier patch conflicted on the same file(s) (${patch.files.join(", ")}). Run \`fern replay resolve\` to apply this customization manually.`
+                );
+                continue;
+              }
               this.lockManager.removePatch(patch.id);
               absorbedPatchIds.add(patch.id);
               absorbed++;
@@ -25359,21 +26088,34 @@ CLI Version: ${options.cliVersion}`;
               continue;
             }
             const newContentHash = this.detector.computeContentHash(diff);
-            if (seenContentHashes.has(newContentHash)) {
+            const priorPatchId = seenContentHashes.get(newContentHash);
+            if (priorPatchId !== void 0) {
               this.lockManager.removePatch(patch.id);
               absorbedPatchIds.add(patch.id);
               absorbed++;
+              if (priorPatchId !== patch.id) {
+                this.warnings.push(
+                  `Consolidated patch ${patch.id} (commit ${(patch.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content after rebase. Per-commit attribution preserved in git log.`
+                );
+              }
               continue;
+            } else {
+              seenContentHashes.set(newContentHash, patch.id);
             }
-            seenContentHashes.add(newContentHash);
             patch.base_generation = currentGenSha;
             patch.patch_content = diff;
             patch.content_hash = newContentHash;
+            const snapshot = await this.readSnapshotFromDisk(patch.files);
+            const snapshotIsNonEmpty = Object.keys(snapshot).length > 0;
+            if (snapshotIsNonEmpty) {
+              patch.theirs_snapshot = snapshot;
+            }
             try {
               this.lockManager.updatePatch(patch.id, {
                 base_generation: currentGenSha,
                 patch_content: diff,
-                content_hash: newContentHash
+                content_hash: newContentHash,
+                ...snapshotIsNonEmpty ? { theirs_snapshot: snapshot } : {}
               });
             } catch {
             }
@@ -25383,6 +26125,112 @@ CLI Version: ${options.cliVersion}`;
         }
         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).
        *
@@ -25503,6 +26351,20 @@ CLI Version: ${options.cliVersion}`;
           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;
@@ -25539,10 +26401,23 @@ CLI Version: ${options.cliVersion}`;
             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 diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
-              if (diff === null) continue;
+              const ppResult = await computePerPatchDiffWithFallback(
+                patch,
+                (f2) => this.git.showFile(currentGen, f2),
+                (f2) => this.git.showFile("HEAD", f2),
+                (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+              );
+              if (ppResult === null) continue;
+              const diff = ppResult.diff;
               if (!diff.trim()) {
                 if (await allPatchFilesUserOwned(patch)) continue;
                 this.lockManager.removePatch(patch.id);
@@ -25569,10 +26444,12 @@ CLI Version: ${options.cliVersion}`;
                 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++;
@@ -25584,8 +26461,14 @@ CLI Version: ${options.cliVersion}`;
           try {
             const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "HEAD", "--", ...patch.files]).catch(() => "");
             if (markerFiles.trim()) continue;
-            const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
-            if (diff === null) continue;
+            const ppResult = await computePerPatchDiffWithFallback(
+              patch,
+              (f2) => this.git.showFile(currentGen, f2),
+              (f2) => this.git.showFile("HEAD", f2),
+              (files) => this.git.exec(["diff", currentGen, "HEAD", "--", ...files]).catch(() => null)
+            );
+            if (ppResult === null) continue;
+            const diff = ppResult.diff;
             if (!diff.trim()) {
               if (await allPatchFilesUserOwned(patch)) {
                 try {
@@ -25599,10 +26482,12 @@ CLI Version: ${options.cliVersion}`;
               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 {
@@ -25610,6 +26495,32 @@ CLI Version: ${options.cliVersion}`;
         }
         return { conflictResolved, conflictAbsorbed, contentRefreshed };
       }
+      /**
+       * After applyPatches(), surface a warning for each (patch × file) where
+       * diff3 silently dropped lines that were unchanged context in the
+       * customer's THEIRS. The deletion stays on disk (correct diff3 outcome),
+       * but the customer must learn so they can re-add the lines if they
+       * relied on them. This is the "surface or preserve, never silently drop"
+       * contract for legitimate-deletion cases.
+       */
+      recordDroppedContextLineWarnings(results) {
+        const PREVIEW_COUNT = 5;
+        for (const result of results) {
+          if (!result.fileResults) continue;
+          for (const fr of result.fileResults) {
+            const dropped = fr.droppedContextLines;
+            if (!dropped || dropped.length === 0) continue;
+            const preview = dropped.slice(0, PREVIEW_COUNT).map((line) => `    ${line}`).join("\n");
+            const more = dropped.length > PREVIEW_COUNT ? `
+    ... and ${dropped.length - PREVIEW_COUNT} more` : "";
+            this.warnings.push(
+              `${fr.file}: ${dropped.length} line(s) that appeared as unchanged context in your customization were deleted by the new generator output. The merge followed the deletion. First lines deleted:
+${preview}${more}
+If you want to keep these lines, restore them in a follow-up commit and re-run replay; otherwise this warning can be safely ignored.`
+            );
+          }
+        }
+      }
       /**
        * After applyPatches(), strip conflict markers from conflicting files
        * so only clean content is committed. Keeps the Generated (OURS) side.
@@ -25619,7 +26530,7 @@ CLI Version: ${options.cliVersion}`;
           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);
@@ -25649,7 +26560,7 @@ CLI Version: ${options.cliVersion}`;
         }
       }
       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("#"));
       }
@@ -25667,6 +26578,9 @@ CLI Version: ${options.cliVersion}`;
           };
         }).filter((d) => d.files.length > 0);
         const partialCount = conflictDetails.filter((d) => d.cleanFiles && d.cleanFiles.length > 0).length;
+        const unresolvedResults = results.filter(
+          (r2) => r2.status === "conflict" || r2.patch.status === "unresolved"
+        );
         return {
           flow,
           patchesDetected: patches.length,
@@ -25683,7 +26597,7 @@ CLI Version: ${options.cliVersion}`;
           patchesRefreshed: preRebaseCounts && preRebaseCounts.contentRefreshed > 0 ? preRebaseCounts.contentRefreshed : void 0,
           conflicts: conflictResults.flatMap((r2) => r2.fileResults?.filter((f2) => f2.status === "conflict") ?? []),
           conflictDetails: conflictDetails.length > 0 ? conflictDetails : void 0,
-          unresolvedPatches: conflictResults.length > 0 ? conflictResults.map((r2) => ({
+          unresolvedPatches: unresolvedResults.length > 0 ? unresolvedResults.map((r2) => ({
             patchId: r2.patch.id,
             patchMessage: r2.patch.original_message,
             files: r2.patch.files,
@@ -25704,10 +26618,10 @@ CLI Version: ${options.cliVersion}`;
         this.outputDir = outputDir;
       }
       fernignoreExists() {
-        return (0, import_fs8.existsSync)((0, import_path10.join)(this.outputDir, ".fernignore"));
+        return (0, import_fs8.existsSync)((0, import_path12.join)(this.outputDir, ".fernignore"));
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_path10.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_path12.join)(this.outputDir, ".fernignore");
         if (!(0, import_fs8.existsSync)(fernignorePath)) {
           return [];
         }
@@ -25759,6 +26673,12 @@ CLI Version: ${options.cliVersion}`;
             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,
@@ -25767,7 +26687,17 @@ CLI Version: ${options.cliVersion}`;
                 original_author: "Fern Replay <replay@buildwithfern.com>",
                 base_generation: currentGen.commit_sha,
                 files: patchFiles,
-                patch_content: patchContent
+                patch_content: patchContent,
+                ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+                // Synthetic patches captured from .fernignore-protected files
+                // are user-owned by definition — the customer's content
+                // diverges from the generator's pristine output, and the
+                // generator never produced this divergent content. Without
+                // this flag, removing the file from .fernignore later (so
+                // it leaves the protection check in `isFileUserOwned`) would
+                // expose the patch to absorption on the next regen,
+                // silently losing the customization.
+                user_owned: true
               });
               trackedByBoth.push({
                 file: pattern,
@@ -25800,7 +26730,7 @@ CLI Version: ${options.cliVersion}`;
         return results;
       }
       readFileContent(filePath) {
-        const fullPath = (0, import_path10.join)(this.outputDir, filePath);
+        const fullPath = (0, import_path12.join)(this.outputDir, filePath);
         if (!(0, import_fs8.existsSync)(fullPath)) {
           return null;
         }
@@ -25865,7 +26795,7 @@ CLI Version: ${options.cliVersion}`;
         };
       }
       movePatternsToReplayYml(patterns) {
-        const replayYmlPath = (0, import_path10.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");
@@ -25874,7 +26804,7 @@ CLI Version: ${options.cliVersion}`;
         const existing = config.exclude ?? [];
         const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
         config.exclude = merged;
-        const dir = (0, import_path10.dirname)(replayYmlPath);
+        const dir = (0, import_path12.dirname)(replayYmlPath);
         if (!(0, import_fs8.existsSync)(dir)) {
           (0, import_fs8.mkdirSync)(dir, { recursive: true });
         }
@@ -26378,7 +27308,7 @@ var require_cross_spawn = __commonJS({
     var cp2 = require("child_process");
     var parse3 = require_parse2();
     var enoent = require_enoent();
-    function spawn2(command, args, options) {
+    function spawn3(command, args, options) {
       const parsed = parse3(command, args, options);
       const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -26390,8 +27320,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn2;
-    module2.exports.spawn = spawn2;
+    module2.exports = spawn3;
+    module2.exports.spawn = spawn3;
     module2.exports.sync = spawnSync;
     module2.exports._parse = parse3;
     module2.exports._enoent = enoent;
@@ -28430,8 +29360,8 @@ function resolve(...paths) {
 
 // src/cli.ts
 var import_fs15 = __toESM(require("fs"));
-var import_promises11 = require("fs/promises");
-var import_path18 = __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 {
@@ -38132,42 +39062,42 @@ function replayForget(params) {
 // src/replay/replay-init.ts
 init_dist3();
 var import_fs11 = require("fs");
-var import_path13 = require("path");
+var import_path16 = require("path");
 var import_tmp_promise2 = __toESM(require_tmp_promise());
 
 // src/replay/fernignore.ts
-var import_promises4 = require("fs/promises");
-var import_path12 = 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_path12.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_path15.join)(outputDir, ".fernignore");
   let content = "";
   try {
-    content = await (0, import_promises4.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_promises4.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_path12.join)(outputDir, ".gitattributes");
+  const gitattributesPath = (0, import_path15.join)(outputDir, ".gitattributes");
   let content = "";
   try {
-    content = await (0, import_promises4.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_promises4.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
+    await (0, import_promises8.writeFile)(gitattributesPath, content + suffix + toAdd.join("\n") + "\n", "utf-8");
   }
 }
 
@@ -38194,7 +39124,7 @@ async function replayInit(params) {
   if (dryRun) {
     return { bootstrap: bootstrapResult, fernignoreEntries: [], gitattributesEntries: [] };
   }
-  const lockfilePath = (0, import_path13.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,
@@ -38315,9 +39245,9 @@ init_dist3();
 
 // src/replay/replay-run.ts
 init_dist3();
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_fs12 = require("fs");
-var import_path14 = require("path");
+var import_path17 = require("path");
 async function replayPrepare(params) {
   const {
     outputDir,
@@ -38328,7 +39258,7 @@ async function replayPrepare(params) {
     skipApplication,
     logger
   } = params;
-  const lockfilePath = (0, import_path14.join)(outputDir, ".fern", "replay.lock");
+  const lockfilePath = (0, import_path17.join)(outputDir, ".fern", "replay.lock");
   if (!(0, import_fs12.existsSync)(lockfilePath)) {
     return null;
   }
@@ -38460,7 +39390,7 @@ async function replayRun(params) {
 }
 function isTagMergedIntoHead(cwd2, tagSha) {
   try {
-    (0, import_child_process3.execFileSync)("git", ["merge-base", "--is-ancestor", tagSha, "HEAD"], {
+    (0, import_child_process4.execFileSync)("git", ["merge-base", "--is-ancestor", tagSha, "HEAD"], {
       cwd: cwd2,
       stdio: "pipe"
     });
@@ -38472,7 +39402,7 @@ function isTagMergedIntoHead(cwd2, tagSha) {
     return false;
   }
   try {
-    const trees = (0, import_child_process3.execFileSync)("git", ["log", "HEAD", "--format=%T", "--max-count=500"], {
+    const trees = (0, import_child_process4.execFileSync)("git", ["log", "HEAD", "--format=%T", "--max-count=500"], {
       cwd: cwd2,
       encoding: "utf-8",
       stdio: "pipe"
@@ -38484,7 +39414,7 @@ function isTagMergedIntoHead(cwd2, tagSha) {
 }
 function gitRevParse(cwd2, rev) {
   try {
-    return (0, import_child_process3.execFileSync)("git", ["rev-parse", "--verify", rev], {
+    return (0, import_child_process4.execFileSync)("git", ["rev-parse", "--verify", rev], {
       cwd: cwd2,
       encoding: "utf-8",
       stdio: "pipe"
@@ -38495,7 +39425,7 @@ function gitRevParse(cwd2, rev) {
 }
 function gitDiffNameOnly(cwd2, from, to) {
   try {
-    const output = (0, import_child_process3.execFileSync)("git", ["diff", "--name-only", from, to], {
+    const output = (0, import_child_process4.execFileSync)("git", ["diff", "--name-only", from, to], {
       cwd: cwd2,
       encoding: "utf-8",
       stdio: "pipe"
@@ -38513,29 +39443,29 @@ function replayStatus(params) {
 }
 
 // src/configuration/loadGitHubConfig.ts
-var import_promises5 = require("fs/promises");
+var import_promises9 = require("fs/promises");
 async function loadGitHubConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises5.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises9.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
 // src/configuration/loadReadmeConfig.ts
-var import_promises6 = require("fs/promises");
+var import_promises10 = require("fs/promises");
 async function loadReadmeConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises6.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises10.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
 // src/configuration/loadReferenceConfig.ts
-var import_promises7 = require("fs/promises");
+var import_promises11 = require("fs/promises");
 async function loadReferenceConfig({
   absolutePathToConfig
 }) {
-  const rawContents = await (0, import_promises7.readFile)(absolutePathToConfig, "utf8");
+  const rawContents = await (0, import_promises11.readFile)(absolutePathToConfig, "utf8");
   return JSON.parse(rawContents);
 }
 
@@ -38552,7 +39482,7 @@ var consolePipelineLogger = {
 };
 
 // src/pipeline/PostGenerationPipeline.ts
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 
 // src/pipeline/github/constants.ts
 var FERN_BOT_NAME2 = "fern-api";
@@ -38560,10 +39490,10 @@ var FERN_BOT_EMAIL2 = "115122769+fern-api[bot]@users.noreply.github.com";
 var FERN_BOT_LOGIN2 = "fern-api[bot]";
 
 // src/pipeline/steps/AutoVersionStep.ts
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 var import_fs14 = require("fs");
-var import_promises9 = require("fs/promises");
-var import_path16 = 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);
@@ -38622,8 +39552,8 @@ async function loggingExeca(logger, executable, args = [], { doNotPipeOutput = f
 
 // src/autoversion/AutoVersioningService.ts
 var import_fs13 = require("fs");
-var import_promises8 = require("fs/promises");
-var import_path15 = require("path");
+var import_promises12 = require("fs/promises");
+var import_path18 = require("path");
 var import_semver = __toESM(require_semver2());
 var AutoVersioningException = class extends Error {
   /**
@@ -39310,7 +40240,7 @@ var AutoVersioningService = class _AutoVersioningService {
       );
       return;
     }
-    const goModPath = (0, import_path15.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;
@@ -39344,7 +40274,7 @@ var AutoVersioningService = class _AutoVersioningService {
    * Reads the module path from a go.mod file.
    */
   async readGoModulePath(goModPath) {
-    const content = await (0, import_promises8.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 ")) {
@@ -39357,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_promises8.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++) {
@@ -39369,7 +40299,7 @@ var AutoVersioningService = class _AutoVersioningService {
       }
     }
     if (changed) {
-      await (0, import_promises8.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`);
     }
   }
@@ -39378,10 +40308,10 @@ var AutoVersioningService = class _AutoVersioningService {
    */
   async walkDirectory(dir, filter2) {
     const results = [];
-    const entries2 = await (0, import_promises8.readdir)(dir);
+    const entries2 = await (0, import_promises12.readdir)(dir);
     for (const entry of entries2) {
-      const fullPath = (0, import_path15.join)(dir, entry);
-      const entryStat = await (0, import_promises8.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;
@@ -39398,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_path15.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);
     }
@@ -39408,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_promises8.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;
@@ -39437,7 +40367,7 @@ var AutoVersioningService = class _AutoVersioningService {
       }
     }
     if (changed) {
-      await (0, import_promises8.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}`);
     }
   }
@@ -39800,7 +40730,7 @@ var AutoVersionStep = class extends BaseStep {
   }
   async readVersionFromMetadata() {
     try {
-      const output = (0, import_child_process4.execFileSync)("git", ["show", "HEAD~1:.fern/metadata.json"], {
+      const output = (0, import_child_process5.execFileSync)("git", ["show", "HEAD~1:.fern/metadata.json"], {
         cwd: this.outputDir,
         encoding: "utf-8",
         stdio: "pipe"
@@ -39816,7 +40746,7 @@ var AutoVersionStep = class extends BaseStep {
     return mappedMagicVersion.startsWith("v") ? `v${stripped}` : stripped;
   }
   gitDiff(from, to) {
-    return (0, import_child_process4.execFileSync)("git", ["diff", from, to, "--", ".", ":(exclude).fern/metadata.json"], {
+    return (0, import_child_process5.execFileSync)("git", ["diff", from, to, "--", ".", ":(exclude).fern/metadata.json"], {
       cwd: this.outputDir,
       encoding: "utf-8",
       stdio: "pipe",
@@ -39829,12 +40759,12 @@ var AutoVersionStep = class extends BaseStep {
     const fullMessage = body.length > 0 ? `${COMMIT_MARKER} ${subject}
 
 ${body}` : `${COMMIT_MARKER} ${subject}`;
-    (0, import_child_process4.execFileSync)("git", ["add", "-A"], { cwd: this.outputDir, stdio: "pipe" });
-    (0, import_child_process4.execFileSync)("git", ["commit", "--allow-empty", "-m", fullMessage], {
+    (0, import_child_process5.execFileSync)("git", ["add", "-A"], { cwd: this.outputDir, stdio: "pipe" });
+    (0, import_child_process5.execFileSync)("git", ["commit", "--allow-empty", "-m", fullMessage], {
       cwd: this.outputDir,
       stdio: "pipe"
     });
-    return (0, import_child_process4.execFileSync)("git", ["rev-parse", "HEAD"], {
+    return (0, import_child_process5.execFileSync)("git", ["rev-parse", "HEAD"], {
       cwd: this.outputDir,
       encoding: "utf-8",
       stdio: "pipe"
@@ -39842,7 +40772,7 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
   }
   async prependChangelogEntry(params) {
     const { version: version2, entry } = params;
-    const changelogPath = (0, import_path16.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}
 `;
@@ -39851,7 +40781,7 @@ ${body}` : `${COMMIT_MARKER} ${subject}`;
 `;
     let existing = "";
     if ((0, import_fs14.existsSync)(changelogPath)) {
-      existing = await (0, import_promises9.readFile)(changelogPath, "utf-8");
+      existing = await (0, import_promises13.readFile)(changelogPath, "utf-8");
     }
     let output;
     if (existing.trim().length === 0) {
@@ -39868,7 +40798,7 @@ ${newBlock}${remainder}`;
     } else {
       output = `${newBlock}${existing}`;
     }
-    await (0, import_promises9.writeFile)(changelogPath, output, "utf-8");
+    await (0, import_promises13.writeFile)(changelogPath, output, "utf-8");
   }
   brandMessage(message) {
     if (this.config.isWhitelabel) {
@@ -40050,8 +40980,8 @@ var GenerationCommitStep = class extends BaseStep {
 };
 
 // src/pipeline/steps/GithubStep.ts
-var import_promises10 = require("fs/promises");
-var import_path17 = 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) {
@@ -40668,13 +41598,13 @@ var GithubStep = class extends BaseStep {
   }
   async ensureFernignore() {
     this.logger.debug("Checking for .fernignore file...");
-    const fernignorePath = (0, import_path17.join)(this.outputDir, ".fernignore");
+    const fernignorePath = (0, import_path20.join)(this.outputDir, ".fernignore");
     try {
-      await (0, import_promises10.access)(fernignorePath);
+      await (0, import_promises14.access)(fernignorePath);
       this.logger.debug(".fernignore already exists");
     } catch {
       this.logger.debug("Creating .fernignore file...");
-      await (0, import_promises10.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) {
@@ -40896,8 +41826,8 @@ var PostGenerationPipeline = class {
   async run() {
     if (this.config.github?.enabled) {
       try {
-        (0, import_child_process5.execFileSync)("git", ["config", "user.name", FERN_BOT_NAME2], { cwd: this.config.outputDir });
-        (0, import_child_process5.execFileSync)("git", ["config", "user.email", FERN_BOT_EMAIL2], { cwd: this.config.outputDir });
+        (0, import_child_process6.execFileSync)("git", ["config", "user.name", FERN_BOT_NAME2], { cwd: this.config.outputDir });
+        (0, import_child_process6.execFileSync)("git", ["config", "user.email", FERN_BOT_EMAIL2], { cwd: this.config.outputDir });
       } catch {
       }
     }
@@ -40967,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_promises11.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,
@@ -41095,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_promises11.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);
@@ -41391,7 +42321,7 @@ async function createWriteStream(outputPath) {
 }
 async function createWriteStreamFromFile(filepath) {
   if (!await doesPathExist(filepath)) {
-    await (0, import_promises11.mkdir)(import_path18.default.dirname(filepath), { recursive: true });
+    await (0, import_promises15.mkdir)(import_path21.default.dirname(filepath), { recursive: true });
   }
   return import_fs15.default.createWriteStream(filepath);
 }