@fern-api/replay 0.9.1 → 0.10.1

package/dist/index.js

@@ -415,6 +415,12 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from "
 import { join, dirname } from "path";
 import { stringify, parse } from "yaml";
 var LOCKFILE_HEADER = "# DO NOT EDIT MANUALLY - Managed by Fern Replay\n";
+var LockfileNotFoundError = class extends Error {
+  constructor(path) {
+    super(`Lockfile not found: ${path}`);
+    this.name = "LockfileNotFoundError";
+  }
+};
 var LockfileManager = class {
   outputDir;
   lock = null;
@@ -434,12 +440,16 @@ var LockfileManager = class {
     if (this.lock) {
       return this.lock;
     }
-    if (!this.exists()) {
-      throw new Error(`Lockfile not found: ${this.lockfilePath}`);
+    try {
+      const content = readFileSync(this.lockfilePath, "utf-8");
+      this.lock = parse(content);
+      return this.lock;
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        throw new LockfileNotFoundError(this.lockfilePath);
+      }
+      throw error;
     }
-    const content = readFileSync(this.lockfilePath, "utf-8");
-    this.lock = parse(content);
-    return this.lock;
   }
   initialize(firstGeneration) {
     this.initializeInMemory(firstGeneration);
@@ -585,13 +595,21 @@ var ReplayDetector = class {
     const exists = await this.git.commitExists(lastGen.commit_sha);
     if (!exists) {
       this.warnings.push(
-        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Skipping new patch detection. Existing lockfile patches will still be applied.`
+        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
+      );
+      return this.detectPatchesViaTreeDiff(
+        lastGen,
+        /* commitKnownMissing */
+        true
       );
-      return { patches: [], revertedPatchIds: [] };
     }
     const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
     if (!isAncestor) {
-      return this.detectPatchesViaTreeDiff(lastGen);
+      return this.detectPatchesViaTreeDiff(
+        lastGen,
+        /* commitKnownMissing */
+        false
+      );
     }
     const log = await this.git.exec([
       "log",
@@ -617,7 +635,15 @@ var ReplayDetector = class {
       if (lock.patches.find((p) => p.original_commit === commit.sha)) {
         continue;
       }
-      const patchContent = await this.git.formatPatch(commit.sha);
+      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;
+      }
       const contentHash = this.computeContentHash(patchContent);
       if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
         continue;
@@ -710,11 +736,15 @@ var ReplayDetector = class {
    * 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) {
-    const filesOutput = await this.git.exec(["diff", "--name-only", lastGen.commit_sha, "HEAD"]);
+  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 files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
     if (files.length === 0) return { patches: [], revertedPatchIds: [] };
-    const diff = await this.git.exec(["diff", lastGen.commit_sha, "HEAD", "--", ...files]);
+    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();
@@ -728,12 +758,113 @@ var ReplayDetector = class {
       original_commit: headSha,
       original_message: "Customer customizations (composite)",
       original_author: "composite",
-      base_generation: lastGen.commit_sha,
+      // 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
     };
     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;
+      }
+      const 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 files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f));
+      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");
@@ -746,7 +877,7 @@ var ReplayDetector = class {
 };
 
 // src/ThreeWayMerge.ts
-import { diff3Merge } from "node-diff3";
+import { diff3Merge, diffPatch } from "node-diff3";
 function threeWayMerge(base, ours, theirs) {
   const baseLines = base.split("\n");
   const oursLines = ours.split("\n");
@@ -760,20 +891,33 @@ function threeWayMerge(base, ours, theirs) {
       outputLines.push(...region.ok);
       currentLine += region.ok.length;
     } else if (region.conflict) {
-      const startLine = currentLine;
-      outputLines.push("<<<<<<< Generated");
-      outputLines.push(...region.conflict.a);
-      outputLines.push("=======");
-      outputLines.push(...region.conflict.b);
-      outputLines.push(">>>>>>> Your customization");
-      const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
-      conflicts.push({
-        startLine,
-        endLine: startLine + conflictLines - 1,
-        ours: region.conflict.a,
-        theirs: region.conflict.b
-      });
-      currentLine += conflictLines;
+      const resolved = tryResolveConflict(
+        region.conflict.a,
+        // ours (generator)
+        region.conflict.o,
+        // base
+        region.conflict.b
+        // theirs (user)
+      );
+      if (resolved !== null) {
+        outputLines.push(...resolved);
+        currentLine += resolved.length;
+      } else {
+        const startLine = currentLine;
+        outputLines.push("<<<<<<< Generated");
+        outputLines.push(...region.conflict.a);
+        outputLines.push("=======");
+        outputLines.push(...region.conflict.b);
+        outputLines.push(">>>>>>> Your customization");
+        const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
+        conflicts.push({
+          startLine,
+          endLine: startLine + conflictLines - 1,
+          ours: region.conflict.a,
+          theirs: region.conflict.b
+        });
+        currentLine += conflictLines;
+      }
     }
   }
   return {
@@ -782,6 +926,62 @@ function threeWayMerge(base, ours, theirs) {
     conflicts
   };
 }
+function tryResolveConflict(oursLines, baseLines, theirsLines) {
+  if (baseLines.length === 0) {
+    return null;
+  }
+  const oursPatches = diffPatch(baseLines, oursLines);
+  const theirsPatches = diffPatch(baseLines, theirsLines);
+  if (oursPatches.length === 0) return theirsLines;
+  if (theirsPatches.length === 0) return oursLines;
+  if (patchesOverlap(oursPatches, theirsPatches)) {
+    return null;
+  }
+  return applyBothPatches(baseLines, oursPatches, theirsPatches);
+}
+function patchesOverlap(oursPatches, theirsPatches) {
+  for (const op of oursPatches) {
+    const oStart = op.buffer1.offset;
+    const oEnd = oStart + op.buffer1.length;
+    for (const tp of theirsPatches) {
+      const tStart = tp.buffer1.offset;
+      const tEnd = tStart + tp.buffer1.length;
+      if (op.buffer1.length === 0 && tp.buffer1.length === 0 && oStart === tStart) {
+        return true;
+      }
+      if (tp.buffer1.length === 0 && tStart === oEnd) {
+        return true;
+      }
+      if (op.buffer1.length === 0 && oStart === tEnd) {
+        return true;
+      }
+      if (oStart < tEnd && tStart < oEnd) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function applyBothPatches(baseLines, oursPatches, theirsPatches) {
+  const allPatches = [
+    ...oursPatches.map((p) => ({
+      offset: p.buffer1.offset,
+      length: p.buffer1.length,
+      replacement: p.buffer2.chunk
+    })),
+    ...theirsPatches.map((p) => ({
+      offset: p.buffer1.offset,
+      length: p.buffer1.length,
+      replacement: p.buffer2.chunk
+    }))
+  ];
+  allPatches.sort((a, b) => b.offset - a.offset);
+  const result = [...baseLines];
+  for (const p of allPatches) {
+    result.splice(p.offset, p.length, ...p.replacement);
+  }
+  return result;
+}
 
 // src/ReplayApplicator.ts
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
@@ -790,29 +990,74 @@ import { dirname as dirname2, extname, join as join2 } from "path";
 import { minimatch } from "minimatch";
 
 // src/conflict-utils.ts
+var CONFLICT_OPENER = "<<<<<<< Generated";
+var CONFLICT_SEPARATOR = "=======";
+var CONFLICT_CLOSER = ">>>>>>> Your customization";
+function trimCR(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function findConflictRanges(lines) {
+  const ranges = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (trimCR(lines[i]) === CONFLICT_OPENER) {
+      let separatorIdx = -1;
+      let j = i + 1;
+      let found = false;
+      while (j < lines.length) {
+        const trimmed = trimCR(lines[j]);
+        if (trimmed === CONFLICT_OPENER) {
+          break;
+        }
+        if (separatorIdx === -1 && trimmed === CONFLICT_SEPARATOR) {
+          separatorIdx = j;
+        } else if (separatorIdx !== -1 && trimmed === CONFLICT_CLOSER) {
+          ranges.push({ start: i, separator: separatorIdx, end: j });
+          i = j;
+          found = true;
+          break;
+        }
+        j++;
+      }
+      if (!found) {
+        i++;
+        continue;
+      }
+    }
+    i++;
+  }
+  return ranges;
+}
 function stripConflictMarkers(content) {
-  const lines = content.split("\n");
+  const lines = content.split(/\r?\n/);
+  const ranges = findConflictRanges(lines);
+  if (ranges.length === 0) {
+    return content;
+  }
   const result = [];
-  let inConflict = false;
-  let inOurs = false;
-  for (const line of lines) {
-    if (line.startsWith("<<<<<<< ")) {
-      inConflict = true;
-      inOurs = true;
-      continue;
-    }
-    if (inConflict && line === "=======") {
-      inOurs = false;
-      continue;
-    }
-    if (inConflict && line.startsWith(">>>>>>> ")) {
-      inConflict = false;
-      inOurs = false;
-      continue;
-    }
-    if (!inConflict || inOurs) {
-      result.push(line);
+  let rangeIdx = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (rangeIdx < ranges.length) {
+      const range = ranges[rangeIdx];
+      if (i === range.start) {
+        continue;
+      }
+      if (i > range.start && i < range.separator) {
+        result.push(lines[i]);
+        continue;
+      }
+      if (i === range.separator) {
+        continue;
+      }
+      if (i > range.separator && i < range.end) {
+        continue;
+      }
+      if (i === range.end) {
+        rangeIdx++;
+        continue;
+      }
     }
+    result.push(lines[i]);
   }
   return result.join("\n");
 }
@@ -879,6 +1124,27 @@ var ReplayApplicator = class {
     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();
@@ -960,7 +1226,7 @@ var ReplayApplicator = class {
     }
   }
   async applyPatchWithFallback(patch) {
-    const baseGen = this.lockManager.getGeneration(patch.base_generation);
+    const baseGen = await this.resolveBaseGeneration(patch.base_generation);
     const lock = this.lockManager.read();
     const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
     const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
@@ -1044,7 +1310,7 @@ var ReplayApplicator = class {
   }
   async mergeFile(patch, filePath, tempGit, tempDir) {
     try {
-      const baseGen = this.lockManager.getGeneration(patch.base_generation);
+      const baseGen = await this.resolveBaseGeneration(patch.base_generation);
       if (!baseGen) {
         return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
       }
@@ -1096,9 +1362,20 @@ var ReplayApplicator = class {
           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"
+          };
+        }
+      }
       let useAccumulatorAsMergeBase = false;
       const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-      if (!theirs && accumulatorEntry) {
+      if (accumulatorEntry && (!theirs || base == null)) {
         theirs = await this.applyPatchToContent(
           accumulatorEntry.content,
           patch.patch_content,
@@ -1110,6 +1387,17 @@ var ReplayApplicator = class {
           useAccumulatorAsMergeBase = true;
         }
       }
+      if (theirs) {
+        const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
+        const accBaseHasMarkers = accumulatorEntry != null && (accumulatorEntry.content.includes("<<<<<<< Generated") || accumulatorEntry.content.includes(">>>>>>> Your customization"));
+        if (theirsHasMarkers && !accBaseHasMarkers && !(base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization")))) {
+          return {
+            file: resolvedPath,
+            status: "skipped",
+            reason: "stale-conflict-markers"
+          };
+        }
+      }
       let effective_theirs = theirs;
       let baseMismatchSkipped = false;
       if (theirs && base && !useAccumulatorAsMergeBase) {
@@ -1129,12 +1417,16 @@ var ReplayApplicator = class {
         }
       }
       if (base == null && !ours && effective_theirs) {
+        this.fileTheirsAccumulator.set(resolvedPath, {
+          content: effective_theirs,
+          baseGeneration: patch.base_generation
+        });
         const outDir2 = dirname2(oursPath);
         await mkdir(outDir2, { recursive: true });
         await writeFile(oursPath, effective_theirs);
         return { file: resolvedPath, status: "merged", reason: "new-file" };
       }
-      if (base == null && ours && effective_theirs) {
+      if (base == null && ours && effective_theirs && !useAccumulatorAsMergeBase) {
         const merged2 = threeWayMerge("", ours, effective_theirs);
         const outDir2 = dirname2(oursPath);
         await mkdir(outDir2, { recursive: true });
@@ -1176,7 +1468,7 @@ var ReplayApplicator = class {
       const outDir = dirname2(oursPath);
       await mkdir(outDir, { recursive: true });
       await writeFile(oursPath, merged.content);
-      if (effective_theirs) {
+      if (effective_theirs && !merged.hasConflicts) {
         this.fileTheirsAccumulator.set(resolvedPath, {
           content: effective_theirs,
           baseGeneration: patch.base_generation
@@ -1317,16 +1609,24 @@ var ReplayApplicator = class {
     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;
       }
@@ -1478,6 +1778,7 @@ var ReplayService = class {
       generator_versions: options?.generatorVersions ?? {},
       base_branch_head: options?.baseBranchHead
     };
+    let resolvedPatches;
     if (!this.lockManager.exists()) {
       this.lockManager.initializeInMemory(record);
     } else {
@@ -1486,13 +1787,13 @@ var ReplayService = class {
         ...this.lockManager.getUnresolvedPatches(),
         ...this.lockManager.getResolvingPatches()
       ];
+      resolvedPatches = this.lockManager.getPatches().filter((p) => p.status == null);
       this.lockManager.addGeneration(record);
       this.lockManager.clearPatches();
       for (const patch of unresolvedPatches) {
         this.lockManager.addPatch(patch);
       }
     }
-    this.lockManager.save();
     try {
       const { patches: redetectedPatches } = await this.detector.detectNewPatches();
       if (redetectedPatches.length > 0) {
@@ -1506,20 +1807,27 @@ var ReplayService = class {
         for (const patch of redetectedPatches) {
           this.lockManager.addPatch(patch);
         }
-        this.lockManager.save();
       }
-    } catch {
+    } catch (error) {
+      for (const patch of resolvedPatches ?? []) {
+        this.lockManager.addPatch(patch);
+      }
+      this.detector.warnings.push(
+        `Patch re-detection failed after divergent merge sync. ${(resolvedPatches ?? []).length} previously resolved patch(es) preserved. Error: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
+    this.lockManager.save();
   }
   determineFlow() {
-    if (!this.lockManager.exists()) {
-      return "first-generation";
-    }
-    const lock = this.lockManager.read();
-    if (lock.patches.length === 0) {
-      return "no-patches";
+    try {
+      const lock = this.lockManager.read();
+      return lock.patches.length === 0 ? "no-patches" : "normal-regeneration";
+    } catch (error) {
+      if (error instanceof LockfileNotFoundError) {
+        return "first-generation";
+      }
+      throw error;
     }
-    return "normal-regeneration";
   }
   async handleFirstGeneration(options) {
     if (options?.dryRun) {
@@ -1561,12 +1869,17 @@ var ReplayService = class {
       baseBranchHead: options.baseBranchHead
     } : void 0;
     await this.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
+    await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
-    if (this.lockManager.exists()) {
+    try {
       this.lockManager.read();
       this.lockManager.addGeneration(genRecord);
-    } else {
-      this.lockManager.initializeInMemory(genRecord);
+    } catch (error) {
+      if (error instanceof LockfileNotFoundError) {
+        this.lockManager.initializeInMemory(genRecord);
+      } else {
+        throw error;
+      }
     }
     this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
     this.lockManager.save();
@@ -1612,6 +1925,7 @@ var ReplayService = class {
       baseBranchHead: options.baseBranchHead
     } : void 0;
     await this.committer.commitGeneration("Update SDK", commitOpts);
+    await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
     this.lockManager.addGeneration(genRecord);
     let results = [];
@@ -1705,6 +2019,7 @@ var ReplayService = class {
       baseBranchHead: options.baseBranchHead
     } : void 0;
     await this.committer.commitGeneration("Update SDK", commitOpts);
+    await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
     this.lockManager.addGeneration(genRecord);
     const results = await this.applicator.applyPatches(allPatches);
@@ -1895,6 +2210,13 @@ var ReplayService = class {
             contentRefreshed++;
             continue;
           }
+          const diffLines = diff.split("\n");
+          const hasStaleMarkers = diffLines.some(
+            (l) => l.startsWith("+<<<<<<< Generated") || l.startsWith("+>>>>>>> Your customization")
+          );
+          if (hasStaleMarkers) {
+            continue;
+          }
           const newContentHash = this.detector.computeContentHash(diff);
           if (newContentHash !== patch.content_hash) {
             const filesOutput = await this.git.exec(["diff", "--name-only", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
@@ -1915,7 +2237,7 @@ var ReplayService = class {
         continue;
       }
       try {
-        const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<<", "HEAD", "--", ...patch.files]).catch(() => "");
+        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;
@@ -1955,6 +2277,25 @@ var ReplayService = class {
       }
     }
   }
+  /**
+   * Clean up stale conflict markers left by a previous crashed run.
+   * Called after commitGeneration() when HEAD is the [fern-generated] commit.
+   * Restores files to their clean generated state from HEAD.
+   * Skips .fernignore-protected files to prevent overwriting user content.
+   */
+  async cleanupStaleConflictMarkers() {
+    const markerFiles = await this.git.exec(["grep", "-l", "<<<<<<< Generated", "--", "."]).catch(() => "");
+    const files = markerFiles.trim().split("\n").filter(Boolean);
+    if (files.length === 0) return;
+    const fernignorePatterns = this.readFernignorePatterns();
+    for (const file of files) {
+      if (fernignorePatterns.some((pattern) => minimatch2(file, pattern))) continue;
+      try {
+        await this.git.exec(["checkout", "HEAD", "--", file]);
+      } catch {
+      }
+    }
+  }
   readFernignorePatterns() {
     const fernignorePath = join3(this.outputDir, ".fernignore");
     if (!existsSync2(fernignorePath)) return [];
@@ -2729,6 +3070,7 @@ export {
   FernignoreMigrator,
   GitClient,
   LockfileManager,
+  LockfileNotFoundError,
   ReplayApplicator,
   ReplayCommitter,
   ReplayDetector,