@fern-api/replay 0.15.0 → 0.15.1

package/dist/index.js

@@ -400,26 +400,26 @@ var PatchApplyTheirs_exports = {};
 __export(PatchApplyTheirs_exports, {
   applyPatchToContent: () => applyPatchToContent
 });
-import { mkdtemp as mkdtemp3, mkdir as mkdir2, writeFile as writeFile3, readFile as readFile2, rm as rm3 } from "fs/promises";
+import { mkdtemp as mkdtemp3, mkdir as mkdir3, writeFile as writeFile4, readFile as readFile3, rm as rm3 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname4, join as join5 } from "path";
 async function applyPatchToContent(base, patchContent, filePath) {
   const fileDiff = extractFileDiff(patchContent, filePath);
   if (!fileDiff) return null;
-  const tempDir = await mkdtemp3(join4(tmpdir3(), "replay-migrate-"));
+  const tempDir = await mkdtemp3(join5(tmpdir3(), "replay-migrate-"));
   const tempGit = new GitClient(tempDir);
   try {
     await tempGit.exec(["init"]);
     await tempGit.exec(["config", "user.email", "migrate@fern.com"]);
     await tempGit.exec(["config", "user.name", "Fern Replay Migration"]);
     await tempGit.exec(["config", "commit.gpgSign", "false"]);
-    const tempFilePath = join4(tempDir, filePath);
-    await mkdir2(dirname3(tempFilePath), { recursive: true });
-    await writeFile3(tempFilePath, base);
+    const tempFilePath = join5(tempDir, filePath);
+    await mkdir3(dirname4(tempFilePath), { recursive: true });
+    await writeFile4(tempFilePath, base);
     await tempGit.exec(["add", filePath]);
     await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
     await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-    return await readFile2(tempFilePath, "utf-8");
+    return await readFile3(tempFilePath, "utf-8");
   } catch {
     return null;
   } finally {
@@ -715,225 +715,8 @@ var LockfileManager = class {
 // src/ReplayDetector.ts
 import { createHash } from "crypto";
 
-// src/ReplayApplicator.ts
-import { mkdir, mkdtemp, readFile, rm, unlink, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { dirname as dirname2, extname, join as join2 } from "path";
-import { minimatch } from "minimatch";
-
-// src/conflict-utils.ts
-var CONFLICT_OPENER = "<<<<<<< Generated";
-var CONFLICT_SEPARATOR = "=======";
-var CONFLICT_CLOSER = ">>>>>>> Your customization";
-function trimCR(line) {
-  return line.endsWith("\r") ? line.slice(0, -1) : line;
-}
-function findConflictRanges(lines) {
-  const ranges = [];
-  let i = 0;
-  while (i < lines.length) {
-    if (trimCR(lines[i]) === CONFLICT_OPENER) {
-      let separatorIdx = -1;
-      let j = i + 1;
-      let found = false;
-      while (j < lines.length) {
-        const trimmed = trimCR(lines[j]);
-        if (trimmed === CONFLICT_OPENER) {
-          break;
-        }
-        if (separatorIdx === -1 && trimmed === CONFLICT_SEPARATOR) {
-          separatorIdx = j;
-        } else if (separatorIdx !== -1 && trimmed === CONFLICT_CLOSER) {
-          ranges.push({ start: i, separator: separatorIdx, end: j });
-          i = j;
-          found = true;
-          break;
-        }
-        j++;
-      }
-      if (!found) {
-        i++;
-        continue;
-      }
-    }
-    i++;
-  }
-  return ranges;
-}
-function stripConflictMarkers(content) {
-  const lines = content.split(/\r?\n/);
-  const ranges = findConflictRanges(lines);
-  if (ranges.length === 0) {
-    return content;
-  }
-  const result = [];
-  let rangeIdx = 0;
-  for (let i = 0; i < lines.length; i++) {
-    if (rangeIdx < ranges.length) {
-      const 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");
-}
-
-// src/ThreeWayMerge.ts
-import { diff3Merge, diffPatch } from "node-diff3";
-function threeWayMerge(base, ours, theirs) {
-  const baseLines = base.split("\n");
-  const oursLines = ours.split("\n");
-  const theirsLines = theirs.split("\n");
-  const regions = diff3Merge(oursLines, baseLines, theirsLines);
-  const outputLines = [];
-  const conflicts = [];
-  let currentLine = 1;
-  for (const region of regions) {
-    if (region.ok) {
-      outputLines.push(...region.ok);
-      currentLine += region.ok.length;
-    } else if (region.conflict) {
-      const resolved = tryResolveConflict(
-        region.conflict.a,
-        // ours (generator)
-        region.conflict.o,
-        // base
-        region.conflict.b
-        // theirs (user)
-      );
-      if (resolved !== null) {
-        outputLines.push(...resolved);
-        currentLine += resolved.length;
-      } else {
-        const startLine = currentLine;
-        outputLines.push("<<<<<<< Generated");
-        outputLines.push(...region.conflict.a);
-        outputLines.push("=======");
-        outputLines.push(...region.conflict.b);
-        outputLines.push(">>>>>>> Your customization");
-        const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
-        conflicts.push({
-          startLine,
-          endLine: startLine + conflictLines - 1,
-          ours: region.conflict.a,
-          theirs: region.conflict.b
-        });
-        currentLine += conflictLines;
-      }
-    }
-  }
-  const result = {
-    content: outputLines.join("\n"),
-    hasConflicts: conflicts.length > 0,
-    conflicts
-  };
-  if (conflicts.length === 0) {
-    const dropped = computeDroppedContextLines(baseLines, theirsLines, outputLines);
-    if (dropped.length > 0) {
-      result.droppedContextLines = dropped;
-    }
-  }
-  return result;
-}
-function computeDroppedContextLines(baseLines, theirsLines, mergedLines) {
-  const baseCounts = countLines(baseLines);
-  const theirsCounts = countLines(theirsLines);
-  const mergedCounts = countLines(mergedLines);
-  const dropped = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const line of baseLines) {
-    if (seen.has(line)) continue;
-    const inBase = baseCounts.get(line) ?? 0;
-    const inTheirs = theirsCounts.get(line) ?? 0;
-    const inMerged = mergedCounts.get(line) ?? 0;
-    if (inBase > 0 && inTheirs > 0 && inMerged < Math.min(inBase, inTheirs)) {
-      dropped.push(line);
-      seen.add(line);
-    }
-  }
-  return dropped;
-}
-function countLines(lines) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    counts.set(line, (counts.get(line) ?? 0) + 1);
-  }
-  return counts;
-}
-function tryResolveConflict(oursLines, baseLines, theirsLines) {
-  if (baseLines.length === 0) {
-    return null;
-  }
-  const oursPatches = diffPatch(baseLines, oursLines);
-  const theirsPatches = diffPatch(baseLines, theirsLines);
-  if (oursPatches.length === 0) return theirsLines;
-  if (theirsPatches.length === 0) return oursLines;
-  if (patchesOverlap(oursPatches, theirsPatches)) {
-    return null;
-  }
-  return applyBothPatches(baseLines, oursPatches, theirsPatches);
-}
-function patchesOverlap(oursPatches, theirsPatches) {
-  for (const op of oursPatches) {
-    const oStart = op.buffer1.offset;
-    const oEnd = oStart + op.buffer1.length;
-    for (const tp of theirsPatches) {
-      const tStart = tp.buffer1.offset;
-      const tEnd = tStart + tp.buffer1.length;
-      if (op.buffer1.length === 0 && tp.buffer1.length === 0 && oStart === tStart) {
-        return true;
-      }
-      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
+// src/shared/binary.ts
+import { extname } from "path";
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
@@ -983,1324 +766,1672 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".pyo",
   ".DS_Store"
 ]);
-var ReplayApplicator = class {
-  git;
-  lockManager;
-  outputDir;
-  renameCache = /* @__PURE__ */ new Map();
-  treeExistsCache = /* @__PURE__ */ new Map();
-  fileTheirsAccumulator = /* @__PURE__ */ new Map();
-  /**
-   * Apply mode for the current `applyPatches` invocation. Set at the start
-   * of `applyPatches`, read by `mergeFile` to decide:
-   *   - whether to skip the intra-loop marker strip (kept in `applyPatches`)
-   *   - whether to populate the accumulator after a conflicted merge
-   *     (resolve mode populates so subsequent patches on the same file
-   *     can use patch A's THEIRS as a structurally-correct merge base
-   *     when their diff was authored against post-A structure)
-   *   - whether to retry THEIRS reconstruction against the accumulator
-   *     when the BASE-relative reconstruction produced markers from a
-   *     cross-patch context mismatch
-   */
-  currentApplyMode = "replay";
-  /**
-   * Set of files that appear in 2+ patches in the current `applyPatches`
-   * invocation. Computed at the top of `applyPatches`. Read by `mergeFile`
-   * and `populateAccumulatorForPatch` to decide whether to use the patch's
-   * `theirs_snapshot` directly as THEIRS (snapshot-as-primary) or fall
-   * back to line-anchored reconstruction (FER-9525 cross-patch isolation).
-   *
-   * Snapshot-as-primary is correct when the patch owns its file (no other
-   * patch in this run touches it): the snapshot is what the customer
-   * intends for that file post-regen, regardless of generator structural
-   * changes that would invalidate the diff's line anchors.
-   *
-   * When a file IS shared, snapshots are CUMULATIVE across the patches
-   * touching it (each one's snapshot includes prior patches' contributions).
-   * Using a later patch's cumulative snapshot as its individual THEIRS
-   * would propagate prior patches' edits into the merge — surfacing nested
-   * conflicts at regions the patch alone never touched. Reconstruction
-   * via `applyPatchToContent` is required there.
-   */
-  sharedFiles = /* @__PURE__ */ new Set();
-  constructor(git, lockManager, outputDir) {
-    this.git = git;
-    this.lockManager = lockManager;
-    this.outputDir = outputDir;
-  }
-  /**
-   * 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();
-  }
+function isBinaryFile(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+
+// src/ReplayDetector.ts
+var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
+function parsePatchFileHeaders(patchContent) {
+  const results = [];
+  let currentPath = null;
+  let currentIsCreate = false;
+  let currentIsDelete = false;
+  const flush = () => {
+    if (currentPath !== null) {
+      results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
+    }
+  };
+  for (const line of patchContent.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      currentPath = null;
+      currentIsCreate = false;
+      currentIsDelete = false;
+      const match = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+      if (match) {
+        currentPath = match[2] ?? null;
+      }
+    } else if (currentPath !== null) {
+      if (line.startsWith("new file mode ")) {
+        currentIsCreate = true;
+      } else if (line.startsWith("deleted file mode ")) {
+        currentIsDelete = true;
+      }
+    }
+  }
+  flush();
+  return results;
+}
+async function capturePatchSnapshot(git, files, treeish) {
+  const snapshot = {};
+  for (const file of files) {
+    if (isBinaryFile(file)) continue;
+    const content = await git.showFile(treeish, file).catch(() => null);
+    if (content != null) snapshot[file] = content;
+  }
+  return snapshot;
+}
+function filterInfrastructureAndSensitiveFiles(rawFilesOutput) {
+  const allFiles = rawFilesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+  const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
+  const files = allFiles.filter((f) => !isSensitiveFile(f));
+  return { files, sensitiveFiles };
+}
+var ReplayDetector = class {
+  git;
+  lockManager;
+  sdkOutputDir;
+  warnings = [];
+  constructor(git, lockManager, sdkOutputDir) {
+    this.git = git;
+    this.lockManager = lockManager;
+    this.sdkOutputDir = sdkOutputDir;
+  }
+  async detectNewPatches() {
+    const lock = this.lockManager.read();
+    const lastGen = this.getLastGeneration(lock);
+    if (!lastGen) {
+      return { patches: [], revertedPatchIds: [] };
+    }
+    const exists = await this.git.commitExists(lastGen.commit_sha);
+    if (!exists) {
+      this.warnings.push(
+        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
+      );
+      return this.detectPatchesViaTreeDiff(
+        lastGen,
+        /* commitKnownMissing */
+        true
+      );
+    }
+    const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
+    if (!isAncestor) {
+      return this.detectPatchesViaMergeBase(lastGen, lock);
+    }
+    return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
+  }
   /**
-   * @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.
+   * 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).
    */
-  getAccumulatorSnapshot() {
-    const snapshot = /* @__PURE__ */ new Map();
-    for (const [path, entry] of this.fileTheirsAccumulator) {
-      snapshot.set(path, { content: entry.content, baseGeneration: entry.baseGeneration });
+  async detectPatchesViaMergeBase(lastGen, lock) {
+    let mergeBase = "";
+    try {
+      mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
+    } catch {
     }
-    return snapshot;
+    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);
   }
   /**
-   * Apply all patches, returning results for each.
-   * Skips patches that match exclude patterns in replay.yml
+   * 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.
    *
-   * `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.
+   * 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 applyPatches(patches, opts) {
-    const applyMode = opts?.applyMode ?? "replay";
-    this.currentApplyMode = applyMode;
-    this.resetAccumulator();
-    const fileFreq = /* @__PURE__ */ new Map();
-    for (const p of patches) {
-      for (const f of p.files) {
-        fileFreq.set(f, (fileFreq.get(f) ?? 0) + 1);
-      }
+  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: [] };
     }
-    this.sharedFiles = new Set(
-      Array.from(fileFreq.entries()).filter(([, n]) => n > 1).map(([f]) => f)
-    );
-    const results = [];
-    for (let i = 0; i < patches.length; i++) {
-      const patch = patches[i];
-      if (this.isExcluded(patch)) {
-        results.push({
-          patch,
-          status: "skipped",
-          method: "git-am"
-        });
+    const commits = this.parseGitLog(log);
+    const newPatches = [];
+    const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+    for (const commit of commits) {
+      if (isGenerationCommit(commit)) {
         continue;
       }
-      const result = await this.applyPatchWithFallback(patch);
-      results.push(result);
-      if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
-        const laterFiles = /* @__PURE__ */ new Set();
-        for (let j = i + 1; j < patches.length; j++) {
-          for (const f of patches[j].files) {
-            laterFiles.add(f);
-          }
-        }
-        const resolvedToOriginal = /* @__PURE__ */ new Map();
-        if (result.resolvedFiles) {
-          for (const [orig, resolved] of Object.entries(result.resolvedFiles)) {
-            resolvedToOriginal.set(resolved, orig);
-          }
+      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);
         }
-        for (const fileResult of result.fileResults) {
-          if (fileResult.status !== "conflict") continue;
-          const originalPath = resolvedToOriginal.get(fileResult.file) ?? fileResult.file;
-          if (laterFiles.has(fileResult.file) || laterFiles.has(originalPath)) {
-            const filePath = join2(this.outputDir, fileResult.file);
+        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 { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+      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 {
-              const content = await readFile(filePath, "utf-8");
-              const stripped = stripConflictMarkers(content);
-              await writeFile(filePath, stripped);
+              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 = await capturePatchSnapshot(this.git, files, commit.sha);
+      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 } : {}
+      });
     }
-    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 mkdtemp(join2(tmpdir(), "replay-acc-"));
-    const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
-    const tempGit = new GitClient2(tempDir);
-    await tempGit.exec(["init"]);
-    await tempGit.exec(["config", "user.email", "replay@fern.com"]);
-    await tempGit.exec(["config", "user.name", "Fern Replay"]);
-    try {
-      for (const filePath of patch.files) {
-        if (isBinaryFile(filePath)) continue;
-        const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
-        const base = await this.git.showFile(baseGen.tree_hash, filePath);
-        const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
-        const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
-        const theirs = !fileIsShared && snapshotForFile != null ? snapshotForFile : await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
-        const finalOnDisk = await readFile(join2(this.outputDir, resolvedPath), "utf-8").catch(() => null);
-        const effectiveTheirs = theirs ?? finalOnDisk;
-        if (effectiveTheirs != null) {
-          this.fileTheirsAccumulator.set(resolvedPath, {
-            content: effectiveTheirs,
-            baseGeneration: patch.base_generation
-          });
+    const survivingPatches = await this.collapseNetZeroFiles(newPatches);
+    survivingPatches.reverse();
+    const revertedPatchIdSet = /* @__PURE__ */ new Set();
+    const revertIndicesToRemove = /* @__PURE__ */ new Set();
+    for (let i = 0; i < survivingPatches.length; i++) {
+      const patch = survivingPatches[i];
+      if (!isRevertCommit(patch.original_message)) continue;
+      let body = "";
+      try {
+        body = await this.git.getCommitBody(patch.original_commit);
+      } catch {
+      }
+      const revertedSha = parseRevertedSha(body);
+      const revertedMessage = parseRevertedMessage(patch.original_message);
+      let matchedExisting = false;
+      if (revertedSha) {
+        const existing = lock.patches.find((p) => p.original_commit === revertedSha);
+        if (existing) {
+          revertedPatchIdSet.add(existing.id);
+          revertIndicesToRemove.add(i);
+          matchedExisting = true;
         }
-        if (base != null && effectiveTheirs != null && finalOnDisk != null) {
-          const dropped = computeDroppedContextLinesForFile(base, effectiveTheirs, finalOnDisk);
-          if (dropped.length > 0) {
-            fileResults.push({
-              file: resolvedPath,
-              status: "merged",
-              droppedContextLines: dropped
-            });
-          }
+      }
+      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 rm(tempDir, { recursive: true }).catch(() => {
-      });
+      if (matchedExisting) continue;
+      let matchedNew = false;
+      if (revertedSha) {
+        const idx = survivingPatches.findIndex(
+          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_commit === revertedSha
+        );
+        if (idx !== -1) {
+          revertIndicesToRemove.add(i);
+          revertIndicesToRemove.add(idx);
+          matchedNew = true;
+        }
+      }
+      if (!matchedNew && revertedMessage) {
+        const idx = survivingPatches.findIndex(
+          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_message === revertedMessage
+        );
+        if (idx !== -1) {
+          revertIndicesToRemove.add(i);
+          revertIndicesToRemove.add(idx);
+        }
+      }
+      if (!matchedExisting && !matchedNew) {
+        revertIndicesToRemove.add(i);
+      }
     }
-    return fileResults;
+    const filteredPatches = survivingPatches.filter((_, i) => !revertIndicesToRemove.has(i));
+    return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
   }
-  async applyPatchWithFallback(patch) {
-    const baseGen = await this.resolveBaseGeneration(patch.base_generation);
-    const lock = this.lockManager.read();
-    const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
-    const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
-    const needsAccumulation = await Promise.all(
-      patch.files.map(async (f) => {
-        if (!baseGen) return false;
-        const resolved = await this.resolveFilePath(f, baseGen.tree_hash, currentTreeHash);
-        return this.fileTheirsAccumulator.has(resolved);
-      })
-    ).then((results) => results.some(Boolean));
-    const resolvedFiles = {};
-    for (const filePath of patch.files) {
-      const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
-      if (resolvedPath !== filePath) {
-        resolvedFiles[filePath] = resolvedPath;
+  /**
+   * 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.
+   */
+  computeContentHash(patchContent) {
+    const lines = patchContent.split("\n");
+    const diffStart = lines.findIndex((l) => l.startsWith("diff --git "));
+    const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
+    const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
+    return `sha256:${createHash("sha256").update(normalized).digest("hex")}`;
+  }
+  /**
+   * 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. Revisit if a future adversarial test
+   * demands per-file stripping.
+   */
+  async collapseNetZeroFiles(patches) {
+    if (patches.length === 0) return patches;
+    const stateByFile = /* @__PURE__ */ new Map();
+    for (const patch of patches) {
+      for (const header of parsePatchFileHeaders(patch.patch_content)) {
+        if (!header.isCreate && !header.isDelete) continue;
+        const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
+        if (header.isCreate) prior.created = true;
+        if (header.isDelete) prior.deleted = true;
+        stateByFile.set(header.path, prior);
       }
     }
-    const patchIsRenameAware = /^rename from /m.test(patch.patch_content);
-    const hasGeneratorRename = Object.keys(resolvedFiles).length > 0 && !patchIsRenameAware;
-    if (!needsAccumulation && !hasGeneratorRename) {
-      const snapshots = /* @__PURE__ */ new Map();
-      for (const filePath of patch.files) {
-        const fullPath = join2(this.outputDir, filePath);
-        snapshots.set(filePath, await readFile(fullPath, "utf-8").catch(() => null));
+    let anyCandidate = false;
+    for (const state of stateByFile.values()) {
+      if (state.created && state.deleted) {
+        anyCandidate = true;
+        break;
       }
-      try {
-        await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
-        const fastPathFileResults = await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
-        return {
-          patch,
-          status: "applied",
-          method: "git-am",
-          ...fastPathFileResults.length > 0 && { fileResults: fastPathFileResults },
-          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
-        };
-      } catch {
-        for (const [filePath, content] of snapshots) {
-          const fullPath = join2(this.outputDir, filePath);
-          if (content != null) {
-            await writeFile(fullPath, content);
-          } else {
-            await unlink(fullPath).catch(() => {
-            });
-          }
-        }
+    }
+    if (!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 this.applyWithThreeWayMerge(patch);
+    if (transient.size === 0) return patches;
+    return patches.filter((patch) => !patch.files.every((f) => transient.has(f)));
   }
-  async applyWithThreeWayMerge(patch) {
-    const fileResults = [];
-    const resolvedFiles = {};
-    const tempDir = await mkdtemp(join2(tmpdir(), "replay-"));
-    const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
-    const tempGit = new GitClient2(tempDir);
-    await tempGit.exec(["init"]);
-    await tempGit.exec(["config", "user.email", "replay@fern.com"]);
-    await tempGit.exec(["config", "user.name", "Fern Replay"]);
+  /**
+   * 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 {
-      for (const filePath of patch.files) {
-        if (isBinaryFile(filePath)) {
-          fileResults.push({
-            file: filePath,
-            status: "skipped",
-            reason: "binary-file"
-          });
-          continue;
-        }
-        const result = await this.mergeFile(patch, filePath, tempGit, tempDir);
-        if (result.file !== filePath) {
-          resolvedFiles[filePath] = result.file;
-        }
-        fileResults.push(result);
-      }
-    } finally {
-      await rm(tempDir, { recursive: true }).catch(() => {
-      });
+      const 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();
     }
-    const conflictFiles = fileResults.filter((r) => r.status === "conflict");
-    const hasConflicts = conflictFiles.length > 0;
-    const conflictReason = hasConflicts ? conflictFiles.some((f) => f.conflictReason === "base-generation-mismatch") ? "base-generation-mismatch" : conflictFiles[0]?.conflictReason : void 0;
+  }
+  /**
+   * 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 { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+    if (sensitiveFiles.length > 0) {
+      this.warnings.push(
+        `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
+      );
+    }
+    if (files.length === 0) return null;
+    const diff = await this.git.exec([
+      "diff",
+      firstParent,
+      mergeCommit.sha,
+      "--",
+      ...files
+    ]);
+    if (!diff.trim()) return null;
+    const contentHash = this.computeContentHash(diff);
+    if (lock.patches.some((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
+      return null;
+    }
+    const theirsSnapshot = await capturePatchSnapshot(this.git, files, mergeCommit.sha);
     return {
-      patch,
-      status: hasConflicts ? "conflict" : "applied",
-      method: "3way-merge",
-      fileResults,
-      conflictReason,
-      ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+      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 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" };
+  /**
+   * 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 lockForGuard = this.lockManager.read();
+    const knownGenerations = new Set(lockForGuard.generations.map((g) => g.commit_sha));
+    let resolvedBaseGeneration = commitKnownMissing ? diffBase : lastGen.commit_sha;
+    if (commitKnownMissing && !knownGenerations.has(diffBase)) {
+      const fallback = lockForGuard.current_generation ?? lockForGuard.generations[lockForGuard.generations.length - 1]?.commit_sha;
+      if (!fallback) {
+        this.warnings.push(
+          `Composite-patch fallback skipped: diff base ${diffBase.slice(0, 7)} is not a recorded generation and the lockfile has no recorded generations to anchor on. Customer customizations on disk are preserved; tracked patches will resume on the next regeneration.`
+        );
+        return { patches: [], revertedPatchIds: [] };
       }
-      const lock = this.lockManager.read();
-      const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
-      const currentTreeHash = currentGen?.tree_hash ?? baseGen.tree_hash;
-      const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
-      const metadata = {
-        patchId: patch.id,
-        patchMessage: patch.original_message,
-        baseGeneration: patch.base_generation,
-        currentGeneration: lock.current_generation
-      };
-      let base = await this.git.showFile(baseGen.tree_hash, filePath);
-      let renameSourcePath;
-      if (!base) {
-        const renameSource = this.extractRenameSource(patch.patch_content, filePath);
-        if (renameSource) {
-          base = await this.git.showFile(baseGen.tree_hash, renameSource);
-          renameSourcePath = renameSource;
-        }
+      resolvedBaseGeneration = fallback;
+    }
+    const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
+    const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+    if (sensitiveFiles.length > 0) {
+      this.warnings.push(
+        `Sensitive file(s) excluded from composite patch: ${sensitiveFiles.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 = await capturePatchSnapshot(this.git, files, "HEAD");
+    const compositePatch = {
+      id: `patch-composite-${headSha.slice(0, 8)}`,
+      content_hash: contentHash,
+      original_commit: headSha,
+      original_message: "Customer customizations (composite)",
+      original_author: "composite",
+      // Anchor `base_generation` on a SHA the applicator's
+      // `resolveBaseGeneration` can find — always a member of
+      // `lock.generations`. When `diffBase` is a recorded
+      // generation, use it directly; otherwise the guard above
+      // has already mapped it onto `current_generation`.
+      base_generation: resolvedBaseGeneration,
+      files,
+      patch_content: diff,
+      ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+      ...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 knownGenerations = new Set(lock.generations.map((g) => g.commit_sha));
+    const fallbackAnchor = lock.current_generation ?? lock.generations[lock.generations.length - 1]?.commit_sha;
+    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 oursPath = join2(this.outputDir, resolvedPath);
-      const ours = await readFile(oursPath, "utf-8").catch(() => null);
-      let ghostReconstructed = false;
-      let theirs = null;
-      if (!base && ours && !renameSourcePath) {
-        const treeReachable = await this.isTreeReachable(baseGen.tree_hash);
-        if (!treeReachable) {
-          const fileDiff = this.extractFileDiff(patch.patch_content, filePath);
-          if (fileDiff) {
-            const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
-            const result = reconstructFromGhostPatch2(fileDiff, ours);
-            if (result) {
-              base = result.base;
-              theirs = result.theirs;
-              ghostReconstructed = true;
-            }
-          }
-        }
+      const parents = await this.git.getCommitParents(commit.sha);
+      if (parents.length > 1) {
+        continue;
       }
-      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 (existingCommits.has(commit.sha)) {
+        continue;
       }
-      const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-      if (theirs) {
-        const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
-        const baseHasMarkers = base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization"));
-        if (theirsHasMarkers && !baseHasMarkers) {
-          if (accumulatorEntry) {
-            theirs = null;
-          } else {
-            return {
-              file: resolvedPath,
-              status: "skipped",
-              reason: "stale-conflict-markers"
-            };
-          }
-        }
+      let patchContent;
+      try {
+        patchContent = await this.git.formatPatch(commit.sha);
+      } catch {
+        continue;
       }
-      let useAccumulatorAsMergeBase = false;
-      if (accumulatorEntry && (theirs == null || base == null)) {
-        theirs = await this.applyPatchToContent(
-          accumulatorEntry.content,
-          patch.patch_content,
-          filePath,
-          tempGit,
-          tempDir
-        );
-        if (theirs != null) {
-          useAccumulatorAsMergeBase = true;
-        } else if (await this.isPatchAlreadyApplied(
-          patch.patch_content,
-          filePath,
-          accumulatorEntry.content,
-          tempGit,
-          tempDir
-        )) {
-          theirs = accumulatorEntry.content;
-          useAccumulatorAsMergeBase = true;
-        }
+      let contentHash = this.computeContentHash(patchContent);
+      if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
+        continue;
       }
-      if (theirs) {
-        const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
-        const accBaseHasMarkers = accumulatorEntry != null && (accumulatorEntry.content.includes("<<<<<<< Generated") || accumulatorEntry.content.includes(">>>>>>> Your customization"));
-        if (theirsHasMarkers && !accBaseHasMarkers && !(base != null && (base.includes("<<<<<<< Generated") || base.includes(">>>>>>> Your customization")))) {
-          return {
-            file: resolvedPath,
-            status: "skipped",
-            reason: "stale-conflict-markers"
-          };
-        }
+      if (this.isCreationOnlyPatch(patchContent)) {
+        continue;
       }
-      let effective_theirs = theirs;
-      let baseMismatchSkipped = false;
-      if (theirs != null && base != null && !useAccumulatorAsMergeBase) {
-        if (accumulatorEntry && accumulatorEntry.baseGeneration === patch.base_generation) {
+      const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
+      const { files, sensitiveFiles } = filterInfrastructureAndSensitiveFiles(filesOutput);
+      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) {
+          if (parents.length === 0) {
+            continue;
+          }
           try {
-            const preMerged = threeWayMerge(base, accumulatorEntry.content, theirs);
-            if (!preMerged.hasConflicts) {
-              effective_theirs = preMerged.content;
-            } else {
-              effective_theirs = theirs;
-            }
+            patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
           } catch {
-            effective_theirs = theirs;
+            continue;
           }
-        } else if (accumulatorEntry) {
-          baseMismatchSkipped = true;
-        }
-      }
-      if (base == null && ours == null && effective_theirs != null) {
-        this.fileTheirsAccumulator.set(resolvedPath, {
-          content: effective_theirs,
-          baseGeneration: patch.base_generation
-        });
-        const outDir2 = dirname2(oursPath);
-        await mkdir(outDir2, { recursive: true });
-        await writeFile(oursPath, effective_theirs);
-        return { file: resolvedPath, status: "merged", reason: "new-file" };
-      }
-      if (base == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
-        const merged2 = threeWayMerge("", ours, effective_theirs);
-        const outDir2 = dirname2(oursPath);
-        await mkdir(outDir2, { recursive: true });
-        await writeFile(oursPath, merged2.content);
-        if (merged2.hasConflicts) {
-          return {
-            file: resolvedPath,
-            status: "conflict",
-            conflicts: merged2.conflicts,
-            conflictReason: "new-file-both",
-            conflictMetadata: metadata
-          };
+          if (!patchContent.trim()) continue;
+          contentHash = this.computeContentHash(patchContent);
         }
-        this.fileTheirsAccumulator.set(resolvedPath, {
-          content: merged2.content,
-          baseGeneration: patch.base_generation
-        });
-        return { file: resolvedPath, status: "merged" };
-      }
-      if (effective_theirs == null) {
-        return {
-          file: resolvedPath,
-          status: "skipped",
-          reason: "missing-content"
-        };
-      }
-      if (base == null && !useAccumulatorAsMergeBase || ours == null) {
-        return {
-          file: resolvedPath,
-          status: "skipped",
-          reason: "missing-content"
-        };
       }
-      const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base;
-      if (mergeBase == null) {
-        return {
-          file: resolvedPath,
-          status: "skipped",
-          reason: "missing-content"
-        };
+      if (files.length === 0) {
+        continue;
       }
-      const merged = threeWayMerge(mergeBase, ours, effective_theirs);
-      const outDir = dirname2(oursPath);
-      await mkdir(outDir, { recursive: true });
-      await writeFile(oursPath, merged.content);
-      const populateAccumulator = effective_theirs != null && (!merged.hasConflicts || this.currentApplyMode === "resolve");
-      if (populateAccumulator) {
-        this.fileTheirsAccumulator.set(resolvedPath, {
-          content: effective_theirs,
-          baseGeneration: patch.base_generation
-        });
+      if (parents.length === 0) {
+        continue;
       }
-      if (merged.hasConflicts) {
-        return {
-          file: resolvedPath,
-          status: "conflict",
-          conflicts: merged.conflicts,
-          conflictReason: baseMismatchSkipped ? "base-generation-mismatch" : "same-line-edit",
-          conflictMetadata: metadata
-        };
+      const parentSha = parents[0];
+      let baseGeneration;
+      if (knownGenerations.has(parentSha)) {
+        baseGeneration = parentSha;
+      } else if (fallbackAnchor) {
+        baseGeneration = fallbackAnchor;
+      } else {
+        this.warnings.push(
+          `Skipping commit ${commit.sha.slice(0, 7)} (${commit.message.split("\n")[0]}): no recorded generation in the lockfile to anchor on. The customer's state on disk is preserved; tracked patches will resume on the next regeneration.`
+        );
+        continue;
       }
-      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)}`
-      };
+      const theirsSnapshot = await capturePatchSnapshot(this.git, files, commit.sha);
+      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: baseGeneration,
+        files,
+        patch_content: patchContent,
+        ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
+      });
     }
+    newPatches.reverse();
+    return { patches: newPatches, revertedPatchIds: [] };
   }
-  async isTreeReachable(treeHash) {
-    let result = this.treeExistsCache.get(treeHash);
-    if (result === void 0) {
-      result = await this.git.treeExists(treeHash);
-      this.treeExistsCache.set(treeHash, result);
+  /**
+   * 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 result;
+    return diffOldHeaders.every((l) => l === "--- /dev/null");
   }
-  isExcluded(patch) {
-    const config = this.lockManager.getCustomizationsConfig();
-    if (!config.exclude) return false;
-    return patch.files.some((file) => config.exclude.some((pattern) => minimatch(file, pattern)));
+  /**
+   * 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;
   }
-  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);
-          }
-        }
+  parseGitLog(log) {
+    return log.trim().split("\n").map((line) => {
+      const [sha, authorName, authorEmail, message] = line.split("\0");
+      return { sha, authorName, authorEmail, message };
+    });
+  }
+  getLastGeneration(lock) {
+    return lock.generations.find((g) => g.commit_sha === lock.current_generation);
+  }
+};
+
+// src/ThreeWayMerge.ts
+import { diff3Merge, diffPatch } from "node-diff3";
+function threeWayMerge(base, ours, theirs) {
+  const baseLines = base.split("\n");
+  const oursLines = ours.split("\n");
+  const theirsLines = theirs.split("\n");
+  const regions = diff3Merge(oursLines, baseLines, theirsLines);
+  const outputLines = [];
+  const conflicts = [];
+  let currentLine = 1;
+  for (const region of regions) {
+    if (region.ok) {
+      outputLines.push(...region.ok);
+      currentLine += region.ok.length;
+    } else if (region.conflict) {
+      const resolved = tryResolveConflict(
+        region.conflict.a,
+        // ours (generator)
+        region.conflict.o,
+        // base
+        region.conflict.b
+        // theirs (user)
+      );
+      if (resolved !== null) {
+        outputLines.push(...resolved);
+        currentLine += resolved.length;
+      } else {
+        const startLine = currentLine;
+        outputLines.push("<<<<<<< Generated");
+        outputLines.push(...region.conflict.a);
+        outputLines.push("=======");
+        outputLines.push(...region.conflict.b);
+        outputLines.push(">>>>>>> Your customization");
+        const conflictLines = region.conflict.a.length + region.conflict.b.length + 3;
+        conflicts.push({
+          startLine,
+          endLine: startLine + conflictLines - 1,
+          ours: region.conflict.a,
+          theirs: region.conflict.b
+        });
+        currentLine += conflictLines;
       }
     }
-    const cacheKey = `${baseTreeHash}:${currentTreeHash}`;
-    let renames = this.renameCache.get(cacheKey);
-    if (!renames) {
-      renames = await this.git.detectRenames(baseTreeHash, currentTreeHash);
-      this.renameCache.set(cacheKey, renames);
-    }
-    const gitRename = renames.find((r) => r.from === filePath);
-    if (gitRename) {
-      return gitRename.to;
+  }
+  const result = {
+    content: outputLines.join("\n"),
+    hasConflicts: conflicts.length > 0,
+    conflicts
+  };
+  if (conflicts.length === 0) {
+    const dropped = computeDroppedContextLines(baseLines, theirsLines, outputLines);
+    if (dropped.length > 0) {
+      result.droppedContextLines = dropped;
     }
-    return filePath;
   }
-  async applyPatchToContent(base, patchContent, filePath, tempGit, tempDir, sourceFilePath) {
-    if (!base) {
-      return this.extractNewFileFromPatch(patchContent, filePath);
+  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);
     }
-    const fileDiff = this.extractFileDiff(patchContent, filePath);
-    if (!fileDiff) return null;
-    try {
-      if (sourceFilePath) {
-        const tempSourcePath = join2(tempDir, sourceFilePath);
-        await mkdir(dirname2(tempSourcePath), { recursive: true });
-        await writeFile(tempSourcePath, base);
-        await tempGit.exec(["add", sourceFilePath]);
-        await tempGit.exec([
-          "commit",
-          "-m",
-          `base for rename ${sourceFilePath} -> ${filePath}`,
-          "--allow-empty"
-        ]);
-        await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-        const tempTargetPath = join2(tempDir, filePath);
-        return await readFile(tempTargetPath, "utf-8");
+  }
+  return dropped;
+}
+function countLines(lines) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    counts.set(line, (counts.get(line) ?? 0) + 1);
+  }
+  return counts;
+}
+function tryResolveConflict(oursLines, baseLines, theirsLines) {
+  if (baseLines.length === 0) {
+    return null;
+  }
+  const oursPatches = diffPatch(baseLines, oursLines);
+  const theirsPatches = diffPatch(baseLines, theirsLines);
+  if (oursPatches.length === 0) return theirsLines;
+  if (theirsPatches.length === 0) return oursLines;
+  if (patchesOverlap(oursPatches, theirsPatches)) {
+    return null;
+  }
+  return applyBothPatches(baseLines, oursPatches, theirsPatches);
+}
+function patchesOverlap(oursPatches, theirsPatches) {
+  for (const op of oursPatches) {
+    const oStart = op.buffer1.offset;
+    const oEnd = oStart + op.buffer1.length;
+    for (const tp of theirsPatches) {
+      const tStart = tp.buffer1.offset;
+      const tEnd = tStart + tp.buffer1.length;
+      if (op.buffer1.length === 0 && tp.buffer1.length === 0 && oStart === tStart) {
+        return true;
+      }
+      if (tp.buffer1.length === 0 && tStart === oEnd) {
+        return true;
+      }
+      if (op.buffer1.length === 0 && oStart === tEnd) {
+        return true;
+      }
+      if (oStart < tEnd && tStart < oEnd) {
+        return true;
       }
-      const tempFilePath = join2(tempDir, filePath);
-      await mkdir(dirname2(tempFilePath), { recursive: true });
-      await writeFile(tempFilePath, base);
-      await tempGit.exec(["add", filePath]);
-      await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
-      await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-      return await readFile(tempFilePath, "utf-8");
-    } catch {
-      return null;
     }
   }
+  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 as mkdir2, mkdtemp, readFile as readFile2, rm, unlink, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname3, join as join3 } from "path";
+import { minimatch } from "minimatch";
+
+// src/accumulator/MergeAccumulator.ts
+var MergeAccumulator = class {
+  constructor(mode, sharedFiles) {
+    this.mode = mode;
+    this.sharedFiles = sharedFiles;
+  }
+  entries = /* @__PURE__ */ new Map();
+  /** Was this file touched by 2+ patches in the current `applyPatches` invocation? */
+  isShared(path) {
+    return this.sharedFiles.has(path);
+  }
+  /** Has any prior patch already recorded a result for this path? */
+  has(path) {
+    return this.entries.has(path);
+  }
+  /** Look up the accumulated content + base generation for this path. */
+  lookup(path) {
+    return this.entries.get(path);
+  }
   /**
-   * 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.
+   * True if any of the patch's files have a prior accumulator entry — in
+   * which case the fast path (`git apply --3way`) cannot honor prior
+   * patches' contributions and we must route through the slow path.
    */
-  async isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
-    const fileDiff = this.extractFileDiff(patchContent, filePath);
-    if (!fileDiff) return false;
-    try {
-      const tempFilePath = join2(tempDir, filePath);
-      await mkdir(dirname2(tempFilePath), { recursive: true });
-      await writeFile(tempFilePath, content);
-      await tempGit.exec(["add", filePath]);
-      await tempGit.exec(["commit", "-m", `check already-applied ${filePath}`, "--allow-empty"]);
-      await tempGit.execWithInput(["apply", "--reverse", "--check", "--allow-empty"], fileDiff);
-      return true;
-    } catch {
-      return false;
+  shouldSkipFastPath(patch) {
+    return patch.files.some((f) => this.entries.has(f));
+  }
+  /** Record a successful (clean) merge result. */
+  recordMerge(path, content, baseGeneration) {
+    this.entries.set(path, { content, baseGeneration });
+  }
+  /**
+   * Record a conflicted merge result. Populates only in `"resolve"` mode
+   * — replay mode keeps the accumulator clean of marker-laden content
+   * since markers will be stripped from disk after the apply loop.
+   */
+  recordConflict(path, content, baseGeneration) {
+    if (this.mode === "resolve") {
+      this.entries.set(path, { content, baseGeneration });
     }
   }
-  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);
+  /**
+   * Defensive copy for test introspection. Used by invariant I2 to assert
+   * that after every applied patch, the accumulator has an entry for each
+   * file the patch touched (see `__tests__/invariants/i2-accumulator-correctness.ts`).
+   *
+   * @internal
+   */
+  snapshot() {
+    const copy = /* @__PURE__ */ new Map();
+    for (const [path, entry] of this.entries) {
+      copy.set(path, { content: entry.content, baseGeneration: entry.baseGeneration });
+    }
+    return copy;
+  }
+};
+
+// src/applicator/resolveInputs.ts
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
+async function resolveInputs(args) {
+  const {
+    patch,
+    filePath,
+    git,
+    lockManager,
+    outputDir,
+    isTreeReachable,
+    resolveBaseGeneration,
+    resolveFilePath,
+    extractRenameSource,
+    extractFileDiff: extractFileDiff2
+  } = args;
+  const baseGen = await resolveBaseGeneration(patch.base_generation);
+  if (!baseGen) {
+    return {
+      resolvedPath: filePath,
+      metadata: {
+        patchId: patch.id,
+        patchMessage: patch.original_message,
+        baseGeneration: patch.base_generation,
+        currentGeneration: lockManager.read().current_generation
+      },
+      base: null,
+      ours: null,
+      oursPath: join2(outputDir, filePath),
+      renameSourcePath: void 0,
+      ghostTheirs: null,
+      earlyExit: { status: "skipped", reason: "base-generation-not-found" }
+    };
+  }
+  const lock = lockManager.read();
+  const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+  const currentTreeHash = currentGen?.tree_hash ?? baseGen.tree_hash;
+  const resolvedPath = await 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 git.showFile(baseGen.tree_hash, filePath);
+  let renameSourcePath;
+  if (!base) {
+    const renameSource = extractRenameSource(patch.patch_content, filePath);
+    if (renameSource) {
+      base = await git.showFile(baseGen.tree_hash, renameSource);
+      renameSourcePath = renameSource;
+    }
+  }
+  const oursPath = join2(outputDir, resolvedPath);
+  const ours = await readFile(oursPath, "utf-8").catch(() => null);
+  let ghostTheirs = null;
+  if (!base && ours && !renameSourcePath) {
+    const treeReachable = await isTreeReachable(baseGen.tree_hash);
+    if (!treeReachable) {
+      const fileDiff = extractFileDiff2(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;
+          ghostTheirs = result.theirs;
         }
-        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;
+  return {
+    resolvedPath,
+    metadata,
+    base,
+    ours,
+    oursPath,
+    renameSourcePath,
+    ghostTheirs
+  };
+}
+
+// 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 (!inTargetFile) continue;
-      if (line.startsWith("@@")) break;
-      if (line.startsWith("rename from ")) {
-        return line.slice("rename from ".length);
+      if (!found) {
+        i++;
+        continue;
       }
     }
-    return null;
+    i++;
   }
-  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;
+  return ranges;
+}
+function stripConflictMarkers(content) {
+  const lines = content.split(/\r?\n/);
+  const ranges = findConflictRanges(lines);
+  if (ranges.length === 0) {
+    return content;
+  }
+  const result = [];
+  let rangeIdx = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (rangeIdx < ranges.length) {
+      const range = ranges[rangeIdx];
+      if (i === range.start) {
         continue;
       }
-      if (!inTargetFile) continue;
-      if (!inHunk) {
-        if (line === "--- /dev/null" || line.startsWith("new file mode")) {
-          isNewFile = true;
-        }
+      if (i > range.start && i < range.separator) {
+        result.push(lines[i]);
+        continue;
       }
-      if (line.startsWith("@@")) {
-        if (!isNewFile) return null;
-        inHunk = true;
+      if (i === range.separator) {
         continue;
       }
-      if (!inHunk) continue;
-      if (line === "\") {
-        noTrailingNewline = true;
+      if (i > range.separator && i < range.end) {
         continue;
       }
-      if (line.startsWith("+") && !line.startsWith("+++")) {
-        addedLines.push(line.slice(1));
+      if (i === range.end) {
+        rangeIdx++;
+        continue;
       }
     }
-    if (addedLines.length === 0) return null;
-    return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
-  }
-};
-function isBinaryFile(filePath) {
-  const ext = extname(filePath).toLowerCase();
-  return BINARY_EXTENSIONS.has(ext);
-}
-function computeDroppedContextLinesForFile(base, theirs, finalContent) {
-  const baseLines = base.split("\n");
-  const theirsLines = theirs.split("\n");
-  const finalLines = finalContent.split("\n");
-  const baseCounts = /* @__PURE__ */ new Map();
-  const theirsCounts = /* @__PURE__ */ new Map();
-  const finalCounts = /* @__PURE__ */ new Map();
-  for (const l of baseLines) baseCounts.set(l, (baseCounts.get(l) ?? 0) + 1);
-  for (const l of theirsLines) theirsCounts.set(l, (theirsCounts.get(l) ?? 0) + 1);
-  for (const l of finalLines) finalCounts.set(l, (finalCounts.get(l) ?? 0) + 1);
-  const dropped = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const line of baseLines) {
-    if (seen.has(line)) continue;
-    const inBase = baseCounts.get(line) ?? 0;
-    const inTheirs = theirsCounts.get(line) ?? 0;
-    const inFinal = finalCounts.get(line) ?? 0;
-    if (inBase > 0 && inTheirs > 0 && inFinal < Math.min(inBase, inTheirs)) {
-      dropped.push(line);
-      seen.add(line);
-    }
+    result.push(lines[i]);
   }
-  return dropped;
+  return result.join("\n");
 }
-function isDiffLineForFile(diffLine, filePath) {
-  const match = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
-  return match !== null && match[1] === filePath;
+function hasConflictMarkerStrings(content) {
+  if (content == null) return false;
+  return content.includes(CONFLICT_OPENER) || content.includes(CONFLICT_CLOSER);
 }
 
-// src/ReplayDetector.ts
-var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
-function parsePatchFileHeaders(patchContent) {
-  const results = [];
-  let currentPath = null;
-  let currentIsCreate = false;
-  let currentIsDelete = false;
-  const flush = () => {
-    if (currentPath !== null) {
-      results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
+// src/applicator/buildMergePlan.ts
+async function buildMergePlan(args) {
+  const {
+    inputs,
+    patch,
+    filePath,
+    accumulator,
+    tempGit,
+    tempDir,
+    applyPatchToContent: applyPatchToContent2,
+    isPatchAlreadyApplied
+  } = args;
+  const { base, ours, resolvedPath, renameSourcePath, ghostTheirs } = inputs;
+  let theirs = ghostTheirs;
+  const ghostReconstructed = ghostTheirs != null;
+  const snapshotForFile = patch.theirs_snapshot?.[resolvedPath] ?? patch.theirs_snapshot?.[filePath];
+  const fileIsShared = accumulator.isShared(resolvedPath) || accumulator.isShared(filePath);
+  const useSnapshotAsPrimary = !fileIsShared && snapshotForFile != null;
+  let primarySource = ghostReconstructed ? "ghost" : "reconstructed";
+  if (!ghostReconstructed) {
+    if (useSnapshotAsPrimary) {
+      theirs = snapshotForFile;
+      primarySource = "snapshot";
+    } else {
+      theirs = await applyPatchToContent2(
+        base,
+        patch.patch_content,
+        filePath,
+        tempGit,
+        tempDir,
+        renameSourcePath
+      );
+      const reconstructionHasMarkers = hasConflictMarkerStrings(theirs);
+      const baseHadMarkers = hasConflictMarkerStrings(base);
+      if (reconstructionHasMarkers && !baseHadMarkers && snapshotForFile != null) {
+        theirs = snapshotForFile;
+      }
+    }
+  }
+  const accumulatorEntry = accumulator.lookup(resolvedPath);
+  if (theirs) {
+    const theirsHasMarkers = hasConflictMarkerStrings(theirs);
+    const baseHasMarkers = hasConflictMarkerStrings(base);
+    if (theirsHasMarkers && !baseHasMarkers) {
+      if (accumulatorEntry) {
+        theirs = null;
+      } else {
+        return { kind: "skipped", reason: "stale-conflict-markers" };
+      }
+    }
+  }
+  let useAccumulatorAsMergeBase = false;
+  if (accumulatorEntry && (theirs == null || base == null)) {
+    theirs = await applyPatchToContent2(
+      accumulatorEntry.content,
+      patch.patch_content,
+      filePath,
+      tempGit,
+      tempDir
+    );
+    if (theirs != null) {
+      useAccumulatorAsMergeBase = true;
+    } else if (await isPatchAlreadyApplied(
+      patch.patch_content,
+      filePath,
+      accumulatorEntry.content,
+      tempGit,
+      tempDir
+    )) {
+      theirs = accumulatorEntry.content;
+      useAccumulatorAsMergeBase = true;
+    }
+  }
+  if (theirs) {
+    const theirsHasMarkers = hasConflictMarkerStrings(theirs);
+    const accBaseHasMarkers = accumulatorEntry != null && hasConflictMarkerStrings(accumulatorEntry.content);
+    if (theirsHasMarkers && !accBaseHasMarkers && !hasConflictMarkerStrings(base)) {
+      return { kind: "skipped", reason: "stale-conflict-markers" };
+    }
+  }
+  let effective_theirs = theirs;
+  let conflictReasonHint;
+  if (theirs != null && base != null && !useAccumulatorAsMergeBase) {
+    if (accumulatorEntry && accumulatorEntry.baseGeneration === patch.base_generation) {
+      try {
+        const preMerged = threeWayMerge(base, accumulatorEntry.content, theirs);
+        if (!preMerged.hasConflicts) {
+          effective_theirs = preMerged.content;
+        } else {
+          effective_theirs = theirs;
+        }
+      } catch {
+        effective_theirs = theirs;
+      }
+    } else if (accumulatorEntry) {
+      conflictReasonHint = "base-generation-mismatch";
+    }
+  }
+  if (base == null && ours == null && effective_theirs != null) {
+    return { kind: "new-file-only-user", theirs: effective_theirs };
+  }
+  if (base == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
+    return { kind: "new-file-both", theirs: effective_theirs };
+  }
+  if (effective_theirs == null) {
+    return { kind: "skipped", reason: "missing-content" };
+  }
+  if (base == null && !useAccumulatorAsMergeBase || ours == null) {
+    return { kind: "skipped", reason: "missing-content" };
+  }
+  if (useAccumulatorAsMergeBase) {
+    const mergeBase = accumulatorEntry?.content ?? base;
+    if (mergeBase == null) {
+      return { kind: "skipped", reason: "missing-content" };
     }
+    return {
+      kind: "accumulator-base",
+      theirs: effective_theirs,
+      mergeBase,
+      conflictReasonHint
+    };
+  }
+  return {
+    kind: primarySource,
+    base,
+    theirs: effective_theirs,
+    mergeBase: base,
+    conflictReasonHint
   };
-  for (const line of patchContent.split("\n")) {
-    if (line.startsWith("diff --git ")) {
-      flush();
-      currentPath = null;
-      currentIsCreate = false;
-      currentIsDelete = false;
-      const match = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
-      if (match) {
-        currentPath = match[2] ?? null;
-      }
-    } else if (currentPath !== null) {
-      if (line.startsWith("new file mode ")) {
-        currentIsCreate = true;
-      } else if (line.startsWith("deleted file mode ")) {
-        currentIsDelete = true;
-      }
+}
+
+// src/applicator/runMergeAndRecord.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+async function runMergeAndRecord(args) {
+  const { plan, inputs, patch, accumulator } = args;
+  const { resolvedPath, metadata, oursPath, ours } = inputs;
+  if (plan.kind === "skipped") {
+    return { file: resolvedPath, status: "skipped", reason: plan.reason };
+  }
+  if (plan.kind === "new-file-only-user") {
+    accumulator.recordMerge(resolvedPath, plan.theirs, patch.base_generation);
+    await mkdir(dirname2(oursPath), { recursive: true });
+    await writeFile(oursPath, plan.theirs);
+    return { file: resolvedPath, status: "merged", reason: "new-file" };
+  }
+  if (plan.kind === "new-file-both") {
+    const merged2 = threeWayMerge("", ours, plan.theirs);
+    await mkdir(dirname2(oursPath), { recursive: true });
+    await writeFile(oursPath, merged2.content);
+    if (merged2.hasConflicts) {
+      return {
+        file: resolvedPath,
+        status: "conflict",
+        conflicts: merged2.conflicts,
+        conflictReason: "new-file-both",
+        conflictMetadata: metadata
+      };
     }
+    accumulator.recordMerge(resolvedPath, merged2.content, patch.base_generation);
+    return { file: resolvedPath, status: "merged" };
   }
-  flush();
-  return results;
+  const merged = threeWayMerge(plan.mergeBase, ours, plan.theirs);
+  await mkdir(dirname2(oursPath), { recursive: true });
+  await writeFile(oursPath, merged.content);
+  if (merged.hasConflicts) {
+    accumulator.recordConflict(resolvedPath, plan.theirs, patch.base_generation);
+    return {
+      file: resolvedPath,
+      status: "conflict",
+      conflicts: merged.conflicts,
+      conflictReason: plan.conflictReasonHint ?? "same-line-edit",
+      conflictMetadata: metadata
+    };
+  }
+  accumulator.recordMerge(resolvedPath, plan.theirs, patch.base_generation);
+  return {
+    file: resolvedPath,
+    status: "merged",
+    ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
+  };
 }
-var ReplayDetector = class {
+
+// src/ReplayApplicator.ts
+var ReplayApplicator = class {
   git;
   lockManager;
-  sdkOutputDir;
-  warnings = [];
-  constructor(git, lockManager, sdkOutputDir) {
+  outputDir;
+  renameCache = /* @__PURE__ */ new Map();
+  treeExistsCache = /* @__PURE__ */ new Map();
+  /**
+   * Inter-patch THEIRS coordination. Created fresh in each `applyPatches`
+   * invocation with the run's apply mode + precomputed shared-file set.
+   * See `src/accumulator/MergeAccumulator.ts` for the full contract.
+   *
+   * Initialized to an empty default in the constructor so type narrowing
+   * works for callers that read it before any `applyPatches` invocation
+   * (e.g., the `getAccumulatorSnapshot` test accessor).
+   */
+  accumulator = new MergeAccumulator("replay", /* @__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 exists = await this.git.commitExists(lastGen.commit_sha);
-    if (!exists) {
-      this.warnings.push(
-        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
-      );
-      return this.detectPatchesViaTreeDiff(
-        lastGen,
-        /* commitKnownMissing */
-        true
-      );
-    }
-    const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
-    if (!isAncestor) {
-      return this.detectPatchesViaMergeBase(lastGen, lock);
-    }
-    return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
+    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
-      );
-    }
-    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.
+   * @internal Test-only.
+   * Returns a defensive copy of the inter-patch accumulator. Used by
+   * invariant I2 to assert that after every applied patch, the
+   * accumulator has an entry for each file the patch touched, and the
+   * entry's content matches on-disk.
+   */
+  getAccumulatorSnapshot() {
+    return this.accumulator.snapshot();
+  }
+  /**
+   * 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";
+    const fileFreq = /* @__PURE__ */ new Map();
+    for (const p of patches) {
+      for (const f of p.files) {
+        fileFreq.set(f, (fileFreq.get(f) ?? 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
+    }
+    const sharedFiles = new Set(
+      Array.from(fileFreq.entries()).filter(([, n]) => n > 1).map(([f]) => f)
+    );
+    this.accumulator = new MergeAccumulator(applyMode, sharedFiles);
+    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((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-      const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
-      const files = allFiles.filter((f) => !isSensitiveFile(f));
-      if (sensitiveFiles.length > 0) {
-        this.warnings.push(
-          `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
-        );
-        if (files.length > 0) {
-          const parentSha = parents[0];
-          if (parentSha) {
+      const result = await this.applyPatchWithFallback(patch);
+      results.push(result);
+      if (applyMode !== "resolve" && result.status === "conflict" && result.fileResults) {
+        const laterFiles = /* @__PURE__ */ new Set();
+        for (let j = i + 1; j < patches.length; j++) {
+          for (const f of patches[j].files) {
+            laterFiles.add(f);
+          }
+        }
+        const resolvedToOriginal = /* @__PURE__ */ new Map();
+        if (result.resolvedFiles) {
+          for (const [orig, resolved] of Object.entries(result.resolvedFiles)) {
+            resolvedToOriginal.set(resolved, orig);
+          }
+        }
+        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 = join3(this.outputDir, fileResult.file);
             try {
-              patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
+              const content = await readFile2(filePath, "utf-8");
+              const stripped = stripConflictMarkers(content);
+              await writeFile2(filePath, stripped);
             } 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 } : {}
+    }
+    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 mkdtemp(join3(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.accumulator.isShared(resolvedPath) || this.accumulator.isShared(filePath);
+        const theirs = !fileIsShared && snapshotForFile != null ? snapshotForFile : await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
+        const finalOnDisk = await readFile2(join3(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+        const effectiveTheirs = theirs ?? finalOnDisk;
+        if (effectiveTheirs != null) {
+          this.accumulator.recordMerge(resolvedPath, effectiveTheirs, patch.base_generation);
+        }
+        if (base != null && effectiveTheirs != null && finalOnDisk != null) {
+          const dropped = computeDroppedContextLinesForFile(base, effectiveTheirs, finalOnDisk);
+          if (dropped.length > 0) {
+            fileResults.push({
+              file: resolvedPath,
+              status: "merged",
+              droppedContextLines: dropped
+            });
+          }
+        }
+      }
+    } finally {
+      await rm(tempDir, { recursive: true }).catch(() => {
       });
     }
-    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 {
+    return fileResults;
+  }
+  async applyPatchWithFallback(patch) {
+    const baseGen = await this.resolveBaseGeneration(patch.base_generation);
+    const lock = this.lockManager.read();
+    const currentGen = lock.generations.find((g) => g.commit_sha === lock.current_generation);
+    const currentTreeHash = currentGen?.tree_hash ?? baseGen?.tree_hash ?? "";
+    const needsAccumulation = await Promise.all(
+      patch.files.map(async (f) => {
+        if (!baseGen) return false;
+        const resolved = await this.resolveFilePath(f, baseGen.tree_hash, currentTreeHash);
+        return this.accumulator.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 revertedSha = parseRevertedSha(body);
-      const revertedMessage = parseRevertedMessage(patch.original_message);
-      let matchedExisting = false;
-      if (revertedSha) {
-        const existing = lock.patches.find((p) => p.original_commit === revertedSha);
-        if (existing) {
-          revertedPatchIdSet.add(existing.id);
-          revertIndicesToRemove.add(i);
-          matchedExisting = true;
-        }
+    }
+    const 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 = join3(this.outputDir, filePath);
+        snapshots.set(filePath, await readFile2(fullPath, "utf-8").catch(() => null));
       }
-      if (!matchedExisting && revertedMessage) {
-        const existing = lock.patches.find((p) => p.original_message === revertedMessage);
-        if (existing) {
-          revertedPatchIdSet.add(existing.id);
-          revertIndicesToRemove.add(i);
-          matchedExisting = true;
+      try {
+        await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
+        const fastPathFileResults = await this.populateAccumulatorForPatch(patch, baseGen, currentTreeHash);
+        return {
+          patch,
+          status: "applied",
+          method: "git-am",
+          ...fastPathFileResults.length > 0 && { fileResults: fastPathFileResults },
+          ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+        };
+      } catch {
+        for (const [filePath, content] of snapshots) {
+          const fullPath = join3(this.outputDir, filePath);
+          if (content != null) {
+            await writeFile2(fullPath, content);
+          } else {
+            await unlink(fullPath).catch(() => {
+            });
+          }
         }
       }
-      if (matchedExisting) continue;
-      let matchedNew = false;
-      if (revertedSha) {
-        const idx = survivingPatches.findIndex(
-          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_commit === revertedSha
-        );
-        if (idx !== -1) {
-          revertIndicesToRemove.add(i);
-          revertIndicesToRemove.add(idx);
-          matchedNew = true;
+    }
+    return this.applyWithThreeWayMerge(patch);
+  }
+  async applyWithThreeWayMerge(patch) {
+    const fileResults = [];
+    const resolvedFiles = {};
+    const tempDir = await mkdtemp(join3(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;
         }
-      }
-      if (!matchedNew && revertedMessage) {
-        const idx = survivingPatches.findIndex(
-          (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_message === revertedMessage
-        );
-        if (idx !== -1) {
-          revertIndicesToRemove.add(i);
-          revertIndicesToRemove.add(idx);
+        const result = await this.mergeFile(patch, filePath, tempGit, tempDir);
+        if (result.file !== filePath) {
+          resolvedFiles[filePath] = result.file;
         }
+        fileResults.push(result);
       }
-      if (!matchedExisting && !matchedNew) {
-        revertIndicesToRemove.add(i);
+    } finally {
+      await rm(tempDir, { recursive: true }).catch(() => {
+      });
+    }
+    const conflictFiles = fileResults.filter((r) => r.status === "conflict");
+    const hasConflicts = conflictFiles.length > 0;
+    const conflictReason = hasConflicts ? conflictFiles.some((f) => f.conflictReason === "base-generation-mismatch") ? "base-generation-mismatch" : conflictFiles[0]?.conflictReason : void 0;
+    return {
+      patch,
+      status: hasConflicts ? "conflict" : "applied",
+      method: "3way-merge",
+      fileResults,
+      conflictReason,
+      ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
+    };
+  }
+  async mergeFile(patch, filePath, tempGit, tempDir) {
+    try {
+      const inputs = await resolveInputs({
+        patch,
+        filePath,
+        git: this.git,
+        lockManager: this.lockManager,
+        outputDir: this.outputDir,
+        isTreeReachable: (h) => this.isTreeReachable(h),
+        resolveBaseGeneration: (s) => this.resolveBaseGeneration(s),
+        resolveFilePath: (f, b, c) => this.resolveFilePath(f, b, c),
+        extractRenameSource: (p, f) => this.extractRenameSource(p, f),
+        extractFileDiff: (p, f) => this.extractFileDiff(p, f)
+      });
+      if (inputs.earlyExit) {
+        return { file: filePath, ...inputs.earlyExit };
       }
+      const plan = await buildMergePlan({
+        inputs,
+        patch,
+        filePath,
+        accumulator: this.accumulator,
+        tempGit,
+        tempDir,
+        applyPatchToContent: (b, p, f, g, d, s) => this.applyPatchToContent(b, p, f, g, d, s),
+        isPatchAlreadyApplied: (p, f, c, g, d) => this.isPatchAlreadyApplied(p, f, c, g, d)
+      });
+      return await runMergeAndRecord({
+        plan,
+        inputs,
+        patch,
+        accumulator: this.accumulator
+      });
+    } catch (error) {
+      return {
+        file: filePath,
+        status: "skipped",
+        reason: `error: ${error instanceof Error ? error.message : String(error)}`
+      };
     }
-    const filteredPatches = survivingPatches.filter((_, i) => !revertIndicesToRemove.has(i));
-    return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
   }
-  /**
-   * Compute content hash for deduplication.
-   *
-   * Produces a format-agnostic hash so both `git format-patch` output
-   * (email-wrapped) and plain `git diff` output hash to the same value
-   * when the underlying diff hunks are identical.
-   *
-   * Normalization:
-   *   1. Strip email wrapper: everything before the first `diff --git` line
-   *      (From:, Subject:, Date:, diffstat, blank separators).
-   *   2. Strip `index` lines (blob SHA pairs change across rebases).
-   *   3. Strip trailing git version marker (`-- \n<version>`).
-   *
-   * This ensures content hashes match across the no-patches and normal-
-   * regeneration flows, which store formatPatch and git-diff formats
-   * respectively (FER-9850, D5-D9).
-   */
-  computeContentHash(patchContent) {
-    const lines = patchContent.split("\n");
-    const diffStart = lines.findIndex((l) => l.startsWith("diff --git "));
-    const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
-    const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
-    return `sha256:${createHash("sha256").update(normalized).digest("hex")}`;
+  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;
   }
-  /**
-   * 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);
+  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);
+          }
+        }
       }
     }
-    let anyCandidate = false;
-    for (const state of stateByFile.values()) {
-      if (state.created && state.deleted) {
-        anyCandidate = true;
-        break;
-      }
+    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 (!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);
-      }
+    const gitRename = renames.find((r) => r.from === filePath);
+    if (gitRename) {
+      return gitRename.to;
     }
-    if (transient.size === 0) return patches;
-    return patches.filter((patch) => !patch.files.every((f) => transient.has(f)));
+    return filePath;
   }
-  /**
-   * 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() {
+  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 {
-      const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
-      return new Set(out.split("\n").map((l) => l.trim()).filter(Boolean));
+      if (sourceFilePath) {
+        const tempSourcePath = join3(tempDir, sourceFilePath);
+        await mkdir2(dirname3(tempSourcePath), { recursive: true });
+        await writeFile2(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 = join3(tempDir, filePath);
+        return await readFile2(tempTargetPath, "utf-8");
+      }
+      const tempFilePath = join3(tempDir, filePath);
+      await mkdir2(dirname3(tempFilePath), { recursive: true });
+      await writeFile2(tempFilePath, base);
+      await tempGit.exec(["add", filePath]);
+      await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
+      await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
+      return await readFile2(tempFilePath, "utf-8");
     } catch {
-      return /* @__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((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-    const sensitiveMergeFiles = allMergeFiles.filter((f) => isSensitiveFile(f));
-    const files = allMergeFiles.filter((f) => !isSensitiveFile(f));
-    if (sensitiveMergeFiles.length > 0) {
-      this.warnings.push(
-        `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveMergeFiles.join(", ")}. These files will not be tracked by replay.`
-      );
-    }
-    if (files.length === 0) return null;
-    const diff = await this.git.exec([
-      "diff",
-      firstParent,
-      mergeCommit.sha,
-      "--",
-      ...files
-    ]);
-    if (!diff.trim()) return null;
-    const contentHash = this.computeContentHash(diff);
-    if (lock.patches.some((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
       return null;
     }
-    const theirsSnapshot = {};
-    for (const file of files) {
-      if (isBinaryFile(file)) continue;
-      const content = await this.git.showFile(mergeCommit.sha, file).catch(() => null);
-      if (content != null) theirsSnapshot[file] = content;
-    }
-    return {
-      id: `patch-merge-${mergeCommit.sha.slice(0, 8)}`,
-      content_hash: contentHash,
-      original_commit: mergeCommit.sha,
-      original_message: mergeCommit.message,
-      original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
-      base_generation: lastGen.commit_sha,
-      files,
-      patch_content: diff,
-      ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
-      ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
-    };
   }
   /**
-   * 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.
+   * 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 detectPatchesViaTreeDiff(lastGen, commitKnownMissing) {
-    const diffBase = await this.resolveDiffBase(lastGen, commitKnownMissing);
-    if (!diffBase) {
-      return this.detectPatchesViaCommitScan();
-    }
-    const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
-    const allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
-    const sensitiveTreeFiles = allTreeFiles.filter((f) => isSensitiveFile(f));
-    const files = allTreeFiles.filter((f) => !isSensitiveFile(f));
-    if (sensitiveTreeFiles.length > 0) {
-      this.warnings.push(
-        `Sensitive file(s) excluded from composite patch: ${sensitiveTreeFiles.join(", ")}. These files will not be tracked by replay.`
-      );
-    }
-    if (files.length === 0) return { patches: [], revertedPatchIds: [] };
-    const diff = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
-    if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
-    const contentHash = this.computeContentHash(diff);
-    const lock = this.lockManager.read();
-    if (lock.patches.some((p) => p.content_hash === contentHash) || (lock.forgotten_hashes ?? []).includes(contentHash)) {
-      return { patches: [], revertedPatchIds: [] };
-    }
-    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;
+  async isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
+    const fileDiff = this.extractFileDiff(patchContent, filePath);
+    if (!fileDiff) return false;
+    try {
+      const tempFilePath = join3(tempDir, filePath);
+      await mkdir2(dirname3(tempFilePath), { recursive: true });
+      await writeFile2(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;
     }
-    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: [] };
   }
-  /**
-   * 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) {
+  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 (existingCommits.has(commit.sha)) {
-        continue;
+      if (inTargetFile) {
+        diffLines.push(line);
       }
-      let patchContent;
-      try {
-        patchContent = await this.git.formatPatch(commit.sha);
-      } catch {
+    }
+    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;
       }
-      let contentHash = this.computeContentHash(patchContent);
-      if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
-        continue;
+      if (!inTargetFile) continue;
+      if (line.startsWith("@@")) break;
+      if (line.startsWith("rename from ")) {
+        return line.slice("rename from ".length);
       }
-      if (this.isCreationOnlyPatch(patchContent)) {
+    }
+    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;
       }
-      const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-      const allScanFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f));
-      const sensitiveScanFiles = allScanFiles.filter((f) => isSensitiveFile(f));
-      const files = allScanFiles.filter((f) => !isSensitiveFile(f));
-      if (sensitiveScanFiles.length > 0) {
-        this.warnings.push(
-          `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveScanFiles.join(", ")}. These files will not be tracked by replay.`
-        );
-        if (files.length > 0) {
-          if (parents.length === 0) {
-            continue;
-          }
-          try {
-            patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
-          } catch {
-            continue;
-          }
-          if (!patchContent.trim()) continue;
-          contentHash = this.computeContentHash(patchContent);
+      if (!inTargetFile) continue;
+      if (!inHunk) {
+        if (line === "--- /dev/null" || line.startsWith("new file mode")) {
+          isNewFile = true;
         }
       }
-      if (files.length === 0) {
+      if (line.startsWith("@@")) {
+        if (!isNewFile) return null;
+        inHunk = true;
         continue;
       }
-      if (parents.length === 0) {
+      if (!inHunk) continue;
+      if (line === "\") {
+        noTrailingNewline = true;
         continue;
       }
-      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;
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        addedLines.push(line.slice(1));
       }
-      newPatches.push({
-        id: `patch-${commit.sha.slice(0, 8)}`,
-        content_hash: contentHash,
-        original_commit: commit.sha,
-        original_message: commit.message,
-        original_author: `${commit.authorName} <${commit.authorEmail}>`,
-        base_generation: parentSha,
-        files,
-        patch_content: patchContent,
-        ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {}
-      });
-    }
-    newPatches.reverse();
-    return { patches: newPatches, revertedPatchIds: [] };
-  }
-  /**
-   * Check if a format-patch consists entirely of new-file creations.
-   * Used to identify squashed commits after force push, which create all files
-   * from scratch (--- /dev/null) rather than modifying existing files.
-   */
-  isCreationOnlyPatch(patchContent) {
-    const diffOldHeaders = patchContent.split("\n").filter((l) => l.startsWith("--- "));
-    if (diffOldHeaders.length === 0) {
-      return false;
     }
-    return diffOldHeaders.every((l) => l === "--- /dev/null");
+    if (addedLines.length === 0) return null;
+    return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
   }
-  /**
-   * 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;
+};
+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 null;
-  }
-  parseGitLog(log) {
-    return log.trim().split("\n").map((line) => {
-      const [sha, authorName, authorEmail, message] = line.split("\0");
-      return { sha, authorName, authorEmail, message };
-    });
-  }
-  getLastGeneration(lock) {
-    return lock.generations.find((g) => g.commit_sha === lock.current_generation);
   }
-};
+  return dropped;
+}
+function isDiffLineForFile(diffLine, filePath) {
+  const match = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
+  return match !== null && match[1] === filePath;
+}
 
 // src/ReplayCommitter.ts
 var ReplayCommitter = class {
@@ -2408,15 +2539,15 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
 // src/ReplayService.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { readFile as readFileAsync } from "fs/promises";
-import { join as join5 } from "path";
-import { minimatch as minimatch2 } from "minimatch";
+import { join as join6 } from "path";
+import { minimatch as minimatch3 } from "minimatch";
 init_GitClient();
 
 // src/PatchRegionDiff.ts
 init_HybridReconstruction();
-import { mkdtemp as mkdtemp2, writeFile as writeFile2, rm as rm2 } from "fs/promises";
+import { mkdtemp as mkdtemp2, writeFile as writeFile3, rm as rm2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { spawn } from "child_process";
 function normalizeHunkBody(hunk) {
   let contextC = 0;
@@ -2622,12 +2753,12 @@ function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locI
 }
 async function unifiedDiff(beforeContent, afterContent, filePath) {
   if (beforeContent === afterContent) return "";
-  const tmp = await mkdtemp2(join3(tmpdir2(), "fern-replay-pp-"));
+  const tmp = await mkdtemp2(join4(tmpdir2(), "fern-replay-pp-"));
   try {
-    const beforePath = join3(tmp, "before");
-    const afterPath = join3(tmp, "after");
-    await writeFile2(beforePath, beforeContent, "utf-8");
-    await writeFile2(afterPath, afterContent, "utf-8");
+    const beforePath = join4(tmp, "before");
+    const afterPath = join4(tmp, "after");
+    await writeFile3(beforePath, beforeContent, "utf-8");
+    await writeFile3(afterPath, afterContent, "utf-8");
     const raw = await runGitDiffNoIndex(beforePath, afterPath);
     if (!raw.trim()) return "";
     return rewriteDiffHeaders(raw, filePath);
@@ -2704,211 +2835,84 @@ function synthesizeDeleteFileDiff(file, content) {
   return header + "\n" + body + trailer + "\n";
 }
 
-// src/ReplayService.ts
-var ReplayService = class {
-  git;
-  detector;
-  applicator;
-  committer;
-  lockManager;
-  outputDir;
-  /** @internal Test-only. Captures the last ReplayResult[] returned from applicator.applyPatches(). */
-  _lastApplyResults = [];
-  /**
-   * Service-level warnings accumulated during a single runReplay() call.
-   * Merged with `detector.warnings` into `ReplayReport.warnings` by each flow handler.
-   * Populated by `isFileUserOwned` when a patch's base generation tree is unreachable
-   * (shallow clone / aggressive `git gc --prune`) and we fall back to a conservative
-   * heuristic. Cleared at the top of `runReplay()`.
-   */
-  warnings = [];
-  /**
-   * @internal Test-only accessor.
-   * Returns the ReplayApplicator instance used for the last run. Tests use this
-   * to inspect the inter-patch accumulator after runReplay() completes (FER-9791, I2).
-   */
-  get applicatorRef() {
-    return this.applicator;
-  }
-  /**
-   * @internal Test-only accessor.
-   * Returns the ReplayResult[] from the most recent applyPatches() call. Tests use
-   * this to filter applied-vs-conflicted-vs-absorbed patches for invariant assertions
-   * (FER-9791). Returns an empty array if no patches have been applied yet.
-   */
-  getLastResults() {
-    return this._lastApplyResults;
-  }
-  constructor(outputDir, _config) {
-    const git = new GitClient(outputDir);
+// src/classifier/FileOwnership.ts
+import { minimatch as minimatch2 } from "minimatch";
+var FileOwnership = class {
+  constructor(git) {
     this.git = git;
-    this.outputDir = outputDir;
-    this.lockManager = new LockfileManager(outputDir);
-    this.detector = new ReplayDetector(git, this.lockManager, outputDir);
-    this.applicator = new ReplayApplicator(git, this.lockManager, outputDir);
-    this.committer = new ReplayCommitter(git, outputDir);
-  }
-  /**
-   * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
-   * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
-   * the generation commit (or unchanged for dry-run).
-   *
-   * Does NOT apply patches — the returned handle must be passed to
-   * `applyPreparedReplay()` to complete the run. No disk writes to the lockfile
-   * happen here; lockfile persistence is deferred to phase 2.
-   *
-   * Callers may land additional commits on HEAD between `prepareReplay` and
-   * `applyPreparedReplay` (e.g., `[fern-autoversion]`).
-   */
-  async prepareReplay(options) {
-    this.warnings = [];
-    this.detector.warnings.length = 0;
-    if (options?.skipApplication) {
-      return this._prepareSkipApplication(options);
-    }
-    const flow = this.determineFlow();
-    switch (flow) {
-      case "first-generation":
-        return this._prepareFirstGeneration(options);
-      case "no-patches":
-        return this._prepareNoPatchesRegeneration(options);
-      case "normal-regeneration":
-        return this._prepareNormalRegeneration(options);
-    }
-  }
-  /**
-   * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
-   * the generation, saves the lockfile, and commits `[fern-replay]` (or stages
-   * under `stageOnly`). Operates on HEAD at call time — mid-phase commits are
-   * respected.
-   *
-   * For terminal handles (dry-run, first-gen has no patch work, skip-app does
-   * its own post-commit logic), this returns the precomputed report.
-   */
-  async applyPreparedReplay(prep, options) {
-    if (prep._prepared.terminal) {
-      return prep._prepared.preparedReport;
-    }
-    switch (prep._prepared.flow) {
-      case "first-generation":
-        return this._applyFirstGeneration(prep);
-      case "skip-application":
-        return this._applySkipApplication(prep, options);
-      case "no-patches":
-        return this._applyNoPatchesRegeneration(prep, options);
-      case "normal-regeneration":
-        return this._applyNormalRegeneration(prep, options);
-    }
-  }
-  /**
-   * Backwards-compatible atomic entry point. Composes `prepareReplay` + `applyPreparedReplay`.
-   * Behavior is byte-identical to the pre-split implementation for all existing callers.
-   */
-  async runReplay(options) {
-    const prep = await this.prepareReplay(options);
-    return this.applyPreparedReplay(prep, options);
   }
   /**
-   * Sync the lockfile after a divergent PR was squash-merged.
-   * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
+   * Canonical resolution. Returns true if `file` is user-owned per:
    *
-   * After updating the generation record, re-detects customer patches via
-   * tree diff between the generation tag (pure generation tree) and HEAD
-   * (which includes customer customizations after squash merge). This ensures
-   * patches survive the squash merge → regenerate cycle even when the lockfile
-   * was restored from the base branch during conflict PR creation.
+   *   1. `patch.user_owned === true` — authoritative, persisted flag.
+   *   2. `file === ".fernignore"` — always user-owned.
+   *   3. File matches a `.fernignore` pattern (via minimatch).
+   *   4. Patch content shows `--- /dev/null` for this file (legacy-safe
+   *      signal for patches predating `user_owned` or whose flag was lost).
+   *   5. Tree-based check against `patch.base_generation` when reachable
+   *      AND distinct from `currentGenSha`. Unreachable base → conservative
+   *      user-owned (silent-absorption safety net), with a one-time warning
+   *      per base SHA.
+   *   6. Final fallback: check `currentGenSha` when no usable base exists
+   *      (legacy one-gen lockfile).
    */
-  async syncFromDivergentMerge(generationCommitSha, options) {
-    const treeHash = await this.git.getTreeHash(generationCommitSha);
-    const timestamp = (await this.git.exec(["log", "-1", "--format=%aI", generationCommitSha])).trim();
-    const record = {
-      commit_sha: generationCommitSha,
-      tree_hash: treeHash,
-      timestamp,
-      cli_version: options?.cliVersion ?? "unknown",
-      generator_versions: options?.generatorVersions ?? {},
-      base_branch_head: options?.baseBranchHead
-    };
-    let resolvedPatches;
-    if (!this.lockManager.exists()) {
-      this.lockManager.initializeInMemory(record);
-    } else {
-      this.lockManager.read();
-      const unresolvedPatches = [
-        ...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);
-      }
+  async resolveCanonical(ctx) {
+    const { file, originalFileName, patch, currentGenSha, fernignorePatterns, warnedGens, warnings } = ctx;
+    if (patch.user_owned) return true;
+    if (file === ".fernignore") return true;
+    if (fernignorePatterns.some((p) => file === p || minimatch2(file, p))) return true;
+    if (fileIsCreationInPatchContent(patch.patch_content, originalFileName ?? file)) {
+      return true;
     }
-    try {
-      const { patches: redetectedPatches } = await this.detector.detectNewPatches();
-      if (redetectedPatches.length > 0) {
-        const redetectedFiles = new Set(redetectedPatches.flatMap((p) => p.files));
-        const currentPatches = this.lockManager.getPatches();
-        for (const patch of currentPatches) {
-          if (patch.status != null && patch.files.some((f) => redetectedFiles.has(f))) {
-            this.lockManager.removePatch(patch.id);
-          }
-        }
-        for (const patch of redetectedPatches) {
-          this.lockManager.addPatch(patch);
+    const base = patch.base_generation;
+    if (base && base !== currentGenSha) {
+      const reachable = await this.git.commitExists(base) || await this.git.treeExists(base);
+      if (!reachable) {
+        if (!warnedGens.has(base)) {
+          warnedGens.add(base);
+          warnings.push(
+            `Base generation ${base.slice(0, 7)} is unreachable (shallow clone or pruned history). Treating affected files as user-owned to avoid silent data loss. Run \`git fetch --unshallow\` or avoid \`git gc --prune\` to restore full history.`
+          );
         }
+        return true;
       }
-    } 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)}`
-      );
+      return await this.git.showFile(base, originalFileName ?? file) === null;
     }
-    this.lockManager.save();
-    this.detector.warnings.push(...this.lockManager.warnings);
+    return await this.git.showFile(currentGenSha, originalFileName ?? file) === null;
   }
-  determineFlow() {
-    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;
+};
+function fileIsCreationInPatchContent(patchContent, file) {
+  const lines = patchContent.split("\n");
+  let inFileSection = false;
+  for (const line of lines) {
+    if (line.startsWith("diff --git ")) {
+      inFileSection = line.includes(` b/${file}`) || line.endsWith(` b/${file}`);
+      continue;
+    }
+    if (inFileSection && line.startsWith("--- ")) {
+      return line === "--- /dev/null";
     }
   }
-  firstGenerationReport() {
-    return {
-      flow: "first-generation",
-      patchesDetected: 0,
-      patchesApplied: 0,
-      patchesWithConflicts: 0,
-      patchesSkipped: 0,
-      conflicts: []
-    };
+  return false;
+}
+
+// src/flows/FirstGenerationFlow.ts
+var FirstGenerationFlow = class {
+  constructor(service) {
+    this.service = service;
   }
-  async _prepareFirstGeneration(options) {
+  async prepare(options) {
     if (options?.dryRun) {
-      const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+      const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
       return {
         flow: "first-generation",
         previousGenerationSha: null,
         currentGenerationSha: headSha,
         baseBranchHead: options.baseBranchHead ?? null,
         _prepared: {
+          kind: "terminal",
           flow: "first-generation",
-          terminal: true,
-          preparedReport: this.firstGenerationReport(),
-          patchesToApply: [],
-          newPatchIds: /* @__PURE__ */ new Set(),
-          detectorWarnings: [],
-          revertedCount: 0,
-          genSha: headSha,
-          optionsSnapshot: options
+          preparedReport: firstGenerationReport()
         }
       };
     }
@@ -2917,17 +2921,17 @@ var ReplayService = class {
       generatorVersions: options.generatorVersions ?? {},
       baseBranchHead: options.baseBranchHead
     } : void 0;
-    await this.committer.commitGeneration("Initial SDK generation", commitOpts);
-    const genRecord = await this.committer.createGenerationRecord(commitOpts);
-    this.lockManager.initializeInMemory(genRecord);
+    await this.service.committer.commitGeneration("Initial SDK generation", commitOpts);
+    const genRecord = await this.service.committer.createGenerationRecord(commitOpts);
+    this.service.lockManager.initializeInMemory(genRecord);
     return {
       flow: "first-generation",
       previousGenerationSha: null,
       currentGenerationSha: genRecord.commit_sha,
       baseBranchHead: options?.baseBranchHead ?? null,
       _prepared: {
+        kind: "active",
         flow: "first-generation",
-        terminal: false,
         patchesToApply: [],
         newPatchIds: /* @__PURE__ */ new Set(),
         detectorWarnings: [],
@@ -2937,47 +2941,57 @@ var ReplayService = class {
       }
     };
   }
-  async _applyFirstGeneration(_prep) {
-    this.lockManager.save();
-    return this.firstGenerationReport();
+  async apply(_prep) {
+    this.service.lockManager.save();
+    return firstGenerationReport();
   }
-  /**
-   * Skip-application mode phase 1: commit the generation and update the
-   * in-memory lockfile, but don't detect or apply patches. Sets a marker
-   * so the next normal run skips revert detection in preGenerationRebase().
-   *
-   * Disk save is deferred to `_applySkipApplication`.
-   */
-  async _prepareSkipApplication(options) {
+};
+function firstGenerationReport() {
+  return {
+    flow: "first-generation",
+    patchesDetected: 0,
+    patchesApplied: 0,
+    patchesWithConflicts: 0,
+    patchesSkipped: 0,
+    conflicts: []
+  };
+}
+
+// src/flows/SkipApplicationFlow.ts
+var SkipApplicationFlow = class {
+  constructor(service) {
+    this.service = service;
+  }
+  async prepare(options) {
     const commitOpts = options ? {
       cliVersion: options.cliVersion ?? "unknown",
       generatorVersions: options.generatorVersions ?? {},
       baseBranchHead: options.baseBranchHead
     } : void 0;
-    await this.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
-    await this.cleanupStaleConflictMarkers();
-    const genRecord = await this.committer.createGenerationRecord(commitOpts);
+    await this.service.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
+    await this.service.cleanupStaleConflictMarkers();
+    const genRecord = await this.service.committer.createGenerationRecord(commitOpts);
     let previousGenerationSha = null;
     try {
-      const lock = this.lockManager.read();
+      const lock = this.service.lockManager.read();
       previousGenerationSha = lock.current_generation ?? null;
-      this.lockManager.addGeneration(genRecord);
+      this.service.lockManager.addGeneration(genRecord);
     } catch (error) {
       if (error instanceof LockfileNotFoundError) {
-        this.lockManager.initializeInMemory(genRecord);
+        this.service.lockManager.initializeInMemory(genRecord);
       } else {
         throw error;
       }
     }
-    this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
+    this.service.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
     return {
       flow: "skip-application",
       previousGenerationSha,
       currentGenerationSha: genRecord.commit_sha,
       baseBranchHead: options?.baseBranchHead ?? null,
       _prepared: {
+        kind: "active",
         flow: "skip-application",
-        terminal: false,
         patchesToApply: [],
         newPatchIds: /* @__PURE__ */ new Set(),
         detectorWarnings: [],
@@ -2987,13 +3001,13 @@ var ReplayService = class {
       }
     };
   }
-  async _applySkipApplication(_prep, options) {
-    this.lockManager.save();
-    const credentialWarnings = [...this.lockManager.warnings];
+  async apply(_prep, options) {
+    this.service.lockManager.save();
+    const credentialWarnings = [...this.service.lockManager.warnings];
     if (!options?.stageOnly) {
-      await this.committer.commitReplay(0);
+      await this.service.committer.commitReplay(0);
     } else {
-      await this.committer.stageAll();
+      await this.service.committer.stageAll();
     }
     return {
       flow: "skip-application",
@@ -3005,13 +3019,20 @@ var ReplayService = class {
       warnings: credentialWarnings.length > 0 ? credentialWarnings : void 0
     };
   }
-  async _prepareNoPatchesRegeneration(options) {
-    const preLock = this.lockManager.read();
+};
+
+// src/flows/NoPatchesFlow.ts
+var NoPatchesFlow = class {
+  constructor(service) {
+    this.service = service;
+  }
+  async prepare(options) {
+    const preLock = this.service.lockManager.read();
     const previousGenerationSha = preLock.current_generation ?? null;
-    let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
-    const detectorWarnings = [...this.detector.warnings];
+    let { patches: newPatches, revertedPatchIds } = await this.service.detector.detectNewPatches();
+    const detectorWarnings = [...this.service.detector.warnings];
     if (options?.dryRun) {
-      const dryRunWarnings = [...detectorWarnings, ...this.warnings];
+      const dryRunWarnings = [...detectorWarnings, ...this.service.warnings];
       const preparedReport = {
         flow: "no-patches",
         patchesDetected: newPatches.length,
@@ -3023,22 +3044,16 @@ var ReplayService = class {
         wouldApply: newPatches,
         warnings: dryRunWarnings.length > 0 ? dryRunWarnings : void 0
       };
-      const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+      const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
       return {
         flow: "no-patches",
         previousGenerationSha,
         currentGenerationSha: headSha,
         baseBranchHead: options.baseBranchHead ?? null,
         _prepared: {
+          kind: "terminal",
           flow: "no-patches",
-          terminal: true,
-          preparedReport,
-          patchesToApply: [],
-          newPatchIds: /* @__PURE__ */ new Set(),
-          detectorWarnings,
-          revertedCount: revertedPatchIds.length,
-          genSha: headSha,
-          optionsSnapshot: options
+          preparedReport
         }
       };
     }
@@ -3047,7 +3062,7 @@ var ReplayService = class {
       const uniqueFiles = [...new Set(newPatches.flatMap((p) => p.files))];
       const absorbedFiles = /* @__PURE__ */ new Set();
       for (const file of uniqueFiles) {
-        const diff = await this.git.exec(["diff", preCurrentGen, "HEAD", "--", file]).catch(() => null);
+        const diff = await this.service.git.exec(["diff", preCurrentGen, "HEAD", "--", file]).catch(() => null);
         if (diff !== null && !diff.trim()) {
           absorbedFiles.add(file);
         }
@@ -3060,7 +3075,7 @@ var ReplayService = class {
     }
     for (const id of revertedPatchIds) {
       try {
-        this.lockManager.removePatch(id);
+        this.service.lockManager.removePatch(id);
       } catch {
       }
     }
@@ -3069,18 +3084,18 @@ var ReplayService = class {
       generatorVersions: options.generatorVersions ?? {},
       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);
+    await this.service.committer.commitGeneration("Update SDK", commitOpts);
+    await this.service.cleanupStaleConflictMarkers();
+    const genRecord = await this.service.committer.createGenerationRecord(commitOpts);
+    this.service.lockManager.addGeneration(genRecord);
     return {
       flow: "no-patches",
       previousGenerationSha,
       currentGenerationSha: genRecord.commit_sha,
       baseBranchHead: options?.baseBranchHead ?? null,
       _prepared: {
+        kind: "active",
         flow: "no-patches",
-        terminal: false,
         patchesToApply: newPatches,
         newPatchIds: new Set(newPatches.map((p) => p.id)),
         detectorWarnings,
@@ -3090,41 +3105,42 @@ var ReplayService = class {
       }
     };
   }
-  async _applyNoPatchesRegeneration(prep, options) {
+  async apply(prep, options) {
+    assertActive(prep);
     const newPatches = prep._prepared.patchesToApply;
     const detectorWarnings = prep._prepared.detectorWarnings;
     const genSha = prep._prepared.genSha;
     let results = [];
     if (newPatches.length > 0) {
-      results = await this.applicator.applyPatches(newPatches);
-      this._lastApplyResults = results;
-      this.recordDroppedContextLineWarnings(results);
-      this.revertConflictingFiles(results);
+      results = await this.service.applicator.applyPatches(newPatches);
+      this.service._lastApplyResults = results;
+      this.service.recordDroppedContextLineWarnings(results);
+      this.service.revertConflictingFiles(results);
       for (const result of results) {
         if (result.status === "conflict") {
           result.patch.status = "unresolved";
         }
       }
     }
-    const rebaseCounts = await this.rebasePatches(results, genSha);
+    const rebaseCounts = await this.service.rebasePatches(results, genSha);
     for (const patch of newPatches) {
       if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
-        this.lockManager.addPatch(patch);
+        this.service.lockManager.addPatch(patch);
       }
     }
-    this.lockManager.save();
-    this.warnings.push(...this.lockManager.warnings);
+    this.service.lockManager.save();
+    this.service.warnings.push(...this.service.lockManager.warnings);
     if (newPatches.length > 0) {
       if (!options?.stageOnly) {
         const appliedCount = results.filter((r) => r.status === "applied").length;
         const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, newPatches);
-        await this.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
+        await this.service.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
       } else {
-        await this.committer.stageAll();
+        await this.service.committer.stageAll();
       }
     }
-    const warnings = [...detectorWarnings, ...this.warnings];
-    return this.buildReport(
+    const warnings = [...detectorWarnings, ...this.service.warnings];
+    return this.service.buildReport(
       "no-patches",
       newPatches,
       results,
@@ -3135,13 +3151,20 @@ var ReplayService = class {
       prep._prepared.revertedCount
     );
   }
-  async _prepareNormalRegeneration(options) {
-    const preLock = this.lockManager.read();
+};
+
+// src/flows/NormalRegenerationFlow.ts
+var NormalRegenerationFlow = class {
+  constructor(service) {
+    this.service = service;
+  }
+  async prepare(options) {
+    const preLock = this.service.lockManager.read();
     const previousGenerationSha = preLock.current_generation ?? null;
     if (options?.dryRun) {
-      const existingPatches2 = this.lockManager.getPatches();
-      const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.detector.detectNewPatches();
-      const warnings = [...this.detector.warnings, ...this.warnings];
+      const existingPatches2 = this.service.lockManager.getPatches();
+      const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.service.detector.detectNewPatches();
+      const warnings = [...this.service.detector.warnings, ...this.service.warnings];
       const allPatches2 = [...existingPatches2, ...newPatches2];
       const preparedReport = {
         flow: "normal-regeneration",
@@ -3154,48 +3177,42 @@ var ReplayService = class {
         wouldApply: allPatches2,
         warnings: warnings.length > 0 ? warnings : void 0
       };
-      const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+      const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
       return {
         flow: "normal-regeneration",
         previousGenerationSha,
         currentGenerationSha: headSha,
         baseBranchHead: options.baseBranchHead ?? null,
         _prepared: {
+          kind: "terminal",
           flow: "normal-regeneration",
-          terminal: true,
-          preparedReport,
-          patchesToApply: [],
-          newPatchIds: /* @__PURE__ */ new Set(),
-          detectorWarnings: [...this.detector.warnings],
-          revertedCount: dryRunReverted.length,
-          genSha: headSha,
-          optionsSnapshot: options
+          preparedReport
         }
       };
     }
-    let existingPatches = this.lockManager.getPatches();
+    let existingPatches = this.service.lockManager.getPatches();
     const preRebasePatchIds = new Set(existingPatches.map((p) => p.id));
-    const preRebaseCounts = await this.preGenerationRebase(existingPatches);
-    const postRebasePatchIds = new Set(this.lockManager.getPatches().map((p) => p.id));
+    const preRebaseCounts = await this.service.preGenerationRebase(existingPatches);
+    const postRebasePatchIds = new Set(this.service.lockManager.getPatches().map((p) => p.id));
     const removedByPreRebase = existingPatches.filter(
       (p) => preRebasePatchIds.has(p.id) && !postRebasePatchIds.has(p.id)
     );
-    existingPatches = this.lockManager.getPatches();
+    existingPatches = this.service.lockManager.getPatches();
     const seenHashes = /* @__PURE__ */ new Map();
     for (const p of existingPatches) {
       const priorPatchId = seenHashes.get(p.content_hash);
       if (priorPatchId !== void 0) {
-        this.lockManager.removePatch(p.id);
-        this.warnings.push(
+        this.service.lockManager.removePatch(p.id);
+        this.service.warnings.push(
           `Consolidated patch ${p.id} (commit ${(p.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content. Per-commit attribution preserved in git log; lockfile collapsed to avoid duplicate-apply corruption on next regen.`
         );
       } else {
         seenHashes.set(p.content_hash, p.id);
       }
     }
-    existingPatches = this.lockManager.getPatches();
-    let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
-    const detectorWarnings = [...this.detector.warnings];
+    existingPatches = this.service.lockManager.getPatches();
+    let { patches: newPatches, revertedPatchIds } = await this.service.detector.detectNewPatches();
+    const detectorWarnings = [...this.service.detector.warnings];
     if (removedByPreRebase.length > 0) {
       const removedOriginalCommits = new Set(removedByPreRebase.map((p) => p.original_commit));
       const removedOriginalMessages = new Set(removedByPreRebase.map((p) => p.original_message));
@@ -3210,7 +3227,7 @@ var ReplayService = class {
     }
     for (const id of revertedPatchIds) {
       try {
-        this.lockManager.removePatch(id);
+        this.service.lockManager.removePatch(id);
       } catch {
       }
     }
@@ -3222,18 +3239,18 @@ var ReplayService = class {
       generatorVersions: options.generatorVersions ?? {},
       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);
+    await this.service.committer.commitGeneration("Update SDK", commitOpts);
+    await this.service.cleanupStaleConflictMarkers();
+    const genRecord = await this.service.committer.createGenerationRecord(commitOpts);
+    this.service.lockManager.addGeneration(genRecord);
     return {
       flow: "normal-regeneration",
       previousGenerationSha,
       currentGenerationSha: genRecord.commit_sha,
       baseBranchHead: options?.baseBranchHead ?? null,
       _prepared: {
+        kind: "active",
         flow: "normal-regeneration",
-        terminal: false,
         patchesToApply: allPatches,
         newPatchIds: new Set(newPatches.map((p) => p.id)),
         preRebaseCounts,
@@ -3244,46 +3261,47 @@ var ReplayService = class {
       }
     };
   }
-  async _applyNormalRegeneration(prep, options) {
+  async apply(prep, options) {
+    assertActive(prep);
     const allPatches = prep._prepared.patchesToApply;
     const newPatchIds = prep._prepared.newPatchIds;
     const detectorWarnings = prep._prepared.detectorWarnings;
     const genSha = prep._prepared.genSha;
-    const results = await this.applicator.applyPatches(allPatches);
-    this._lastApplyResults = results;
-    this.recordDroppedContextLineWarnings(results);
-    this.revertConflictingFiles(results);
+    const results = await this.service.applicator.applyPatches(allPatches);
+    this.service._lastApplyResults = results;
+    this.service.recordDroppedContextLineWarnings(results);
+    this.service.revertConflictingFiles(results);
     for (const result of results) {
       if (result.status === "conflict") {
         result.patch.status = "unresolved";
       }
     }
-    const rebaseCounts = await this.rebasePatches(results, genSha);
+    const rebaseCounts = await this.service.rebasePatches(results, genSha);
     const newPatches = allPatches.filter((p) => newPatchIds.has(p.id));
     for (const patch of newPatches) {
       if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
-        this.lockManager.addPatch(patch);
+        this.service.lockManager.addPatch(patch);
       }
     }
     for (const result of results) {
       if (result.status === "conflict") {
         try {
-          this.lockManager.markPatchUnresolved(result.patch.id);
+          this.service.lockManager.markPatchUnresolved(result.patch.id);
         } catch {
         }
       }
     }
-    this.lockManager.save();
-    this.warnings.push(...this.lockManager.warnings);
+    this.service.lockManager.save();
+    this.service.warnings.push(...this.service.lockManager.warnings);
     if (options?.stageOnly) {
-      await this.committer.stageAll();
+      await this.service.committer.stageAll();
     } else {
       const appliedCount = results.filter((r) => r.status === "applied").length;
       const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, allPatches);
-      await this.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
+      await this.service.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
     }
-    const warnings = [...detectorWarnings, ...this.warnings];
-    return this.buildReport(
+    const warnings = [...detectorWarnings, ...this.service.warnings];
+    return this.service.buildReport(
       "normal-regeneration",
       allPatches,
       results,
@@ -3294,10 +3312,213 @@ var ReplayService = class {
       prep._prepared.revertedCount
     );
   }
+};
+
+// src/ReplayService.ts
+function assertActive(prep) {
+  if (prep._prepared.kind !== "active") {
+    throw new Error(
+      `Flow.apply() called with terminal preparation (kind=${prep._prepared.kind}); terminal cases must be handled by applyPreparedReplay's dispatcher`
+    );
+  }
+}
+var ReplayService = class {
+  /** @internal Used by Flow implementations in `src/flows/`. */
+  git;
+  /** @internal Used by Flow implementations in `src/flows/`. */
+  detector;
+  /** @internal Used by Flow implementations in `src/flows/`. */
+  applicator;
+  /** @internal Used by Flow implementations in `src/flows/`. */
+  committer;
+  /** @internal Used by Flow implementations in `src/flows/`. */
+  lockManager;
+  /** @internal Used by Flow implementations in `src/flows/`. */
+  fileOwnership;
+  /** @internal Used by Flow implementations in `src/flows/`. */
+  outputDir;
+  /** @internal Test-only. Captures the last ReplayResult[] returned from applicator.applyPatches(). */
+  _lastApplyResults = [];
+  /**
+   * Service-level warnings accumulated during a single runReplay() call.
+   * Merged with `detector.warnings` into `ReplayReport.warnings` by each flow handler.
+   * Populated by `FileOwnership.resolveCanonical` when a patch's base generation tree
+   * is unreachable (shallow clone / aggressive `git gc --prune`) and we fall back to a
+   * conservative heuristic. Cleared at the top of `runReplay()`.
+   *
+   * @internal Used by Flow implementations in `src/flows/`.
+   */
+  warnings = [];
+  /**
+   * @internal Test-only accessor.
+   * Returns the ReplayApplicator instance used for the last run. Tests use this
+   * to inspect the inter-patch accumulator after runReplay() completes (invariant I2).
+   */
+  get applicatorRef() {
+    return this.applicator;
+  }
+  /**
+   * @internal Test-only accessor.
+   * Returns the ReplayResult[] from the most recent applyPatches() call. Tests use
+   * this to filter applied-vs-conflicted-vs-absorbed patches for invariant
+   * assertions. Returns an empty array if no patches have been applied yet.
+   */
+  getLastResults() {
+    return this._lastApplyResults;
+  }
+  constructor(outputDir, _config) {
+    const git = new GitClient(outputDir);
+    this.git = git;
+    this.outputDir = outputDir;
+    this.lockManager = new LockfileManager(outputDir);
+    this.detector = new ReplayDetector(git, this.lockManager, outputDir);
+    this.applicator = new ReplayApplicator(git, this.lockManager, outputDir);
+    this.committer = new ReplayCommitter(git, outputDir);
+    this.fileOwnership = new FileOwnership(git);
+  }
+  /**
+   * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
+   * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
+   * the generation commit (or unchanged for dry-run).
+   *
+   * Does NOT apply patches — the returned handle must be passed to
+   * `applyPreparedReplay()` to complete the run. No disk writes to the lockfile
+   * happen here; lockfile persistence is deferred to phase 2.
+   *
+   * Callers may land additional commits on HEAD between `prepareReplay` and
+   * `applyPreparedReplay` (e.g., `[fern-autoversion]`).
+   */
+  async prepareReplay(options) {
+    this.warnings = [];
+    this.detector.warnings.length = 0;
+    return this.selectFlow(options).prepare(options);
+  }
+  /**
+   * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
+   * the generation, saves the lockfile, and commits `[fern-replay]` (or stages
+   * under `stageOnly`). Operates on HEAD at call time — mid-phase commits are
+   * respected.
+   *
+   * For terminal handles (dry-run, first-gen has no patch work, skip-app does
+   * its own post-commit logic), this returns the precomputed report.
+   */
+  async applyPreparedReplay(prep, options) {
+    if (prep._prepared.kind === "terminal") {
+      return prep._prepared.preparedReport;
+    }
+    return this.flowForKind(prep._prepared.flow).apply(prep, options);
+  }
+  /**
+   * Construct the flow for the current run. `selectFlow` is called from
+   * `prepareReplay` and decides based on options + lockfile state.
+   */
+  selectFlow(options) {
+    if (options?.skipApplication) return new SkipApplicationFlow(this);
+    return this.flowForKind(this.determineFlow());
+  }
+  /**
+   * Construct a flow given its kind. Used by `applyPreparedReplay` to
+   * route to the same kind that was selected in phase 1.
+   */
+  flowForKind(kind) {
+    switch (kind) {
+      case "first-generation":
+        return new FirstGenerationFlow(this);
+      case "no-patches":
+        return new NoPatchesFlow(this);
+      case "normal-regeneration":
+        return new NormalRegenerationFlow(this);
+      case "skip-application":
+        return new SkipApplicationFlow(this);
+    }
+  }
+  /**
+   * Backwards-compatible atomic entry point. Composes `prepareReplay` + `applyPreparedReplay`.
+   * Behavior is byte-identical to the pre-split implementation for all existing callers.
+   */
+  async runReplay(options) {
+    const prep = await this.prepareReplay(options);
+    return this.applyPreparedReplay(prep, options);
+  }
+  /**
+   * Sync the lockfile after a divergent PR was squash-merged.
+   * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
+   *
+   * After updating the generation record, re-detects customer patches via
+   * tree diff between the generation tag (pure generation tree) and HEAD
+   * (which includes customer customizations after squash merge). This ensures
+   * patches survive the squash merge → regenerate cycle even when the lockfile
+   * was restored from the base branch during conflict PR creation.
+   */
+  async syncFromDivergentMerge(generationCommitSha, options) {
+    const treeHash = await this.git.getTreeHash(generationCommitSha);
+    const timestamp = (await this.git.exec(["log", "-1", "--format=%aI", generationCommitSha])).trim();
+    const record = {
+      commit_sha: generationCommitSha,
+      tree_hash: treeHash,
+      timestamp,
+      cli_version: options?.cliVersion ?? "unknown",
+      generator_versions: options?.generatorVersions ?? {},
+      base_branch_head: options?.baseBranchHead
+    };
+    let resolvedPatches;
+    if (!this.lockManager.exists()) {
+      this.lockManager.initializeInMemory(record);
+    } else {
+      this.lockManager.read();
+      const unresolvedPatches = [
+        ...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);
+      }
+    }
+    try {
+      const { patches: redetectedPatches } = await this.detector.detectNewPatches();
+      if (redetectedPatches.length > 0) {
+        const redetectedFiles = new Set(redetectedPatches.flatMap((p) => p.files));
+        const currentPatches = this.lockManager.getPatches();
+        for (const patch of currentPatches) {
+          if (patch.status != null && patch.files.some((f) => redetectedFiles.has(f))) {
+            this.lockManager.removePatch(patch.id);
+          }
+        }
+        for (const patch of redetectedPatches) {
+          this.lockManager.addPatch(patch);
+        }
+      }
+    } 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();
+    this.detector.warnings.push(...this.lockManager.warnings);
+  }
+  determineFlow() {
+    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;
+    }
+  }
   /**
    * Rebase cleanly applied patches so they are relative to the current generation.
    * This prevents recurring conflicts on subsequent regenerations.
    * Returns the number of patches rebased.
+   *
+   * @internal Used by Flow implementations in `src/flows/`.
    */
   async rebasePatches(results, currentGenSha) {
     let absorbed = 0;
@@ -3307,6 +3528,7 @@ var ReplayService = class {
     const seenContentHashes = /* @__PURE__ */ new Map();
     const absorbedPatchIds = /* @__PURE__ */ new Set();
     const fernignorePatterns = this.readFernignorePatterns();
+    const warnedGens = /* @__PURE__ */ new Set();
     for (const result of results) {
       if (result.resolvedFiles && Object.keys(result.resolvedFiles).length > 0) {
         const patch = result.patch;
@@ -3351,21 +3573,20 @@ var ReplayService = class {
           }
         }
         const isUserOwnedPerFile = await Promise.all(
-          patch.files.map(async (file) => {
-            if (file === ".fernignore") return true;
-            if (fernignorePatterns.some((p) => file === p || minimatch2(file, p))) {
-              return true;
-            }
-            if (patch.user_owned) return true;
-            if (this.fileIsCreationInPatchContent(patch.patch_content, originalByResolved[file] ?? file)) {
-              return true;
-            }
-            const content = await this.git.showFile(currentGenSha, file);
-            return content === null;
-          })
+          patch.files.map(
+            (file) => this.fileOwnership.resolveCanonical({
+              file,
+              originalFileName: originalByResolved[file],
+              patch,
+              currentGenSha,
+              fernignorePatterns,
+              warnedGens,
+              warnings: this.warnings
+            })
+          )
         );
         const hasProtectedFiles = patch.files.some(
-          (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || minimatch2(file, p))
+          (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || minimatch3(file, p))
         );
         const allUserOwned = isUserOwnedPerFile.every(Boolean);
         if (allUserOwned && patch.files.length > 0) {
@@ -3489,7 +3710,7 @@ var ReplayService = class {
     for (const file of files) {
       if (isBinaryFile(file)) continue;
       try {
-        const content = await readFileAsync(join5(this.outputDir, file), "utf-8");
+        const content = await readFileAsync(join6(this.outputDir, file), "utf-8");
         snapshot[file] = content;
       } catch {
       }
@@ -3497,10 +3718,16 @@ var ReplayService = class {
     return snapshot;
   }
   /**
-   * FER-10203: returns true when a `[fern-autoversion]` commit between
-   * `fromSha` and `toSha` touched any of the patch's `files`. Re-classifies
-   * each grep match via `isGenerationCommit` so a customer commit that
-   * merely quotes the marker in its body doesn't false-positive.
+   * Detects autoversion contamination — returns true when a
+   * `[fern-autoversion]` commit between `fromSha` and `toSha` touched any
+   * of the patch's `files`. Re-classifies each grep match via
+   * `isGenerationCommit` so a customer commit that merely quotes the
+   * marker in its body doesn't false-positive.
+   *
+   * Used by preGenerationRebase to skip the customer-content rebuild for
+   * patches whose files were last touched by an autoversion step — a
+   * naive `git diff currentGen HEAD` there would capture the
+   * placeholder→semver swap as customer customization.
    */
   async hasAutoversionContamination(fromSha, toSha, files) {
     if (files.length === 0) return false;
@@ -3529,10 +3756,15 @@ var ReplayService = class {
     return false;
   }
   /**
-   * FER-10203: rebuild patch_content from `theirs_snapshot` (captured at
-   * detection time, predates pipeline content) rather than a HEAD-relative
-   * diff. Returns `null` when snapshot is missing or doesn't cover every
-   * file in `patch.files` — caller leaves the patch unchanged.
+   * Rebuild patch_content from `theirs_snapshot` (captured at detection
+   * time, predates pipeline content) rather than a HEAD-relative diff.
+   * Returns `null` when snapshot is missing or doesn't cover every file
+   * in `patch.files` — caller leaves the patch unchanged.
+   *
+   * Used as the autoversion-contamination escape hatch: when the
+   * HEAD-relative diff would capture pipeline content (autoversion's
+   * placeholder swap) as customer customization, the snapshot path
+   * preserves the customer's actual intent.
    */
   async computeSnapshotBasedPatchDiff(patch, currentGen) {
     if (!patch.theirs_snapshot) return null;
@@ -3580,7 +3812,7 @@ var ReplayService = class {
    * **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
+   * into one patch's snapshot — breaking 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
@@ -3642,72 +3874,6 @@ var ReplayService = class {
       );
     }
   }
-  /**
-   * Determine whether `file` is user-owned (never produced by the generator).
-   *
-   * Resolution order (first match wins):
-   *  1. `patch.user_owned === true` — authoritative, persisted across cycles.
-   *  2. `.fernignore` itself, or file matches a .fernignore pattern.
-   *  3. Legacy-safe signal: `patch_content` shows this file as a `--- /dev/null`
-   *     creation. Works for patches that predate the `user_owned` field or
-   *     whose flag was lost. Immune to rename tricks — relies on raw patch text.
-   *  4. Tree-based check against `patch.base_generation` when it is reachable
-   *     AND distinct from `currentGenSha`. If the base tree is unreachable
-   *     (shallow clone / aggressive `git gc --prune`), emit a one-time
-   *     customer-actionable warning (deduplicated via warnedGens) and
-   *     conservatively treat as user-owned — strictly safer than silent
-   *     absorption (FER-9809).
-   *  5. Final fallback — check `currentGenSha` when there is no usable base
-   *     (legacy one-gen lockfile). Preserves pre-fix behavior for that edge.
-   *
-   * `originalFileName` is the pre-rename path when the generator moved the
-   * file between the patch's base and the current generation. Tree lookups
-   * at ancestor generations use the original path — that's where the
-   * generator produced the content.
-   */
-  async isFileUserOwned(file, patch, currentGenSha, fernignorePatterns, warnedGens, originalFileName) {
-    if (patch.user_owned) return true;
-    if (file === ".fernignore") return true;
-    if (fernignorePatterns.some((p) => file === p || minimatch2(file, p))) return true;
-    if (this.fileIsCreationInPatchContent(patch.patch_content, originalFileName ?? file)) {
-      return true;
-    }
-    const base = patch.base_generation;
-    if (base && base !== currentGenSha) {
-      const reachable = await this.git.commitExists(base) || await this.git.treeExists(base);
-      if (!reachable) {
-        if (!warnedGens.has(base)) {
-          warnedGens.add(base);
-          this.warnings.push(
-            `Base generation ${base.slice(0, 7)} is unreachable (shallow clone or pruned history). Treating affected files as user-owned to avoid silent data loss. Run \`git fetch --unshallow\` or avoid \`git gc --prune\` to restore full history.`
-          );
-        }
-        return true;
-      }
-      return await this.git.showFile(base, originalFileName ?? file) === null;
-    }
-    return await this.git.showFile(currentGenSha, originalFileName ?? file) === null;
-  }
-  /**
-   * Returns true if `file`'s diff section in `patchContent` starts with
-   * `--- /dev/null`, meaning this file was introduced by the patch (user
-   * creation). Used as a legacy-safe fallback when `patch.user_owned` is
-   * absent or cleared.
-   */
-  fileIsCreationInPatchContent(patchContent, file) {
-    const lines = patchContent.split("\n");
-    let inFileSection = false;
-    for (const line of lines) {
-      if (line.startsWith("diff --git ")) {
-        inFileSection = line.includes(` b/${file}`) || line.endsWith(` b/${file}`);
-        continue;
-      }
-      if (inFileSection && line.startsWith("--- ")) {
-        return line === "--- /dev/null";
-      }
-    }
-    return false;
-  }
   /**
    * For conflict patches with mixed results (some files merged, some conflicted),
    * check if the cleanly merged files were absorbed by the generator (empty diff).
@@ -3726,7 +3892,15 @@ var ReplayService = class {
     const warnedGens = /* @__PURE__ */ new Set();
     const generatorCleanFiles = [];
     for (const file of cleanFiles) {
-      if (await this.isFileUserOwned(file, patch, currentGenSha, fernignorePatterns, warnedGens)) {
+      const userOwned = await this.fileOwnership.resolveCanonical({
+        file,
+        patch,
+        currentGenSha,
+        fernignorePatterns,
+        warnedGens,
+        warnings: this.warnings
+      });
+      if (userOwned) {
         continue;
       }
       generatorCleanFiles.push(file);
@@ -3755,6 +3929,7 @@ var ReplayService = class {
    * Pre-generation rebase: update patches using the customer's current state.
    * Called BEFORE commitGeneration() while HEAD has customer code.
    */
+  /** @internal Used by Flow implementations in `src/flows/`. */
   async preGenerationRebase(patches) {
     const lock = this.lockManager.read();
     const currentGen = lock.current_generation;
@@ -3793,7 +3968,15 @@ var ReplayService = class {
       if (patch.user_owned) return true;
       if (patch.files.length === 0) return false;
       for (const file of patch.files) {
-        if (!await this.isFileUserOwned(file, patch, currentGen, fernignorePatterns, warnedGens)) {
+        const userOwned = await this.fileOwnership.resolveCanonical({
+          file,
+          patch,
+          currentGenSha: currentGen,
+          fernignorePatterns,
+          warnedGens,
+          warnings: this.warnings
+        });
+        if (!userOwned) {
           return false;
         }
       }
@@ -3843,7 +4026,7 @@ var ReplayService = class {
             );
             if (snapHasStaleMarkers) continue;
             const isProtectedSnap = patch.files.some(
-              (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || minimatch2(file, p))
+              (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || minimatch3(file, p))
             );
             if (isProtectedSnap) continue;
             const snapHash = this.detector.computeContentHash(snapshotDiff);
@@ -3878,7 +4061,7 @@ var ReplayService = class {
             continue;
           }
           const isProtected = patch.files.some(
-            (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || minimatch2(file, p))
+            (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || minimatch3(file, p))
           );
           if (isProtected) {
             continue;
@@ -3985,6 +4168,7 @@ var ReplayService = class {
    * relied on them. This is the "surface or preserve, never silently drop"
    * contract for legitimate-deletion cases.
    */
+  /** @internal Used by Flow implementations in `src/flows/`. */
   recordDroppedContextLineWarnings(results) {
     const PREVIEW_COUNT = 5;
     for (const result of results) {
@@ -4007,12 +4191,13 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
    * After applyPatches(), strip conflict markers from conflicting files
    * so only clean content is committed. Keeps the Generated (OURS) side.
    */
+  /** @internal Used by Flow implementations in `src/flows/`. */
   revertConflictingFiles(results) {
     for (const result of results) {
       if (result.status !== "conflict" || !result.fileResults) continue;
       for (const fileResult of result.fileResults) {
         if (fileResult.status !== "conflict") continue;
-        const filePath = join5(this.outputDir, fileResult.file);
+        const filePath = join6(this.outputDir, fileResult.file);
         try {
           const content = readFileSync2(filePath, "utf-8");
           const stripped = stripConflictMarkers(content);
@@ -4028,13 +4213,14 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
    * Restores files to their clean generated state from HEAD.
    * Skips .fernignore-protected files to prevent overwriting user content.
    */
+  /** @internal Used by Flow implementations in `src/flows/`. */
   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;
+      if (fernignorePatterns.some((pattern) => minimatch3(file, pattern))) continue;
       try {
         await this.git.exec(["checkout", "HEAD", "--", file]);
       } catch {
@@ -4042,10 +4228,11 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     }
   }
   readFernignorePatterns() {
-    const fernignorePath = join5(this.outputDir, ".fernignore");
+    const fernignorePath = join6(this.outputDir, ".fernignore");
     if (!existsSync2(fernignorePath)) return [];
     return readFileSync2(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   }
+  /** @internal Used by Flow implementations in `src/flows/`. */
   buildReport(flow, patches, results, options, warnings, rebaseCounts, preRebaseCounts, patchesReverted) {
     const conflictResults = results.filter((r) => r.status === "conflict");
     const conflictDetails = conflictResults.map((r) => {
@@ -4121,8 +4308,8 @@ function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit)
 // src/FernignoreMigrator.ts
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4, join as join6 } from "path";
-import { minimatch as minimatch3 } from "minimatch";
+import { dirname as dirname5, join as join7 } from "path";
+import { minimatch as minimatch4 } from "minimatch";
 import { parse as parse2, stringify as stringify2 } from "yaml";
 var FernignoreMigrator = class {
   git;
@@ -4134,10 +4321,10 @@ var FernignoreMigrator = class {
     this.outputDir = outputDir;
   }
   fernignoreExists() {
-    return existsSync3(join6(this.outputDir, ".fernignore"));
+    return existsSync3(join7(this.outputDir, ".fernignore"));
   }
   readFernignorePatterns() {
-    const fernignorePath = join6(this.outputDir, ".fernignore");
+    const fernignorePath = join7(this.outputDir, ".fernignore");
     if (!existsSync3(fernignorePath)) {
       return [];
     }
@@ -4154,7 +4341,7 @@ var FernignoreMigrator = class {
     const commitsOnly = [];
     const syntheticPatches = [];
     for (const pattern of patterns) {
-      const matchingPatch = patches.find((p) => p.files.some((f) => minimatch3(f, pattern) || f === pattern));
+      const matchingPatch = patches.find((p) => p.files.some((f) => minimatch4(f, pattern) || f === pattern));
       if (matchingPatch) {
         trackedByBoth.push({
           file: pattern,
@@ -4227,7 +4414,7 @@ var FernignoreMigrator = class {
       fernignoreOnly.push(...remainingFernignoreOnly);
     }
     for (const patch of patches) {
-      const hasUnprotectedFiles = patch.files.some((f) => !patterns.some((p) => minimatch3(f, p) || f === p));
+      const hasUnprotectedFiles = patch.files.some((f) => !patterns.some((p) => minimatch4(f, p) || f === p));
       if (hasUnprotectedFiles) {
         commitsOnly.push(patch);
       }
@@ -4239,14 +4426,14 @@ var FernignoreMigrator = class {
     const results = [];
     for (const pattern of patterns) {
       const matching = allFiles.filter(
-        (f) => minimatch3(f, pattern) || f === pattern || f.startsWith(pattern + "/")
+        (f) => minimatch4(f, pattern) || f === pattern || f.startsWith(pattern + "/")
       );
       results.push({ pattern, files: matching.length > 0 ? matching : [pattern] });
     }
     return results;
   }
   readFileContent(filePath) {
-    const fullPath = join6(this.outputDir, filePath);
+    const fullPath = join7(this.outputDir, filePath);
     if (!existsSync3(fullPath)) {
       return null;
     }
@@ -4311,7 +4498,7 @@ var FernignoreMigrator = class {
     };
   }
   movePatternsToReplayYml(patterns) {
-    const replayYmlPath = join6(this.outputDir, ".fern", "replay.yml");
+    const replayYmlPath = join7(this.outputDir, ".fern", "replay.yml");
     let config = {};
     if (existsSync3(replayYmlPath)) {
       const content = readFileSync3(replayYmlPath, "utf-8");
@@ -4320,7 +4507,7 @@ var FernignoreMigrator = class {
     const existing = config.exclude ?? [];
     const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
     config.exclude = merged;
-    const dir = dirname4(replayYmlPath);
+    const dir = dirname5(replayYmlPath);
     if (!existsSync3(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
@@ -4331,7 +4518,7 @@ var FernignoreMigrator = class {
 // src/commands/bootstrap.ts
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 init_GitClient();
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
@@ -4498,7 +4685,7 @@ function parseGitLog(log) {
 }
 var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = join7(outputDir, ".fernignore");
+  const fernignorePath = join8(outputDir, ".fernignore");
   let content = "";
   if (existsSync4(fernignorePath)) {
     content = readFileSync4(fernignorePath, "utf-8");
@@ -4522,7 +4709,7 @@ function ensureFernignoreEntries(outputDir) {
 }
 var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = join7(outputDir, ".gitattributes");
+  const gitattributesPath = join8(outputDir, ".gitattributes");
   let content = "";
   if (existsSync4(gitattributesPath)) {
     content = readFileSync4(gitattributesPath, "utf-8");
@@ -4552,7 +4739,7 @@ function computeContentHash(patchContent) {
 }
 
 // src/commands/forget.ts
-import { minimatch as minimatch4 } from "minimatch";
+import { minimatch as minimatch5 } from "minimatch";
 function parseDiffStat(patchContent) {
   let additions = 0;
   let deletions = 0;
@@ -4582,7 +4769,7 @@ function toMatchedPatch(patch) {
 }
 function matchesPatch(patch, pattern) {
   const fileMatch = patch.files.some(
-    (file) => file === pattern || minimatch4(file, pattern)
+    (file) => file === pattern || minimatch5(file, pattern)
   );
   if (fileMatch) return true;
   return patch.original_message.toLowerCase().includes(pattern.toLowerCase());
@@ -4721,8 +4908,8 @@ function reset(outputDir, options) {
 
 // src/commands/resolve.ts
 init_GitClient();
-import { readFile as readFile3 } from "fs/promises";
-import { join as join8 } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { join as join9 } from "path";
 async function resolve(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
@@ -4770,7 +4957,7 @@ async function resolve(outputDir, options) {
       const result = await computePerPatchDiffWithFallback(
         patch,
         (f) => git.showFile(currentGen, f),
-        (f) => readFile3(join8(outputDir, f), "utf-8").catch(() => null),
+        (f) => readFile4(join9(outputDir, f), "utf-8").catch(() => null),
         (files) => git.exec(["diff", currentGen, "--", ...files]).catch(() => null)
       );
       if (result === null) {
@@ -4826,7 +5013,7 @@ async function resolve(outputDir, options) {
       const theirsSnapshot = {};
       for (const file of filesForSnapshot) {
         if (isBinaryFile(file)) continue;
-        const content = await readFile3(join8(outputDir, file), "utf-8").catch(() => null);
+        const content = await readFile4(join9(outputDir, file), "utf-8").catch(() => null);
         if (content != null) {
           theirsSnapshot[file] = content;
         }