@fern-api/fern-api-dev 5.27.5 → 5.27.7

package/cli.cjs

@@ -360342,9 +360342,9 @@ var require_diff3 = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/@fern-api+replay@0.15.0/node_modules/@fern-api/replay/dist/index.cjs
+// ../../../node_modules/.pnpm/@fern-api+replay@0.15.2/node_modules/@fern-api/replay/dist/index.cjs
 var require_dist14 = __commonJS({
-  "../../../node_modules/.pnpm/@fern-api+replay@0.15.0/node_modules/@fern-api/replay/dist/index.cjs"(exports2, module4) {
+  "../../../node_modules/.pnpm/@fern-api+replay@0.15.2/node_modules/@fern-api/replay/dist/index.cjs"(exports2, module4) {
     "use strict";
     var __defProp4 = Object.defineProperty;
     var __getOwnPropDesc4 = Object.getOwnPropertyDescriptor;
@@ -360757,24 +360757,24 @@ var require_dist14 = __commonJS({
     async function applyPatchToContent(base4, patchContent, filePath) {
       const fileDiff = extractFileDiff(patchContent, filePath);
       if (!fileDiff) return null;
-      const tempDir2 = await (0, import_promises310.mkdtemp)((0, import_node_path42.join)((0, import_node_os32.tmpdir)(), "replay-migrate-"));
+      const tempDir2 = await (0, import_promises510.mkdtemp)((0, import_node_path72.join)((0, import_node_os32.tmpdir)(), "replay-migrate-"));
       const tempGit = new GitClient(tempDir2);
       try {
         await tempGit.exec(["init"]);
         await tempGit.exec(["config", "user.email", "migrate@fern.com"]);
         await tempGit.exec(["config", "user.name", "Fern Replay Migration"]);
         await tempGit.exec(["config", "commit.gpgSign", "false"]);
-        const tempFilePath = (0, import_node_path42.join)(tempDir2, filePath);
-        await (0, import_promises310.mkdir)((0, import_node_path42.dirname)(tempFilePath), { recursive: true });
-        await (0, import_promises310.writeFile)(tempFilePath, base4);
+        const tempFilePath = (0, import_node_path72.join)(tempDir2, filePath);
+        await (0, import_promises510.mkdir)((0, import_node_path72.dirname)(tempFilePath), { recursive: true });
+        await (0, import_promises510.writeFile)(tempFilePath, base4);
         await tempGit.exec(["add", filePath]);
         await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
         await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-        return await (0, import_promises310.readFile)(tempFilePath, "utf-8");
+        return await (0, import_promises510.readFile)(tempFilePath, "utf-8");
       } catch {
         return null;
       } finally {
-        await (0, import_promises310.rm)(tempDir2, { recursive: true, force: true }).catch(() => {
+        await (0, import_promises510.rm)(tempDir2, { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -360796,15 +360796,15 @@ var require_dist14 = __commonJS({
       }
       return out.length > 0 ? out.join("\n") + "\n" : null;
     }
-    var import_promises310;
+    var import_promises510;
     var import_node_os32;
-    var import_node_path42;
+    var import_node_path72;
     var init_PatchApplyTheirs = __esm3({
       "src/PatchApplyTheirs.ts"() {
         "use strict";
-        import_promises310 = require("fs/promises");
+        import_promises510 = require("fs/promises");
         import_node_os32 = require("os");
-        import_node_path42 = require("path");
+        import_node_path72 = require("path");
         init_GitClient();
       }
     });
@@ -360898,7 +360898,7 @@ var require_dist14 = __commonJS({
       return match3?.[1];
     }
     var import_node_fs32 = require("fs");
-    var import_node_path43 = require("path");
+    var import_node_path42 = require("path");
     var import_yaml18 = require_dist11();
     var LOCKFILE_HEADER = "# DO NOT EDIT MANUALLY - Managed by Fern Replay\n";
     var LockfileNotFoundError = class extends Error {
@@ -360915,10 +360915,10 @@ var require_dist14 = __commonJS({
         this.outputDir = outputDir;
       }
       get lockfilePath() {
-        return (0, import_node_path43.join)(this.outputDir, ".fern", "replay.lock");
+        return (0, import_node_path42.join)(this.outputDir, ".fern", "replay.lock");
       }
       get customizationsPath() {
-        return (0, import_node_path43.join)(this.outputDir, ".fern", "replay.yml");
+        return (0, import_node_path42.join)(this.outputDir, ".fern", "replay.yml");
       }
       exists() {
         return (0, import_node_fs32.existsSync)(this.lockfilePath);
@@ -360990,7 +360990,7 @@ var require_dist14 = __commonJS({
           }
         }
         this.lock.patches = cleanPatches;
-        const dir = (0, import_node_path43.dirname)(this.lockfilePath);
+        const dir = (0, import_node_path42.dirname)(this.lockfilePath);
         if (!(0, import_node_fs32.existsSync)(dir)) {
           (0, import_node_fs32.mkdirSync)(dir, { recursive: true });
         }
@@ -361091,81 +361091,608 @@ var require_dist14 = __commonJS({
       }
     };
     var import_node_crypto7 = require("crypto");
-    var import_promises195 = require("fs/promises");
-    var import_node_os15 = require("os");
     var import_node_path210 = require("path");
-    var import_minimatch8 = require_commonjs3();
-    var CONFLICT_OPENER = "<<<<<<< Generated";
-    var CONFLICT_SEPARATOR = "=======";
-    var CONFLICT_CLOSER = ">>>>>>> Your customization";
-    function trimCR(line) {
-      return line.endsWith("\r") ? line.slice(0, -1) : line;
+    var BINARY_EXTENSIONS2 = /* @__PURE__ */ new Set([
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".bmp",
+      ".ico",
+      ".webp",
+      ".svg",
+      ".pdf",
+      ".doc",
+      ".docx",
+      ".xls",
+      ".xlsx",
+      ".ppt",
+      ".pptx",
+      ".zip",
+      ".gz",
+      ".tar",
+      ".bz2",
+      ".7z",
+      ".rar",
+      ".jar",
+      ".war",
+      ".ear",
+      ".class",
+      ".exe",
+      ".dll",
+      ".so",
+      ".dylib",
+      ".o",
+      ".a",
+      ".woff",
+      ".woff2",
+      ".ttf",
+      ".eot",
+      ".otf",
+      ".mp3",
+      ".mp4",
+      ".avi",
+      ".mov",
+      ".wav",
+      ".flac",
+      ".sqlite",
+      ".db",
+      ".pyc",
+      ".pyo",
+      ".DS_Store"
+    ]);
+    function isBinaryFile(filePath) {
+      const ext2 = (0, import_node_path210.extname)(filePath).toLowerCase();
+      return BINARY_EXTENSIONS2.has(ext2);
     }
-    function findConflictRanges(lines) {
-      const ranges = [];
-      let i9 = 0;
-      while (i9 < lines.length) {
-        if (trimCR(lines[i9]) === CONFLICT_OPENER) {
-          let separatorIdx = -1;
-          let j7 = i9 + 1;
-          let found = false;
-          while (j7 < lines.length) {
-            const trimmed2 = trimCR(lines[j7]);
-            if (trimmed2 === CONFLICT_OPENER) {
-              break;
-            }
-            if (separatorIdx === -1 && trimmed2 === CONFLICT_SEPARATOR) {
-              separatorIdx = j7;
-            } else if (separatorIdx !== -1 && trimmed2 === CONFLICT_CLOSER) {
-              ranges.push({ start: i9, separator: separatorIdx, end: j7 });
-              i9 = j7;
-              found = true;
-              break;
+    var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
+    function parsePatchFileHeaders(patchContent) {
+      const results = [];
+      let currentPath = null;
+      let currentIsCreate = false;
+      let currentIsDelete = false;
+      const flush3 = () => {
+        if (currentPath !== null) {
+          results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
+        }
+      };
+      for (const line of patchContent.split("\n")) {
+        if (line.startsWith("diff --git ")) {
+          flush3();
+          currentPath = null;
+          currentIsCreate = false;
+          currentIsDelete = false;
+          const match3 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+          if (match3) {
+            currentPath = match3[2] ?? null;
+          }
+        } else if (currentPath !== null) {
+          if (line.startsWith("new file mode ")) {
+            currentIsCreate = true;
+          } else if (line.startsWith("deleted file mode ")) {
+            currentIsDelete = true;
+          }
+        }
+      }
+      flush3();
+      return results;
+    }
+    async function capturePatchSnapshot(git, files, treeish) {
+      const snapshot = {};
+      for (const file4 of files) {
+        if (isBinaryFile(file4)) continue;
+        const content5 = await git.showFile(treeish, file4).catch(() => null);
+        if (content5 != null) snapshot[file4] = content5;
+      }
+      return snapshot;
+    }
+    function filterInfrastructureAndSensitiveFiles(rawFilesOutput) {
+      const allFiles = rawFilesOutput.trim().split("\n").filter(Boolean).filter((f4) => !INFRASTRUCTURE_FILES.has(f4)).filter((f4) => !f4.startsWith(".fern/"));
+      const sensitiveFiles = allFiles.filter((f4) => isSensitiveFile(f4));
+      const files = allFiles.filter((f4) => !isSensitiveFile(f4));
+      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 exists2 = await this.git.commitExists(lastGen.commit_sha);
+        if (!exists2) {
+          this.warnings.push(
+            `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
+          );
+          return this.detectPatchesViaTreeDiff(
+            lastGen,
+            /* commitKnownMissing */
+            true
+          );
+        }
+        const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
+        if (!isAncestor) {
+          return this.detectPatchesViaMergeBase(lastGen, lock);
+        }
+        return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
+      }
+      /**
+       * Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+       *
+       * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
+       * `[fern-generated]`) is orphaned but still in git's object database. The
+       * merge-base is the commit on main from which the bot's branch was created —
+       * a reachable ancestor of HEAD. Walking that range and classifying each
+       * commit via `isGenerationCommit` mirrors the linear path and eliminates
+       * the bug class where pipeline-driven changes (autoversion, replay,
+       * generation) get bundled as customer customizations.
+       *
+       * Falls through to the legacy composite path when no common ancestor exists
+       * (truly disjoint history — orphan branches with no shared root).
+       */
+      async detectPatchesViaMergeBase(lastGen, lock) {
+        let mergeBase = "";
+        try {
+          mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
+        } catch {
+        }
+        if (!mergeBase) {
+          this.warnings.push(
+            `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
+          );
+          return this.detectPatchesViaTreeDiff(
+            lastGen,
+            /* commitKnownMissing */
+            false
+          );
+        }
+        return this.detectPatchesInRange(mergeBase, lastGen, lock);
+      }
+      /**
+       * Walk `${rangeStart}..HEAD`, classify each commit, emit one
+       * `StoredPatch` per customer commit. Body shared by the linear path
+       * (rangeStart = lastGen.commit_sha) and the merge-base path.
+       *
+       * Patch `base_generation` is always `lastGen.commit_sha` — the
+       * lockfile-tracked reference the applicator uses to fetch base file
+       * content, regardless of where the walk actually started.
+       */
+      async detectPatchesInRange(rangeStart, lastGen, lock) {
+        const log4 = await this.git.exec([
+          "log",
+          "--no-merges",
+          "--format=%H%x00%an%x00%ae%x00%s",
+          `${rangeStart}..HEAD`,
+          "--",
+          this.sdkOutputDir
+        ]);
+        if (!log4.trim()) {
+          return { patches: [], revertedPatchIds: [] };
+        }
+        const commits = this.parseGitLog(log4);
+        const newPatches = [];
+        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+        for (const commit of commits) {
+          if (isGenerationCommit(commit)) {
+            continue;
+          }
+          if (lock.patches.find((p14) => p14.original_commit === commit.sha)) {
+            continue;
+          }
+          const parents = await this.git.getCommitParents(commit.sha);
+          let patchContent;
+          try {
+            patchContent = await this.git.formatPatch(commit.sha);
+          } catch {
+            this.warnings.push(
+              `Could not generate patch for commit ${commit.sha.slice(0, 7)} \u2014 it may be unreachable in a shallow clone. Skipping.`
+            );
+            continue;
+          }
+          let contentHash = this.computeContentHash(patchContent);
+          if (lock.patches.find((p14) => p14.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 {
+                  patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
+                } catch {
+                  continue;
+                }
+                if (!patchContent.trim()) continue;
+                contentHash = this.computeContentHash(patchContent);
+              }
             }
-            j7++;
           }
-          if (!found) {
-            i9++;
+          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 } : {}
+          });
         }
-        i9++;
+        const survivingPatches = await this.collapseNetZeroFiles(newPatches);
+        survivingPatches.reverse();
+        const revertedPatchIdSet = /* @__PURE__ */ new Set();
+        const revertIndicesToRemove = /* @__PURE__ */ new Set();
+        for (let i9 = 0; i9 < survivingPatches.length; i9++) {
+          const patch5 = survivingPatches[i9];
+          if (!isRevertCommit(patch5.original_message)) continue;
+          let body = "";
+          try {
+            body = await this.git.getCommitBody(patch5.original_commit);
+          } catch {
+          }
+          const revertedSha = parseRevertedSha(body);
+          const revertedMessage = parseRevertedMessage(patch5.original_message);
+          let matchedExisting = false;
+          if (revertedSha) {
+            const existing = lock.patches.find((p14) => p14.original_commit === revertedSha);
+            if (existing) {
+              revertedPatchIdSet.add(existing.id);
+              revertIndicesToRemove.add(i9);
+              matchedExisting = true;
+            }
+          }
+          if (!matchedExisting && revertedMessage) {
+            const existing = lock.patches.find((p14) => p14.original_message === revertedMessage);
+            if (existing) {
+              revertedPatchIdSet.add(existing.id);
+              revertIndicesToRemove.add(i9);
+              matchedExisting = true;
+            }
+          }
+          if (matchedExisting) continue;
+          let matchedNew = false;
+          if (revertedSha) {
+            const idx = survivingPatches.findIndex(
+              (p14, j7) => j7 !== i9 && !revertIndicesToRemove.has(j7) && p14.original_commit === revertedSha
+            );
+            if (idx !== -1) {
+              revertIndicesToRemove.add(i9);
+              revertIndicesToRemove.add(idx);
+              matchedNew = true;
+            }
+          }
+          if (!matchedNew && revertedMessage) {
+            const idx = survivingPatches.findIndex(
+              (p14, j7) => j7 !== i9 && !revertIndicesToRemove.has(j7) && p14.original_message === revertedMessage
+            );
+            if (idx !== -1) {
+              revertIndicesToRemove.add(i9);
+              revertIndicesToRemove.add(idx);
+            }
+          }
+          if (!matchedExisting && !matchedNew) {
+            revertIndicesToRemove.add(i9);
+          }
+        }
+        const filteredPatches = survivingPatches.filter((_7, i9) => !revertIndicesToRemove.has(i9));
+        return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
       }
-      return ranges;
-    }
-    function stripConflictMarkers(content5) {
-      const lines = content5.split(/\r?\n/);
-      const ranges = findConflictRanges(lines);
-      if (ranges.length === 0) {
-        return content5;
+      /**
+       * 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((l9) => l9.startsWith("diff --git "));
+        const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
+        const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
+        return `sha256:${(0, import_node_crypto7.createHash)("sha256").update(normalized).digest("hex")}`;
       }
-      const result = [];
-      let rangeIdx = 0;
-      for (let i9 = 0; i9 < lines.length; i9++) {
-        if (rangeIdx < ranges.length) {
-          const range2 = ranges[rangeIdx];
-          if (i9 === range2.start) {
+      /**
+       * 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: 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 patch5 of patches) {
+          for (const header of parsePatchFileHeaders(patch5.patch_content)) {
+            if (!header.isCreate && !header.isDelete) continue;
+            const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
+            if (header.isCreate) prior.created = true;
+            if (header.isDelete) prior.deleted = true;
+            stateByFile.set(header.path, prior);
+          }
+        }
+        let anyCandidate = false;
+        for (const state of stateByFile.values()) {
+          if (state.created && state.deleted) {
+            anyCandidate = true;
+            break;
+          }
+        }
+        if (!anyCandidate) return patches;
+        const headFiles = await this.listHeadFiles();
+        const transient = /* @__PURE__ */ new Set();
+        for (const [file4, state] of stateByFile) {
+          if (state.created && state.deleted && !headFiles.has(file4)) {
+            transient.add(file4);
+          }
+        }
+        if (transient.size === 0) return patches;
+        return patches.filter((patch5) => !patch5.files.every((f4) => transient.has(f4)));
+      }
+      /**
+       * List every tracked path at HEAD (one `git ls-tree -r` invocation).
+       * Returns an empty Set if HEAD is unborn or the invocation fails — the
+       * caller then treats every candidate as "not in HEAD" and may collapse
+       * more aggressively. On typical SDK repos this is a single sub-10ms call.
+       */
+      async listHeadFiles() {
+        try {
+          const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
+          return new Set(out.split("\n").map((l9) => l9.trim()).filter(Boolean));
+        } catch {
+          return /* @__PURE__ */ new Set();
+        }
+      }
+      /**
+       * 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((g8) => g8.commit_sha));
+        let resolvedBaseGeneration = commitKnownMissing ? diffBase : lastGen.commit_sha;
+        if (commitKnownMissing && !knownGenerations.has(diffBase)) {
+          const fallback2 = lockForGuard.current_generation ?? lockForGuard.generations[lockForGuard.generations.length - 1]?.commit_sha;
+          if (!fallback2) {
+            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: [] };
+          }
+          resolvedBaseGeneration = fallback2;
+        }
+        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 diff2 = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
+        if (!diff2.trim()) return { patches: [], revertedPatchIds: [] };
+        const contentHash = this.computeContentHash(diff2);
+        const lock = this.lockManager.read();
+        if (lock.patches.some((p14) => p14.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: diff2,
+          ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
+          ...this.isCreationOnlyPatch(diff2) ? { 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((g8) => g8.commit_sha));
+        const fallbackAnchor = lock.current_generation ?? lock.generations[lock.generations.length - 1]?.commit_sha;
+        const log4 = await this.git.exec([
+          "log",
+          "--max-count=200",
+          "--format=%H%x00%an%x00%ae%x00%s",
+          "HEAD",
+          "--",
+          this.sdkOutputDir
+        ]);
+        if (!log4.trim()) {
+          return { patches: [], revertedPatchIds: [] };
+        }
+        const commits = this.parseGitLog(log4);
+        const newPatches = [];
+        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
+        const existingHashes = new Set(lock.patches.map((p14) => p14.content_hash));
+        const existingCommits = new Set(lock.patches.map((p14) => p14.original_commit));
+        for (const commit of commits) {
+          if (isGenerationCommit(commit)) {
             continue;
           }
-          if (i9 > range2.start && i9 < range2.separator) {
-            result.push(lines[i9]);
+          const parents = await this.git.getCommitParents(commit.sha);
+          if (parents.length > 1) {
             continue;
           }
-          if (i9 === range2.separator) {
+          if (existingCommits.has(commit.sha)) {
             continue;
           }
-          if (i9 > range2.separator && i9 < range2.end) {
+          let patchContent;
+          try {
+            patchContent = await this.git.formatPatch(commit.sha);
+          } catch {
             continue;
           }
-          if (i9 === range2.end) {
-            rangeIdx++;
+          let contentHash = this.computeContentHash(patchContent);
+          if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
+            continue;
+          }
+          if (this.isCreationOnlyPatch(patchContent)) {
+            continue;
+          }
+          const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
+          const { 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 {
+                patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
+              } catch {
+                continue;
+              }
+              if (!patchContent.trim()) continue;
+              contentHash = this.computeContentHash(patchContent);
+            }
+          }
+          if (files.length === 0) {
             continue;
           }
+          if (parents.length === 0) {
+            continue;
+          }
+          const parentSha = parents[0];
+          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;
+          }
+          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 } : {}
+          });
         }
-        result.push(lines[i9]);
+        newPatches.reverse();
+        return { patches: newPatches, revertedPatchIds: [] };
       }
-      return result.join("\n");
-    }
+      /**
+       * 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((l9) => l9.startsWith("--- "));
+        if (diffOldHeaders.length === 0) {
+          return false;
+        }
+        return diffOldHeaders.every((l9) => l9 === "--- /dev/null");
+      }
+      /**
+       * Resolve the best available diff base for a generation record.
+       * Prefers commit_sha, falls back to tree_hash for unreachable commits.
+       * When commitKnownMissing is true, skips the redundant commitExists check.
+       */
+      async resolveDiffBase(gen, commitKnownMissing) {
+        if (!commitKnownMissing && await this.git.commitExists(gen.commit_sha)) {
+          return gen.commit_sha;
+        }
+        if (await this.git.treeExists(gen.tree_hash)) {
+          return gen.tree_hash;
+        }
+        return null;
+      }
+      parseGitLog(log4) {
+        return log4.trim().split("\n").map((line) => {
+          const [sha, authorName, authorEmail, message] = line.split("\0");
+          return { sha, authorName, authorEmail, message };
+        });
+      }
+      getLastGeneration(lock) {
+        return lock.generations.find((g8) => g8.commit_sha === lock.current_generation);
+      }
+    };
     var import_node_diff3 = require_diff3();
     function threeWayMerge(base4, ours, theirs) {
       const baseLines = base4.split("\n");
@@ -361303,95 +361830,414 @@ var require_dist14 = __commonJS({
       }
       return result;
     }
-    var BINARY_EXTENSIONS2 = /* @__PURE__ */ new Set([
-      ".png",
-      ".jpg",
-      ".jpeg",
-      ".gif",
-      ".bmp",
-      ".ico",
-      ".webp",
-      ".svg",
-      ".pdf",
-      ".doc",
-      ".docx",
-      ".xls",
-      ".xlsx",
-      ".ppt",
-      ".pptx",
-      ".zip",
-      ".gz",
-      ".tar",
-      ".bz2",
-      ".7z",
-      ".rar",
-      ".jar",
-      ".war",
-      ".ear",
-      ".class",
-      ".exe",
-      ".dll",
-      ".so",
-      ".dylib",
-      ".o",
-      ".a",
-      ".woff",
-      ".woff2",
-      ".ttf",
-      ".eot",
-      ".otf",
-      ".mp3",
-      ".mp4",
-      ".avi",
-      ".mov",
-      ".wav",
-      ".flac",
-      ".sqlite",
-      ".db",
-      ".pyc",
-      ".pyo",
-      ".DS_Store"
-    ]);
+    var import_promises310 = require("fs/promises");
+    var import_node_os15 = require("os");
+    var import_node_path52 = require("path");
+    var import_minimatch8 = require_commonjs3();
+    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(path111) {
+        return this.sharedFiles.has(path111);
+      }
+      /** Has any prior patch already recorded a result for this path? */
+      has(path111) {
+        return this.entries.has(path111);
+      }
+      /** Look up the accumulated content + base generation for this path. */
+      lookup(path111) {
+        return this.entries.get(path111);
+      }
+      /**
+       * 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.
+       */
+      shouldSkipFastPath(patch5) {
+        return patch5.files.some((f4) => this.entries.has(f4));
+      }
+      /** Record a successful (clean) merge result. */
+      recordMerge(path111, content5, baseGeneration) {
+        this.entries.set(path111, { content: content5, 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(path111, content5, baseGeneration) {
+        if (this.mode === "resolve") {
+          this.entries.set(path111, { content: content5, baseGeneration });
+        }
+      }
+      /**
+       * 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 [path111, entry] of this.entries) {
+          copy.set(path111, { content: entry.content, baseGeneration: entry.baseGeneration });
+        }
+        return copy;
+      }
+    };
+    var import_promises195 = require("fs/promises");
+    var import_node_path310 = require("path");
+    async function resolveInputs(args) {
+      const {
+        patch: patch5,
+        filePath,
+        git,
+        lockManager,
+        outputDir,
+        isTreeReachable,
+        resolveBaseGeneration,
+        resolveFilePath,
+        extractRenameSource,
+        extractFileDiff: extractFileDiff2
+      } = args;
+      const baseGen = await resolveBaseGeneration(patch5.base_generation);
+      if (!baseGen) {
+        return {
+          resolvedPath: filePath,
+          metadata: {
+            patchId: patch5.id,
+            patchMessage: patch5.original_message,
+            baseGeneration: patch5.base_generation,
+            currentGeneration: lockManager.read().current_generation
+          },
+          base: null,
+          ours: null,
+          oursPath: (0, import_node_path310.join)(outputDir, filePath),
+          renameSourcePath: void 0,
+          ghostTheirs: null,
+          earlyExit: { status: "skipped", reason: "base-generation-not-found" }
+        };
+      }
+      const lock = lockManager.read();
+      const currentGen = lock.generations.find((g8) => g8.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: patch5.id,
+        patchMessage: patch5.original_message,
+        baseGeneration: patch5.base_generation,
+        currentGeneration: lock.current_generation
+      };
+      let base4 = await git.showFile(baseGen.tree_hash, filePath);
+      let renameSourcePath;
+      if (!base4) {
+        const renameSource = extractRenameSource(patch5.patch_content, filePath);
+        if (renameSource) {
+          base4 = await git.showFile(baseGen.tree_hash, renameSource);
+          renameSourcePath = renameSource;
+        }
+      }
+      const oursPath = (0, import_node_path310.join)(outputDir, resolvedPath);
+      const ours = await (0, import_promises195.readFile)(oursPath, "utf-8").catch(() => null);
+      let ghostTheirs = null;
+      if (!base4 && ours && !renameSourcePath) {
+        const treeReachable = await isTreeReachable(baseGen.tree_hash);
+        if (!treeReachable) {
+          const fileDiff = extractFileDiff2(patch5.patch_content, filePath);
+          if (fileDiff) {
+            const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
+            const result = reconstructFromGhostPatch2(fileDiff, ours);
+            if (result) {
+              base4 = result.base;
+              ghostTheirs = result.theirs;
+            }
+          }
+        }
+      }
+      return {
+        resolvedPath,
+        metadata,
+        base: base4,
+        ours,
+        oursPath,
+        renameSourcePath,
+        ghostTheirs
+      };
+    }
+    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 i9 = 0;
+      while (i9 < lines.length) {
+        if (trimCR(lines[i9]) === CONFLICT_OPENER) {
+          let separatorIdx = -1;
+          let j7 = i9 + 1;
+          let found = false;
+          while (j7 < lines.length) {
+            const trimmed2 = trimCR(lines[j7]);
+            if (trimmed2 === CONFLICT_OPENER) {
+              break;
+            }
+            if (separatorIdx === -1 && trimmed2 === CONFLICT_SEPARATOR) {
+              separatorIdx = j7;
+            } else if (separatorIdx !== -1 && trimmed2 === CONFLICT_CLOSER) {
+              ranges.push({ start: i9, separator: separatorIdx, end: j7 });
+              i9 = j7;
+              found = true;
+              break;
+            }
+            j7++;
+          }
+          if (!found) {
+            i9++;
+            continue;
+          }
+        }
+        i9++;
+      }
+      return ranges;
+    }
+    function stripConflictMarkers(content5) {
+      const lines = content5.split(/\r?\n/);
+      const ranges = findConflictRanges(lines);
+      if (ranges.length === 0) {
+        return content5;
+      }
+      const result = [];
+      let rangeIdx = 0;
+      for (let i9 = 0; i9 < lines.length; i9++) {
+        if (rangeIdx < ranges.length) {
+          const range2 = ranges[rangeIdx];
+          if (i9 === range2.start) {
+            continue;
+          }
+          if (i9 > range2.start && i9 < range2.separator) {
+            result.push(lines[i9]);
+            continue;
+          }
+          if (i9 === range2.separator) {
+            continue;
+          }
+          if (i9 > range2.separator && i9 < range2.end) {
+            continue;
+          }
+          if (i9 === range2.end) {
+            rangeIdx++;
+            continue;
+          }
+        }
+        result.push(lines[i9]);
+      }
+      return result.join("\n");
+    }
+    function hasConflictMarkerStrings(content5) {
+      if (content5 == null) return false;
+      return content5.includes(CONFLICT_OPENER) || content5.includes(CONFLICT_CLOSER);
+    }
+    async function buildMergePlan(args) {
+      const {
+        inputs,
+        patch: patch5,
+        filePath,
+        accumulator,
+        tempGit,
+        tempDir: tempDir2,
+        applyPatchToContent: applyPatchToContent2,
+        isPatchAlreadyApplied
+      } = args;
+      const { base: base4, ours, resolvedPath, renameSourcePath, ghostTheirs } = inputs;
+      let theirs = ghostTheirs;
+      const ghostReconstructed = ghostTheirs != null;
+      const snapshotForFile = patch5.theirs_snapshot?.[resolvedPath] ?? patch5.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(
+            base4,
+            patch5.patch_content,
+            filePath,
+            tempGit,
+            tempDir2,
+            renameSourcePath
+          );
+          const reconstructionHasMarkers = hasConflictMarkerStrings(theirs);
+          const baseHadMarkers = hasConflictMarkerStrings(base4);
+          if (reconstructionHasMarkers && !baseHadMarkers && snapshotForFile != null) {
+            theirs = snapshotForFile;
+          }
+        }
+      }
+      const accumulatorEntry = accumulator.lookup(resolvedPath);
+      if (theirs) {
+        const theirsHasMarkers = hasConflictMarkerStrings(theirs);
+        const baseHasMarkers = hasConflictMarkerStrings(base4);
+        if (theirsHasMarkers && !baseHasMarkers) {
+          if (accumulatorEntry) {
+            theirs = null;
+          } else {
+            return { kind: "skipped", reason: "stale-conflict-markers" };
+          }
+        }
+      }
+      let useAccumulatorAsMergeBase = false;
+      if (accumulatorEntry && (theirs == null || base4 == null)) {
+        theirs = await applyPatchToContent2(
+          accumulatorEntry.content,
+          patch5.patch_content,
+          filePath,
+          tempGit,
+          tempDir2
+        );
+        if (theirs != null) {
+          useAccumulatorAsMergeBase = true;
+        } else if (await isPatchAlreadyApplied(
+          patch5.patch_content,
+          filePath,
+          accumulatorEntry.content,
+          tempGit,
+          tempDir2
+        )) {
+          theirs = accumulatorEntry.content;
+          useAccumulatorAsMergeBase = true;
+        }
+      }
+      if (theirs) {
+        const theirsHasMarkers = hasConflictMarkerStrings(theirs);
+        const accBaseHasMarkers = accumulatorEntry != null && hasConflictMarkerStrings(accumulatorEntry.content);
+        if (theirsHasMarkers && !accBaseHasMarkers && !hasConflictMarkerStrings(base4)) {
+          return { kind: "skipped", reason: "stale-conflict-markers" };
+        }
+      }
+      let effective_theirs = theirs;
+      let conflictReasonHint;
+      if (theirs != null && base4 != null && !useAccumulatorAsMergeBase) {
+        if (accumulatorEntry && accumulatorEntry.baseGeneration === patch5.base_generation) {
+          try {
+            const preMerged = threeWayMerge(base4, 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 (base4 == null && ours == null && effective_theirs != null) {
+        return { kind: "new-file-only-user", theirs: effective_theirs };
+      }
+      if (base4 == 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 (base4 == null && !useAccumulatorAsMergeBase || ours == null) {
+        return { kind: "skipped", reason: "missing-content" };
+      }
+      if (useAccumulatorAsMergeBase) {
+        const mergeBase = accumulatorEntry?.content ?? base4;
+        if (mergeBase == null) {
+          return { kind: "skipped", reason: "missing-content" };
+        }
+        return {
+          kind: "accumulator-base",
+          theirs: effective_theirs,
+          mergeBase,
+          conflictReasonHint
+        };
+      }
+      return {
+        kind: primarySource,
+        base: base4,
+        theirs: effective_theirs,
+        mergeBase: base4,
+        conflictReasonHint
+      };
+    }
+    var import_promises210 = require("fs/promises");
+    var import_node_path43 = require("path");
+    async function runMergeAndRecord(args) {
+      const { plan, inputs, patch: patch5, 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, patch5.base_generation);
+        await (0, import_promises210.mkdir)((0, import_node_path43.dirname)(oursPath), { recursive: true });
+        await (0, import_promises210.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 (0, import_promises210.mkdir)((0, import_node_path43.dirname)(oursPath), { recursive: true });
+        await (0, import_promises210.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, patch5.base_generation);
+        return { file: resolvedPath, status: "merged" };
+      }
+      const merged = threeWayMerge(plan.mergeBase, ours, plan.theirs);
+      await (0, import_promises210.mkdir)((0, import_node_path43.dirname)(oursPath), { recursive: true });
+      await (0, import_promises210.writeFile)(oursPath, merged.content);
+      if (merged.hasConflicts) {
+        accumulator.recordConflict(resolvedPath, plan.theirs, patch5.base_generation);
+        return {
+          file: resolvedPath,
+          status: "conflict",
+          conflicts: merged.conflicts,
+          conflictReason: plan.conflictReasonHint ?? "same-line-edit",
+          conflictMetadata: metadata
+        };
+      }
+      accumulator.recordMerge(resolvedPath, plan.theirs, patch5.base_generation);
+      return {
+        file: resolvedPath,
+        status: "merged",
+        ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
+      };
+    }
     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.
+      /**
+       * 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.
        *
-       * 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();
+       * 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;
@@ -361418,23 +362264,15 @@ var require_dist14 = __commonJS({
           return void 0;
         }
       }
-      /** Reset inter-patch accumulator for a new cycle. */
-      resetAccumulator() {
-        this.fileTheirsAccumulator.clear();
-      }
       /**
        * @internal Test-only.
-       * Returns a defensive copy of the inter-patch accumulator. Used by the
-       * adversarial test suite (FER-9791) to assert invariant I2: after every
-       * applied patch, the accumulator has an entry for each file the patch
-       * touched, and the entry's content matches on-disk.
+       * 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() {
-        const snapshot = /* @__PURE__ */ new Map();
-        for (const [path111, entry] of this.fileTheirsAccumulator) {
-          snapshot.set(path111, { content: entry.content, baseGeneration: entry.baseGeneration });
-        }
-        return snapshot;
+        return this.accumulator.snapshot();
       }
       /**
        * Apply all patches, returning results for each.
@@ -361455,17 +362293,16 @@ var require_dist14 = __commonJS({
        */
       async applyPatches(patches, opts) {
         const applyMode = opts?.applyMode ?? "replay";
-        this.currentApplyMode = applyMode;
-        this.resetAccumulator();
         const fileFreq = /* @__PURE__ */ new Map();
         for (const p14 of patches) {
           for (const f4 of p14.files) {
             fileFreq.set(f4, (fileFreq.get(f4) ?? 0) + 1);
           }
         }
-        this.sharedFiles = new Set(
+        const sharedFiles = new Set(
           Array.from(fileFreq.entries()).filter(([, n19]) => n19 > 1).map(([f4]) => f4)
         );
+        this.accumulator = new MergeAccumulator(applyMode, sharedFiles);
         const results = [];
         for (let i9 = 0; i9 < patches.length; i9++) {
           const patch5 = patches[i9];
@@ -361496,11 +362333,11 @@ var require_dist14 = __commonJS({
               if (fileResult.status !== "conflict") continue;
               const originalPath = resolvedToOriginal.get(fileResult.file) ?? fileResult.file;
               if (laterFiles.has(fileResult.file) || laterFiles.has(originalPath)) {
-                const filePath = (0, import_node_path210.join)(this.outputDir, fileResult.file);
+                const filePath = (0, import_node_path52.join)(this.outputDir, fileResult.file);
                 try {
-                  const content5 = await (0, import_promises195.readFile)(filePath, "utf-8");
+                  const content5 = await (0, import_promises310.readFile)(filePath, "utf-8");
                   const stripped = stripConflictMarkers(content5);
-                  await (0, import_promises195.writeFile)(filePath, stripped);
+                  await (0, import_promises310.writeFile)(filePath, stripped);
                 } catch {
                 }
               }
@@ -361520,7 +362357,7 @@ var require_dist14 = __commonJS({
       async populateAccumulatorForPatch(patch5, baseGen, currentTreeHash) {
         const fileResults = [];
         if (!baseGen) return fileResults;
-        const tempDir2 = await (0, import_promises195.mkdtemp)((0, import_node_path210.join)((0, import_node_os15.tmpdir)(), "replay-acc-"));
+        const tempDir2 = await (0, import_promises310.mkdtemp)((0, import_node_path52.join)((0, import_node_os15.tmpdir)(), "replay-acc-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir2);
         await tempGit.exec(["init"]);
@@ -361532,15 +362369,12 @@ var require_dist14 = __commonJS({
             const resolvedPath = await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash);
             const base4 = await this.git.showFile(baseGen.tree_hash, filePath);
             const snapshotForFile = patch5.theirs_snapshot?.[resolvedPath] ?? patch5.theirs_snapshot?.[filePath];
-            const fileIsShared = this.sharedFiles.has(resolvedPath) || this.sharedFiles.has(filePath);
+            const fileIsShared = this.accumulator.isShared(resolvedPath) || this.accumulator.isShared(filePath);
             const theirs = !fileIsShared && snapshotForFile != null ? snapshotForFile : await this.applyPatchToContent(base4, patch5.patch_content, filePath, tempGit, tempDir2);
-            const finalOnDisk = await (0, import_promises195.readFile)((0, import_node_path210.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
+            const finalOnDisk = await (0, import_promises310.readFile)((0, import_node_path52.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
             const effectiveTheirs = theirs ?? finalOnDisk;
             if (effectiveTheirs != null) {
-              this.fileTheirsAccumulator.set(resolvedPath, {
-                content: effectiveTheirs,
-                baseGeneration: patch5.base_generation
-              });
+              this.accumulator.recordMerge(resolvedPath, effectiveTheirs, patch5.base_generation);
             }
             if (base4 != null && effectiveTheirs != null && finalOnDisk != null) {
               const dropped = computeDroppedContextLinesForFile(base4, effectiveTheirs, finalOnDisk);
@@ -361554,7 +362388,7 @@ var require_dist14 = __commonJS({
             }
           }
         } finally {
-          await (0, import_promises195.rm)(tempDir2, { recursive: true }).catch(() => {
+          await (0, import_promises310.rm)(tempDir2, { recursive: true }).catch(() => {
           });
         }
         return fileResults;
@@ -361568,7 +362402,7 @@ var require_dist14 = __commonJS({
           patch5.files.map(async (f4) => {
             if (!baseGen) return false;
             const resolved = await this.resolveFilePath(f4, baseGen.tree_hash, currentTreeHash);
-            return this.fileTheirsAccumulator.has(resolved);
+            return this.accumulator.has(resolved);
           })
         ).then((results) => results.some(Boolean));
         const resolvedFiles = {};
@@ -361583,8 +362417,8 @@ var require_dist14 = __commonJS({
         if (!needsAccumulation && !hasGeneratorRename) {
           const snapshots = /* @__PURE__ */ new Map();
           for (const filePath of patch5.files) {
-            const fullPath = (0, import_node_path210.join)(this.outputDir, filePath);
-            snapshots.set(filePath, await (0, import_promises195.readFile)(fullPath, "utf-8").catch(() => null));
+            const fullPath = (0, import_node_path52.join)(this.outputDir, filePath);
+            snapshots.set(filePath, await (0, import_promises310.readFile)(fullPath, "utf-8").catch(() => null));
           }
           try {
             await this.git.execWithInput(["apply", "--3way"], patch5.patch_content);
@@ -361598,11 +362432,11 @@ var require_dist14 = __commonJS({
             };
           } catch {
             for (const [filePath, content5] of snapshots) {
-              const fullPath = (0, import_node_path210.join)(this.outputDir, filePath);
+              const fullPath = (0, import_node_path52.join)(this.outputDir, filePath);
               if (content5 != null) {
-                await (0, import_promises195.writeFile)(fullPath, content5);
+                await (0, import_promises310.writeFile)(fullPath, content5);
               } else {
-                await (0, import_promises195.unlink)(fullPath).catch(() => {
+                await (0, import_promises310.unlink)(fullPath).catch(() => {
                 });
               }
             }
@@ -361613,7 +362447,7 @@ var require_dist14 = __commonJS({
       async applyWithThreeWayMerge(patch5) {
         const fileResults = [];
         const resolvedFiles = {};
-        const tempDir2 = await (0, import_promises195.mkdtemp)((0, import_node_path210.join)((0, import_node_os15.tmpdir)(), "replay-"));
+        const tempDir2 = await (0, import_promises310.mkdtemp)((0, import_node_path52.join)((0, import_node_os15.tmpdir)(), "replay-"));
         const { GitClient: GitClient2 } = await Promise.resolve().then(() => (init_GitClient(), GitClient_exports));
         const tempGit = new GitClient2(tempDir2);
         await tempGit.exec(["init"]);
@@ -361636,7 +362470,7 @@ var require_dist14 = __commonJS({
             fileResults.push(result);
           }
         } finally {
-          await (0, import_promises195.rm)(tempDir2, { recursive: true }).catch(() => {
+          await (0, import_promises310.rm)(tempDir2, { recursive: true }).catch(() => {
           });
         }
         const conflictFiles = fileResults.filter((r5) => r5.status === "conflict");
@@ -361653,214 +362487,37 @@ var require_dist14 = __commonJS({
       }
       async mergeFile(patch5, filePath, tempGit, tempDir2) {
         try {
-          const baseGen = await this.resolveBaseGeneration(patch5.base_generation);
-          if (!baseGen) {
-            return { file: filePath, status: "skipped", reason: "base-generation-not-found" };
-          }
-          const lock = this.lockManager.read();
-          const currentGen = lock.generations.find((g8) => g8.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: patch5.id,
-            patchMessage: patch5.original_message,
-            baseGeneration: patch5.base_generation,
-            currentGeneration: lock.current_generation
-          };
-          let base4 = await this.git.showFile(baseGen.tree_hash, filePath);
-          let renameSourcePath;
-          if (!base4) {
-            const renameSource = this.extractRenameSource(patch5.patch_content, filePath);
-            if (renameSource) {
-              base4 = await this.git.showFile(baseGen.tree_hash, renameSource);
-              renameSourcePath = renameSource;
-            }
-          }
-          const oursPath = (0, import_node_path210.join)(this.outputDir, resolvedPath);
-          const ours = await (0, import_promises195.readFile)(oursPath, "utf-8").catch(() => null);
-          let ghostReconstructed = false;
-          let theirs = null;
-          if (!base4 && ours && !renameSourcePath) {
-            const treeReachable = await this.isTreeReachable(baseGen.tree_hash);
-            if (!treeReachable) {
-              const fileDiff = this.extractFileDiff(patch5.patch_content, filePath);
-              if (fileDiff) {
-                const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
-                const result = reconstructFromGhostPatch2(fileDiff, ours);
-                if (result) {
-                  base4 = result.base;
-                  theirs = result.theirs;
-                  ghostReconstructed = true;
-                }
-              }
-            }
-          }
-          const snapshotForFile = patch5.theirs_snapshot?.[resolvedPath] ?? patch5.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(
-                base4,
-                patch5.patch_content,
-                filePath,
-                tempGit,
-                tempDir2,
-                renameSourcePath
-              );
-              const reconstructionHasMarkers = theirs != null && (theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization"));
-              const baseHadMarkers = base4 != null && (base4.includes("<<<<<<< Generated") || base4.includes(">>>>>>> Your customization"));
-              if (reconstructionHasMarkers && !baseHadMarkers && snapshotForFile != null) {
-                theirs = snapshotForFile;
-              }
-            }
-          }
-          const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-          if (theirs) {
-            const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
-            const baseHasMarkers = base4 != null && (base4.includes("<<<<<<< Generated") || base4.includes(">>>>>>> Your customization"));
-            if (theirsHasMarkers && !baseHasMarkers) {
-              if (accumulatorEntry) {
-                theirs = null;
-              } else {
-                return {
-                  file: resolvedPath,
-                  status: "skipped",
-                  reason: "stale-conflict-markers"
-                };
-              }
-            }
-          }
-          let useAccumulatorAsMergeBase = false;
-          if (accumulatorEntry && (theirs == null || base4 == null)) {
-            theirs = await this.applyPatchToContent(
-              accumulatorEntry.content,
-              patch5.patch_content,
-              filePath,
-              tempGit,
-              tempDir2
-            );
-            if (theirs != null) {
-              useAccumulatorAsMergeBase = true;
-            } else if (await this.isPatchAlreadyApplied(
-              patch5.patch_content,
-              filePath,
-              accumulatorEntry.content,
-              tempGit,
-              tempDir2
-            )) {
-              theirs = accumulatorEntry.content;
-              useAccumulatorAsMergeBase = true;
-            }
-          }
-          if (theirs) {
-            const theirsHasMarkers = theirs.includes("<<<<<<< Generated") || theirs.includes(">>>>>>> Your customization");
-            const accBaseHasMarkers = accumulatorEntry != null && (accumulatorEntry.content.includes("<<<<<<< Generated") || accumulatorEntry.content.includes(">>>>>>> Your customization"));
-            if (theirsHasMarkers && !accBaseHasMarkers && !(base4 != null && (base4.includes("<<<<<<< Generated") || base4.includes(">>>>>>> Your customization")))) {
-              return {
-                file: resolvedPath,
-                status: "skipped",
-                reason: "stale-conflict-markers"
-              };
-            }
-          }
-          let effective_theirs = theirs;
-          let baseMismatchSkipped = false;
-          if (theirs != null && base4 != null && !useAccumulatorAsMergeBase) {
-            if (accumulatorEntry && accumulatorEntry.baseGeneration === patch5.base_generation) {
-              try {
-                const preMerged = threeWayMerge(base4, accumulatorEntry.content, theirs);
-                if (!preMerged.hasConflicts) {
-                  effective_theirs = preMerged.content;
-                } else {
-                  effective_theirs = theirs;
-                }
-              } catch {
-                effective_theirs = theirs;
-              }
-            } else if (accumulatorEntry) {
-              baseMismatchSkipped = true;
-            }
-          }
-          if (base4 == null && ours == null && effective_theirs != null) {
-            this.fileTheirsAccumulator.set(resolvedPath, {
-              content: effective_theirs,
-              baseGeneration: patch5.base_generation
-            });
-            const outDir2 = (0, import_node_path210.dirname)(oursPath);
-            await (0, import_promises195.mkdir)(outDir2, { recursive: true });
-            await (0, import_promises195.writeFile)(oursPath, effective_theirs);
-            return { file: resolvedPath, status: "merged", reason: "new-file" };
-          }
-          if (base4 == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
-            const merged2 = threeWayMerge("", ours, effective_theirs);
-            const outDir2 = (0, import_node_path210.dirname)(oursPath);
-            await (0, import_promises195.mkdir)(outDir2, { recursive: true });
-            await (0, import_promises195.writeFile)(oursPath, merged2.content);
-            if (merged2.hasConflicts) {
-              return {
-                file: resolvedPath,
-                status: "conflict",
-                conflicts: merged2.conflicts,
-                conflictReason: "new-file-both",
-                conflictMetadata: metadata
-              };
-            }
-            this.fileTheirsAccumulator.set(resolvedPath, {
-              content: merged2.content,
-              baseGeneration: patch5.base_generation
-            });
-            return { file: resolvedPath, status: "merged" };
-          }
-          if (effective_theirs == null) {
-            return {
-              file: resolvedPath,
-              status: "skipped",
-              reason: "missing-content"
-            };
-          }
-          if (base4 == null && !useAccumulatorAsMergeBase || ours == null) {
-            return {
-              file: resolvedPath,
-              status: "skipped",
-              reason: "missing-content"
-            };
-          }
-          const mergeBase = useAccumulatorAsMergeBase && accumulatorEntry ? accumulatorEntry.content : base4;
-          if (mergeBase == null) {
-            return {
-              file: resolvedPath,
-              status: "skipped",
-              reason: "missing-content"
-            };
-          }
-          const merged = threeWayMerge(mergeBase, ours, effective_theirs);
-          const outDir = (0, import_node_path210.dirname)(oursPath);
-          await (0, import_promises195.mkdir)(outDir, { recursive: true });
-          await (0, import_promises195.writeFile)(oursPath, merged.content);
-          const populateAccumulator = effective_theirs != null && (!merged.hasConflicts || this.currentApplyMode === "resolve");
-          if (populateAccumulator) {
-            this.fileTheirsAccumulator.set(resolvedPath, {
-              content: effective_theirs,
-              baseGeneration: patch5.base_generation
-            });
-          }
-          if (merged.hasConflicts) {
-            return {
-              file: resolvedPath,
-              status: "conflict",
-              conflicts: merged.conflicts,
-              conflictReason: baseMismatchSkipped ? "base-generation-mismatch" : "same-line-edit",
-              conflictMetadata: metadata
-            };
-          }
-          return {
-            file: resolvedPath,
-            status: "merged",
-            ...merged.droppedContextLines && merged.droppedContextLines.length > 0 ? { droppedContextLines: merged.droppedContextLines } : {}
-          };
+          const inputs = await resolveInputs({
+            patch: patch5,
+            filePath,
+            git: this.git,
+            lockManager: this.lockManager,
+            outputDir: this.outputDir,
+            isTreeReachable: (h5) => this.isTreeReachable(h5),
+            resolveBaseGeneration: (s9) => this.resolveBaseGeneration(s9),
+            resolveFilePath: (f4, b8, c6) => this.resolveFilePath(f4, b8, c6),
+            extractRenameSource: (p14, f4) => this.extractRenameSource(p14, f4),
+            extractFileDiff: (p14, f4) => this.extractFileDiff(p14, f4)
+          });
+          if (inputs.earlyExit) {
+            return { file: filePath, ...inputs.earlyExit };
+          }
+          const plan = await buildMergePlan({
+            inputs,
+            patch: patch5,
+            filePath,
+            accumulator: this.accumulator,
+            tempGit,
+            tempDir: tempDir2,
+            applyPatchToContent: (b8, p14, f4, g8, d5, s9) => this.applyPatchToContent(b8, p14, f4, g8, d5, s9),
+            isPatchAlreadyApplied: (p14, f4, c6, g8, d5) => this.isPatchAlreadyApplied(p14, f4, c6, g8, d5)
+          });
+          return await runMergeAndRecord({
+            plan,
+            inputs,
+            patch: patch5,
+            accumulator: this.accumulator
+          });
         } catch (error50) {
           return {
             file: filePath,
@@ -361918,9 +362575,9 @@ var require_dist14 = __commonJS({
         if (!fileDiff) return null;
         try {
           if (sourceFilePath) {
-            const tempSourcePath = (0, import_node_path210.join)(tempDir2, sourceFilePath);
-            await (0, import_promises195.mkdir)((0, import_node_path210.dirname)(tempSourcePath), { recursive: true });
-            await (0, import_promises195.writeFile)(tempSourcePath, base4);
+            const tempSourcePath = (0, import_node_path52.join)(tempDir2, sourceFilePath);
+            await (0, import_promises310.mkdir)((0, import_node_path52.dirname)(tempSourcePath), { recursive: true });
+            await (0, import_promises310.writeFile)(tempSourcePath, base4);
             await tempGit.exec(["add", sourceFilePath]);
             await tempGit.exec([
               "commit",
@@ -361929,16 +362586,16 @@ var require_dist14 = __commonJS({
               "--allow-empty"
             ]);
             await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-            const tempTargetPath = (0, import_node_path210.join)(tempDir2, filePath);
-            return await (0, import_promises195.readFile)(tempTargetPath, "utf-8");
+            const tempTargetPath = (0, import_node_path52.join)(tempDir2, filePath);
+            return await (0, import_promises310.readFile)(tempTargetPath, "utf-8");
           }
-          const tempFilePath = (0, import_node_path210.join)(tempDir2, filePath);
-          await (0, import_promises195.mkdir)((0, import_node_path210.dirname)(tempFilePath), { recursive: true });
-          await (0, import_promises195.writeFile)(tempFilePath, base4);
+          const tempFilePath = (0, import_node_path52.join)(tempDir2, filePath);
+          await (0, import_promises310.mkdir)((0, import_node_path52.dirname)(tempFilePath), { recursive: true });
+          await (0, import_promises310.writeFile)(tempFilePath, base4);
           await tempGit.exec(["add", filePath]);
           await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
           await tempGit.execWithInput(["apply", "--allow-empty"], fileDiff);
-          return await (0, import_promises195.readFile)(tempFilePath, "utf-8");
+          return await (0, import_promises310.readFile)(tempFilePath, "utf-8");
         } catch {
           return null;
         }
@@ -361954,9 +362611,9 @@ var require_dist14 = __commonJS({
         const fileDiff = this.extractFileDiff(patchContent, filePath);
         if (!fileDiff) return false;
         try {
-          const tempFilePath = (0, import_node_path210.join)(tempDir2, filePath);
-          await (0, import_promises195.mkdir)((0, import_node_path210.dirname)(tempFilePath), { recursive: true });
-          await (0, import_promises195.writeFile)(tempFilePath, content5);
+          const tempFilePath = (0, import_node_path52.join)(tempDir2, filePath);
+          await (0, import_promises310.mkdir)((0, import_node_path52.dirname)(tempFilePath), { recursive: true });
+          await (0, import_promises310.writeFile)(tempFilePath, content5);
           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);
@@ -362042,10 +362699,6 @@ var require_dist14 = __commonJS({
         return addedLines.join("\n") + (noTrailingNewline ? "" : "\n");
       }
     };
-    function isBinaryFile(filePath) {
-      const ext2 = (0, import_node_path210.extname)(filePath).toLowerCase();
-      return BINARY_EXTENSIONS2.has(ext2);
-    }
     function computeDroppedContextLinesForFile(base4, theirs, finalContent) {
       const baseLines = base4.split("\n");
       const theirsLines = theirs.split("\n");
@@ -362074,600 +362727,6 @@ var require_dist14 = __commonJS({
       const match3 = diffLine.match(/^diff --git a\/.+ b\/(.+)$/);
       return match3 !== null && match3[1] === filePath;
     }
-    var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
-    function parsePatchFileHeaders(patchContent) {
-      const results = [];
-      let currentPath = null;
-      let currentIsCreate = false;
-      let currentIsDelete = false;
-      const flush3 = () => {
-        if (currentPath !== null) {
-          results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
-        }
-      };
-      for (const line of patchContent.split("\n")) {
-        if (line.startsWith("diff --git ")) {
-          flush3();
-          currentPath = null;
-          currentIsCreate = false;
-          currentIsDelete = false;
-          const match3 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
-          if (match3) {
-            currentPath = match3[2] ?? null;
-          }
-        } else if (currentPath !== null) {
-          if (line.startsWith("new file mode ")) {
-            currentIsCreate = true;
-          } else if (line.startsWith("deleted file mode ")) {
-            currentIsDelete = true;
-          }
-        }
-      }
-      flush3();
-      return results;
-    }
-    var ReplayDetector = class {
-      git;
-      lockManager;
-      sdkOutputDir;
-      warnings = [];
-      constructor(git, lockManager, sdkOutputDir) {
-        this.git = git;
-        this.lockManager = lockManager;
-        this.sdkOutputDir = sdkOutputDir;
-      }
-      async detectNewPatches() {
-        const lock = this.lockManager.read();
-        const lastGen = this.getLastGeneration(lock);
-        if (!lastGen) {
-          return { patches: [], revertedPatchIds: [] };
-        }
-        const exists2 = await this.git.commitExists(lastGen.commit_sha);
-        if (!exists2) {
-          this.warnings.push(
-            `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
-          );
-          return this.detectPatchesViaTreeDiff(
-            lastGen,
-            /* commitKnownMissing */
-            true
-          );
-        }
-        const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
-        if (!isAncestor) {
-          return this.detectPatchesViaMergeBase(lastGen, lock);
-        }
-        return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
-      }
-      /**
-       * FER-10201 — Non-linear-history detection via `merge-base(prevGen, HEAD)`.
-       *
-       * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
-       * `[fern-generated]`) is orphaned but still in git's object database. The
-       * merge-base is the commit on main from which the bot's branch was created —
-       * a reachable ancestor of HEAD. Walking that range and classifying each
-       * commit via `isGenerationCommit` mirrors the linear path and eliminates
-       * the bug class where pipeline-driven changes (autoversion, replay,
-       * generation) get bundled as customer customizations.
-       *
-       * Falls through to the legacy composite path when no common ancestor exists
-       * (truly disjoint history — orphan branches with no shared root).
-       */
-      async detectPatchesViaMergeBase(lastGen, lock) {
-        let mergeBase = "";
-        try {
-          mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
-        } catch {
-        }
-        if (!mergeBase) {
-          this.warnings.push(
-            `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
-          );
-          return this.detectPatchesViaTreeDiff(
-            lastGen,
-            /* commitKnownMissing */
-            false
-          );
-        }
-        return this.detectPatchesInRange(mergeBase, lastGen, lock);
-      }
-      /**
-       * FER-10201 — Walk `${rangeStart}..HEAD`, classify each commit, emit one
-       * `StoredPatch` per customer commit. Body shared by the linear path
-       * (rangeStart = lastGen.commit_sha) and the merge-base path.
-       *
-       * Patch `base_generation` is always `lastGen.commit_sha` — the
-       * lockfile-tracked reference the applicator uses to fetch base file
-       * content, regardless of where the walk actually started.
-       */
-      async detectPatchesInRange(rangeStart, lastGen, lock) {
-        const log4 = await this.git.exec([
-          "log",
-          "--first-parent",
-          "--format=%H%x00%an%x00%ae%x00%s",
-          `${rangeStart}..HEAD`,
-          "--",
-          this.sdkOutputDir
-        ]);
-        if (!log4.trim()) {
-          return { patches: [], revertedPatchIds: [] };
-        }
-        const commits = this.parseGitLog(log4);
-        const newPatches = [];
-        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
-        for (const commit of commits) {
-          if (isGenerationCommit(commit)) {
-            continue;
-          }
-          if (lock.patches.find((p14) => p14.original_commit === commit.sha)) {
-            continue;
-          }
-          const parents = await this.git.getCommitParents(commit.sha);
-          if (parents.length > 1) {
-            const compositePatch = await this.createMergeCompositePatch({
-              mergeCommit: commit,
-              firstParent: parents[0],
-              lastGen,
-              lock
-            });
-            if (compositePatch) {
-              newPatches.push(compositePatch);
-            }
-            continue;
-          }
-          let patchContent;
-          try {
-            patchContent = await this.git.formatPatch(commit.sha);
-          } catch {
-            this.warnings.push(
-              `Could not generate patch for commit ${commit.sha.slice(0, 7)} \u2014 it may be unreachable in a shallow clone. Skipping.`
-            );
-            continue;
-          }
-          let contentHash = this.computeContentHash(patchContent);
-          if (lock.patches.find((p14) => p14.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((f4) => !INFRASTRUCTURE_FILES.has(f4)).filter((f4) => !f4.startsWith(".fern/"));
-          const sensitiveFiles = allFiles.filter((f4) => isSensitiveFile(f4));
-          const files = allFiles.filter((f4) => !isSensitiveFile(f4));
-          if (sensitiveFiles.length > 0) {
-            this.warnings.push(
-              `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
-            );
-            if (files.length > 0) {
-              const parentSha = parents[0];
-              if (parentSha) {
-                try {
-                  patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
-                } catch {
-                  continue;
-                }
-                if (!patchContent.trim()) continue;
-                contentHash = this.computeContentHash(patchContent);
-              }
-            }
-          }
-          if (files.length === 0) {
-            continue;
-          }
-          const theirsSnapshot = {};
-          for (const file4 of files) {
-            if (isBinaryFile(file4)) continue;
-            const content5 = await this.git.showFile(commit.sha, file4).catch(() => null);
-            if (content5 != null) theirsSnapshot[file4] = content5;
-          }
-          newPatches.push({
-            id: `patch-${commit.sha.slice(0, 8)}`,
-            content_hash: contentHash,
-            original_commit: commit.sha,
-            original_message: commit.message,
-            original_author: `${commit.authorName} <${commit.authorEmail}>`,
-            base_generation: lastGen.commit_sha,
-            files,
-            patch_content: patchContent,
-            ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
-            ...this.isCreationOnlyPatch(patchContent) ? { user_owned: true } : {}
-          });
-        }
-        const survivingPatches = await this.collapseNetZeroFiles(newPatches);
-        survivingPatches.reverse();
-        const revertedPatchIdSet = /* @__PURE__ */ new Set();
-        const revertIndicesToRemove = /* @__PURE__ */ new Set();
-        for (let i9 = 0; i9 < survivingPatches.length; i9++) {
-          const patch5 = survivingPatches[i9];
-          if (!isRevertCommit(patch5.original_message)) continue;
-          let body = "";
-          try {
-            body = await this.git.getCommitBody(patch5.original_commit);
-          } catch {
-          }
-          const revertedSha = parseRevertedSha(body);
-          const revertedMessage = parseRevertedMessage(patch5.original_message);
-          let matchedExisting = false;
-          if (revertedSha) {
-            const existing = lock.patches.find((p14) => p14.original_commit === revertedSha);
-            if (existing) {
-              revertedPatchIdSet.add(existing.id);
-              revertIndicesToRemove.add(i9);
-              matchedExisting = true;
-            }
-          }
-          if (!matchedExisting && revertedMessage) {
-            const existing = lock.patches.find((p14) => p14.original_message === revertedMessage);
-            if (existing) {
-              revertedPatchIdSet.add(existing.id);
-              revertIndicesToRemove.add(i9);
-              matchedExisting = true;
-            }
-          }
-          if (matchedExisting) continue;
-          let matchedNew = false;
-          if (revertedSha) {
-            const idx = survivingPatches.findIndex(
-              (p14, j7) => j7 !== i9 && !revertIndicesToRemove.has(j7) && p14.original_commit === revertedSha
-            );
-            if (idx !== -1) {
-              revertIndicesToRemove.add(i9);
-              revertIndicesToRemove.add(idx);
-              matchedNew = true;
-            }
-          }
-          if (!matchedNew && revertedMessage) {
-            const idx = survivingPatches.findIndex(
-              (p14, j7) => j7 !== i9 && !revertIndicesToRemove.has(j7) && p14.original_message === revertedMessage
-            );
-            if (idx !== -1) {
-              revertIndicesToRemove.add(i9);
-              revertIndicesToRemove.add(idx);
-            }
-          }
-          if (!matchedExisting && !matchedNew) {
-            revertIndicesToRemove.add(i9);
-          }
-        }
-        const filteredPatches = survivingPatches.filter((_7, i9) => !revertIndicesToRemove.has(i9));
-        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((l9) => l9.startsWith("diff --git "));
-        const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
-        const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
-        return `sha256:${(0, import_node_crypto7.createHash)("sha256").update(normalized).digest("hex")}`;
-      }
-      /**
-       * FER-9805 — Drop patches whose files were transiently created and then
-       * deleted within the current linear detection window, and are absent from
-       * HEAD at the end of the window.
-       *
-       * Rationale: on a merge commit, createMergeCompositePatch already diffs
-       * firstParent..mergeCommit so net-zero files never enter the composite. On
-       * linear history each commit becomes its own patch, so a file that was
-       * briefly added and later removed survives as a create+delete pair whose
-       * cumulative diff is empty. We drop such patches before they reach the
-       * lockfile.
-       *
-       * A file is "transient" when:
-       *   1. some patch in the window sets `new file mode` for it (a creation), AND
-       *   2. some patch in the window sets `deleted file mode` for it (a deletion), AND
-       *   3. it is absent from HEAD's tree.
-       *
-       * The HEAD guard (#3) prevents false positives when a file is deleted
-       * and then recreated with different content — the cumulative diff of
-       * such a pair is non-empty and must be preserved.
-       *
-       * This only drops patches whose `files` are a subset of the transient
-       * set. A partial-transient patch (one that touches a transient file
-       * alongside a persistent one) is left unmodified; surgical stripping of
-       * single files from a multi-file patch would require a follow-up that
-       * regenerates the patch content via `git format-patch -- <files>`. No
-       * current failing test exercises this, and leaving the patch intact
-       * preserves today's behaviour. TODO(FER-9805): revisit if a future
-       * adversarial test demands per-file stripping.
-       */
-      async collapseNetZeroFiles(patches) {
-        if (patches.length === 0) return patches;
-        const stateByFile = /* @__PURE__ */ new Map();
-        for (const patch5 of patches) {
-          for (const header of parsePatchFileHeaders(patch5.patch_content)) {
-            if (!header.isCreate && !header.isDelete) continue;
-            const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
-            if (header.isCreate) prior.created = true;
-            if (header.isDelete) prior.deleted = true;
-            stateByFile.set(header.path, prior);
-          }
-        }
-        let anyCandidate = false;
-        for (const state of stateByFile.values()) {
-          if (state.created && state.deleted) {
-            anyCandidate = true;
-            break;
-          }
-        }
-        if (!anyCandidate) return patches;
-        const headFiles = await this.listHeadFiles();
-        const transient = /* @__PURE__ */ new Set();
-        for (const [file4, state] of stateByFile) {
-          if (state.created && state.deleted && !headFiles.has(file4)) {
-            transient.add(file4);
-          }
-        }
-        if (transient.size === 0) return patches;
-        return patches.filter((patch5) => !patch5.files.every((f4) => transient.has(f4)));
-      }
-      /**
-       * List every tracked path at HEAD (one `git ls-tree -r` invocation).
-       * Returns an empty Set if HEAD is unborn or the invocation fails — the
-       * caller then treats every candidate as "not in HEAD" and may collapse
-       * more aggressively. On typical SDK repos this is a single sub-10ms call.
-       */
-      async listHeadFiles() {
-        try {
-          const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
-          return new Set(out.split("\n").map((l9) => l9.trim()).filter(Boolean));
-        } catch {
-          return /* @__PURE__ */ new Set();
-        }
-      }
-      /**
-       * Create a single composite patch for a merge commit by diffing the merge
-       * commit against its first parent. This captures the net change of the
-       * entire merged branch as one patch, eliminating accumulator chaining and
-       * zero-net-change ghost conflicts.
-       */
-      async createMergeCompositePatch(input3) {
-        const { mergeCommit, firstParent, lastGen, lock } = input3;
-        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((f4) => !INFRASTRUCTURE_FILES.has(f4)).filter((f4) => !f4.startsWith(".fern/"));
-        const sensitiveMergeFiles = allMergeFiles.filter((f4) => isSensitiveFile(f4));
-        const files = allMergeFiles.filter((f4) => !isSensitiveFile(f4));
-        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 diff2 = await this.git.exec([
-          "diff",
-          firstParent,
-          mergeCommit.sha,
-          "--",
-          ...files
-        ]);
-        if (!diff2.trim()) return null;
-        const contentHash = this.computeContentHash(diff2);
-        if (lock.patches.some((p14) => p14.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
-          return null;
-        }
-        const theirsSnapshot = {};
-        for (const file4 of files) {
-          if (isBinaryFile(file4)) continue;
-          const content5 = await this.git.showFile(mergeCommit.sha, file4).catch(() => null);
-          if (content5 != null) theirsSnapshot[file4] = content5;
-        }
-        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: diff2,
-          ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
-          ...this.isCreationOnlyPatch(diff2) ? { user_owned: true } : {}
-        };
-      }
-      /**
-       * Detect patches via tree diff for non-linear history. Returns a composite patch.
-       * Revert reconciliation is skipped here because tree-diff produces a single composite
-       * patch from the aggregate diff — individual revert commits are not distinguishable.
-       */
-      async detectPatchesViaTreeDiff(lastGen, commitKnownMissing) {
-        const diffBase = await this.resolveDiffBase(lastGen, commitKnownMissing);
-        if (!diffBase) {
-          return this.detectPatchesViaCommitScan();
-        }
-        const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
-        const allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f4) => !INFRASTRUCTURE_FILES.has(f4)).filter((f4) => !f4.startsWith(".fern/"));
-        const sensitiveTreeFiles = allTreeFiles.filter((f4) => isSensitiveFile(f4));
-        const files = allTreeFiles.filter((f4) => !isSensitiveFile(f4));
-        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 diff2 = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
-        if (!diff2.trim()) return { patches: [], revertedPatchIds: [] };
-        const contentHash = this.computeContentHash(diff2);
-        const lock = this.lockManager.read();
-        if (lock.patches.some((p14) => p14.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 file4 of files) {
-          if (isBinaryFile(file4)) continue;
-          const content5 = await this.git.showFile("HEAD", file4).catch(() => null);
-          if (content5 != null) theirsSnapshot[file4] = content5;
-        }
-        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: diff2,
-          ...Object.keys(theirsSnapshot).length > 0 ? { theirs_snapshot: theirsSnapshot } : {},
-          ...this.isCreationOnlyPatch(diff2) ? { 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 log4 = await this.git.exec([
-          "log",
-          "--max-count=200",
-          "--format=%H%x00%an%x00%ae%x00%s",
-          "HEAD",
-          "--",
-          this.sdkOutputDir
-        ]);
-        if (!log4.trim()) {
-          return { patches: [], revertedPatchIds: [] };
-        }
-        const commits = this.parseGitLog(log4);
-        const newPatches = [];
-        const forgottenHashes = new Set(lock.forgotten_hashes ?? []);
-        const existingHashes = new Set(lock.patches.map((p14) => p14.content_hash));
-        const existingCommits = new Set(lock.patches.map((p14) => p14.original_commit));
-        for (const commit of commits) {
-          if (isGenerationCommit(commit)) {
-            continue;
-          }
-          const parents = await this.git.getCommitParents(commit.sha);
-          if (parents.length > 1) {
-            continue;
-          }
-          if (existingCommits.has(commit.sha)) {
-            continue;
-          }
-          let patchContent;
-          try {
-            patchContent = await this.git.formatPatch(commit.sha);
-          } catch {
-            continue;
-          }
-          let contentHash = this.computeContentHash(patchContent);
-          if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
-            continue;
-          }
-          if (this.isCreationOnlyPatch(patchContent)) {
-            continue;
-          }
-          const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-          const allScanFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f4) => !INFRASTRUCTURE_FILES.has(f4));
-          const sensitiveScanFiles = allScanFiles.filter((f4) => isSensitiveFile(f4));
-          const files = allScanFiles.filter((f4) => !isSensitiveFile(f4));
-          if (sensitiveScanFiles.length > 0) {
-            this.warnings.push(
-              `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveScanFiles.join(", ")}. These files will not be tracked by replay.`
-            );
-            if (files.length > 0) {
-              if (parents.length === 0) {
-                continue;
-              }
-              try {
-                patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
-              } catch {
-                continue;
-              }
-              if (!patchContent.trim()) continue;
-              contentHash = this.computeContentHash(patchContent);
-            }
-          }
-          if (files.length === 0) {
-            continue;
-          }
-          if (parents.length === 0) {
-            continue;
-          }
-          const parentSha = parents[0];
-          const theirsSnapshot = {};
-          for (const file4 of files) {
-            if (isBinaryFile(file4)) continue;
-            const content5 = await this.git.showFile(commit.sha, file4).catch(() => null);
-            if (content5 != null) theirsSnapshot[file4] = content5;
-          }
-          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((l9) => l9.startsWith("--- "));
-        if (diffOldHeaders.length === 0) {
-          return false;
-        }
-        return diffOldHeaders.every((l9) => l9 === "--- /dev/null");
-      }
-      /**
-       * Resolve the best available diff base for a generation record.
-       * Prefers commit_sha, falls back to tree_hash for unreachable commits.
-       * When commitKnownMissing is true, skips the redundant commitExists check.
-       */
-      async resolveDiffBase(gen, commitKnownMissing) {
-        if (!commitKnownMissing && await this.git.commitExists(gen.commit_sha)) {
-          return gen.commit_sha;
-        }
-        if (await this.git.treeExists(gen.tree_hash)) {
-          return gen.tree_hash;
-        }
-        return null;
-      }
-      parseGitLog(log4) {
-        return log4.trim().split("\n").map((line) => {
-          const [sha, authorName, authorEmail, message] = line.split("\0");
-          return { sha, authorName, authorEmail, message };
-        });
-      }
-      getLastGeneration(lock) {
-        return lock.generations.find((g8) => g8.commit_sha === lock.current_generation);
-      }
-    };
     var ReplayCommitter = class {
       git;
       outputDir;
@@ -362770,13 +362829,13 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
       }
     };
     var import_node_fs210 = require("fs");
-    var import_promises410 = require("fs/promises");
-    var import_node_path52 = require("path");
-    var import_minimatch22 = require_commonjs3();
+    var import_promises610 = require("fs/promises");
+    var import_node_path82 = require("path");
+    var import_minimatch32 = require_commonjs3();
     init_GitClient();
-    var import_promises210 = require("fs/promises");
+    var import_promises410 = require("fs/promises");
     var import_node_os22 = require("os");
-    var import_node_path310 = require("path");
+    var import_node_path62 = require("path");
     var import_node_child_process8 = require("child_process");
     init_HybridReconstruction();
     function normalizeHunkBody(hunk) {
@@ -362983,17 +363042,17 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
     }
     async function unifiedDiff(beforeContent, afterContent, filePath) {
       if (beforeContent === afterContent) return "";
-      const tmp18 = await (0, import_promises210.mkdtemp)((0, import_node_path310.join)((0, import_node_os22.tmpdir)(), "fern-replay-pp-"));
+      const tmp18 = await (0, import_promises410.mkdtemp)((0, import_node_path62.join)((0, import_node_os22.tmpdir)(), "fern-replay-pp-"));
       try {
-        const beforePath = (0, import_node_path310.join)(tmp18, "before");
-        const afterPath = (0, import_node_path310.join)(tmp18, "after");
-        await (0, import_promises210.writeFile)(beforePath, beforeContent, "utf-8");
-        await (0, import_promises210.writeFile)(afterPath, afterContent, "utf-8");
+        const beforePath = (0, import_node_path62.join)(tmp18, "before");
+        const afterPath = (0, import_node_path62.join)(tmp18, "after");
+        await (0, import_promises410.writeFile)(beforePath, beforeContent, "utf-8");
+        await (0, import_promises410.writeFile)(afterPath, afterContent, "utf-8");
         const raw = await runGitDiffNoIndex(beforePath, afterPath);
         if (!raw.trim()) return "";
         return rewriteDiffHeaders(raw, filePath);
       } finally {
-        await (0, import_promises210.rm)(tmp18, { recursive: true, force: true });
+        await (0, import_promises410.rm)(tmp18, { recursive: true, force: true });
       }
     }
     function runGitDiffNoIndex(beforePath, afterPath) {
@@ -363064,27 +363123,513 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
       const trailer = hasTrailingNewline ? "" : "\n\";
       return header + "\n" + body + trailer + "\n";
     }
+    var import_minimatch22 = require_commonjs3();
+    var FileOwnership = class {
+      constructor(git) {
+        this.git = git;
+      }
+      /**
+       * Canonical resolution. Returns true if `file` is user-owned per:
+       *
+       *   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 resolveCanonical(ctx) {
+        const { file: file4, originalFileName, patch: patch5, currentGenSha, fernignorePatterns, warnedGens, warnings } = ctx;
+        if (patch5.user_owned) return true;
+        if (file4 === ".fernignore") return true;
+        if (fernignorePatterns.some((p14) => file4 === p14 || (0, import_minimatch22.minimatch)(file4, p14))) return true;
+        if (fileIsCreationInPatchContent(patch5.patch_content, originalFileName ?? file4)) {
+          return true;
+        }
+        const base4 = patch5.base_generation;
+        if (base4 && base4 !== currentGenSha) {
+          const reachable = await this.git.commitExists(base4) || await this.git.treeExists(base4);
+          if (!reachable) {
+            if (!warnedGens.has(base4)) {
+              warnedGens.add(base4);
+              warnings.push(
+                `Base generation ${base4.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(base4, originalFileName ?? file4) === null;
+        }
+        return await this.git.showFile(currentGenSha, originalFileName ?? file4) === null;
+      }
+    };
+    function fileIsCreationInPatchContent(patchContent, file4) {
+      const lines = patchContent.split("\n");
+      let inFileSection = false;
+      for (const line of lines) {
+        if (line.startsWith("diff --git ")) {
+          inFileSection = line.includes(` b/${file4}`) || line.endsWith(` b/${file4}`);
+          continue;
+        }
+        if (inFileSection && line.startsWith("--- ")) {
+          return line === "--- /dev/null";
+        }
+      }
+      return false;
+    }
+    var FirstGenerationFlow = class {
+      constructor(service) {
+        this.service = service;
+      }
+      async prepare(options2) {
+        if (options2?.dryRun) {
+          const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s9) => s9.trim()).catch(() => "");
+          return {
+            flow: "first-generation",
+            previousGenerationSha: null,
+            currentGenerationSha: headSha,
+            baseBranchHead: options2.baseBranchHead ?? null,
+            _prepared: {
+              kind: "terminal",
+              flow: "first-generation",
+              preparedReport: firstGenerationReport()
+            }
+          };
+        }
+        const commitOpts = options2 ? {
+          cliVersion: options2.cliVersion ?? "unknown",
+          generatorVersions: options2.generatorVersions ?? {},
+          baseBranchHead: options2.baseBranchHead
+        } : void 0;
+        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: options2?.baseBranchHead ?? null,
+          _prepared: {
+            kind: "active",
+            flow: "first-generation",
+            patchesToApply: [],
+            newPatchIds: /* @__PURE__ */ new Set(),
+            detectorWarnings: [],
+            revertedCount: 0,
+            genSha: genRecord.commit_sha,
+            optionsSnapshot: options2
+          }
+        };
+      }
+      async apply(_prep) {
+        this.service.lockManager.save();
+        return firstGenerationReport();
+      }
+    };
+    function firstGenerationReport() {
+      return {
+        flow: "first-generation",
+        patchesDetected: 0,
+        patchesApplied: 0,
+        patchesWithConflicts: 0,
+        patchesSkipped: 0,
+        conflicts: []
+      };
+    }
+    var SkipApplicationFlow = class {
+      constructor(service) {
+        this.service = service;
+      }
+      async prepare(options2) {
+        const commitOpts = options2 ? {
+          cliVersion: options2.cliVersion ?? "unknown",
+          generatorVersions: options2.generatorVersions ?? {},
+          baseBranchHead: options2.baseBranchHead
+        } : void 0;
+        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.service.lockManager.read();
+          previousGenerationSha = lock.current_generation ?? null;
+          this.service.lockManager.addGeneration(genRecord);
+        } catch (error50) {
+          if (error50 instanceof LockfileNotFoundError) {
+            this.service.lockManager.initializeInMemory(genRecord);
+          } else {
+            throw error50;
+          }
+        }
+        this.service.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
+        return {
+          flow: "skip-application",
+          previousGenerationSha,
+          currentGenerationSha: genRecord.commit_sha,
+          baseBranchHead: options2?.baseBranchHead ?? null,
+          _prepared: {
+            kind: "active",
+            flow: "skip-application",
+            patchesToApply: [],
+            newPatchIds: /* @__PURE__ */ new Set(),
+            detectorWarnings: [],
+            revertedCount: 0,
+            genSha: genRecord.commit_sha,
+            optionsSnapshot: options2
+          }
+        };
+      }
+      async apply(_prep, options2) {
+        this.service.lockManager.save();
+        const credentialWarnings = [...this.service.lockManager.warnings];
+        if (!options2?.stageOnly) {
+          await this.service.committer.commitReplay(0);
+        } else {
+          await this.service.committer.stageAll();
+        }
+        return {
+          flow: "skip-application",
+          patchesDetected: 0,
+          patchesApplied: 0,
+          patchesWithConflicts: 0,
+          patchesSkipped: 0,
+          conflicts: [],
+          warnings: credentialWarnings.length > 0 ? credentialWarnings : void 0
+        };
+      }
+    };
+    var NoPatchesFlow = class {
+      constructor(service) {
+        this.service = service;
+      }
+      async prepare(options2) {
+        const preLock = this.service.lockManager.read();
+        const previousGenerationSha = preLock.current_generation ?? null;
+        let { patches: newPatches, revertedPatchIds } = await this.service.detector.detectNewPatches();
+        const detectorWarnings = [...this.service.detector.warnings];
+        if (options2?.dryRun) {
+          const dryRunWarnings = [...detectorWarnings, ...this.service.warnings];
+          const preparedReport = {
+            flow: "no-patches",
+            patchesDetected: newPatches.length,
+            patchesApplied: 0,
+            patchesWithConflicts: 0,
+            patchesSkipped: 0,
+            patchesReverted: revertedPatchIds.length,
+            conflicts: [],
+            wouldApply: newPatches,
+            warnings: dryRunWarnings.length > 0 ? dryRunWarnings : void 0
+          };
+          const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s9) => s9.trim()).catch(() => "");
+          return {
+            flow: "no-patches",
+            previousGenerationSha,
+            currentGenerationSha: headSha,
+            baseBranchHead: options2.baseBranchHead ?? null,
+            _prepared: {
+              kind: "terminal",
+              flow: "no-patches",
+              preparedReport
+            }
+          };
+        }
+        {
+          const preCurrentGen = preLock.current_generation;
+          const uniqueFiles = [...new Set(newPatches.flatMap((p14) => p14.files))];
+          const absorbedFiles = /* @__PURE__ */ new Set();
+          for (const file4 of uniqueFiles) {
+            const diff2 = await this.service.git.exec(["diff", preCurrentGen, "HEAD", "--", file4]).catch(() => null);
+            if (diff2 !== null && !diff2.trim()) {
+              absorbedFiles.add(file4);
+            }
+          }
+          if (absorbedFiles.size > 0) {
+            newPatches = newPatches.filter(
+              (p14) => p14.files.length === 0 || !p14.files.every((f4) => absorbedFiles.has(f4))
+            );
+          }
+        }
+        for (const id2 of revertedPatchIds) {
+          try {
+            this.service.lockManager.removePatch(id2);
+          } catch {
+          }
+        }
+        const commitOpts = options2 ? {
+          cliVersion: options2.cliVersion ?? "unknown",
+          generatorVersions: options2.generatorVersions ?? {},
+          baseBranchHead: options2.baseBranchHead
+        } : void 0;
+        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: options2?.baseBranchHead ?? null,
+          _prepared: {
+            kind: "active",
+            flow: "no-patches",
+            patchesToApply: newPatches,
+            newPatchIds: new Set(newPatches.map((p14) => p14.id)),
+            detectorWarnings,
+            revertedCount: revertedPatchIds.length,
+            genSha: genRecord.commit_sha,
+            optionsSnapshot: options2
+          }
+        };
+      }
+      async apply(prep, options2) {
+        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.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.service.rebasePatches(results, genSha);
+        for (const patch5 of newPatches) {
+          if (!rebaseCounts.absorbedPatchIds.has(patch5.id)) {
+            this.service.lockManager.addPatch(patch5);
+          }
+        }
+        this.service.lockManager.save();
+        this.service.warnings.push(...this.service.lockManager.warnings);
+        if (newPatches.length > 0) {
+          if (!options2?.stageOnly) {
+            const appliedCount = results.filter((r5) => r5.status === "applied").length;
+            const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, newPatches);
+            await this.service.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
+          } else {
+            await this.service.committer.stageAll();
+          }
+        }
+        const warnings = [...detectorWarnings, ...this.service.warnings];
+        return this.service.buildReport(
+          "no-patches",
+          newPatches,
+          results,
+          prep._prepared.optionsSnapshot,
+          warnings,
+          rebaseCounts,
+          void 0,
+          prep._prepared.revertedCount
+        );
+      }
+    };
+    var NormalRegenerationFlow = class {
+      constructor(service) {
+        this.service = service;
+      }
+      async prepare(options2) {
+        const preLock = this.service.lockManager.read();
+        const previousGenerationSha = preLock.current_generation ?? null;
+        if (options2?.dryRun) {
+          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",
+            patchesDetected: allPatches2.length,
+            patchesApplied: 0,
+            patchesWithConflicts: 0,
+            patchesSkipped: 0,
+            patchesReverted: dryRunReverted.length,
+            conflicts: [],
+            wouldApply: allPatches2,
+            warnings: warnings.length > 0 ? warnings : void 0
+          };
+          const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s9) => s9.trim()).catch(() => "");
+          return {
+            flow: "normal-regeneration",
+            previousGenerationSha,
+            currentGenerationSha: headSha,
+            baseBranchHead: options2.baseBranchHead ?? null,
+            _prepared: {
+              kind: "terminal",
+              flow: "normal-regeneration",
+              preparedReport
+            }
+          };
+        }
+        let existingPatches = this.service.lockManager.getPatches();
+        const preRebasePatchIds = new Set(existingPatches.map((p14) => p14.id));
+        const preRebaseCounts = await this.service.preGenerationRebase(existingPatches);
+        const postRebasePatchIds = new Set(this.service.lockManager.getPatches().map((p14) => p14.id));
+        const removedByPreRebase = existingPatches.filter(
+          (p14) => preRebasePatchIds.has(p14.id) && !postRebasePatchIds.has(p14.id)
+        );
+        existingPatches = this.service.lockManager.getPatches();
+        const seenHashes = /* @__PURE__ */ new Map();
+        for (const p14 of existingPatches) {
+          const priorPatchId = seenHashes.get(p14.content_hash);
+          if (priorPatchId !== void 0) {
+            this.service.lockManager.removePatch(p14.id);
+            this.service.warnings.push(
+              `Consolidated patch ${p14.id} (commit ${(p14.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(p14.content_hash, p14.id);
+          }
+        }
+        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((p14) => p14.original_commit));
+          const removedOriginalMessages = new Set(removedByPreRebase.map((p14) => p14.original_message));
+          newPatches = newPatches.filter((p14) => {
+            if (removedOriginalCommits.has(p14.original_commit)) return false;
+            if (isRevertCommit(p14.original_message)) {
+              const revertedMsg = parseRevertedMessage(p14.original_message);
+              if (revertedMsg && removedOriginalMessages.has(revertedMsg)) return false;
+            }
+            return true;
+          });
+        }
+        for (const id2 of revertedPatchIds) {
+          try {
+            this.service.lockManager.removePatch(id2);
+          } catch {
+          }
+        }
+        const revertedSet = new Set(revertedPatchIds);
+        existingPatches = existingPatches.filter((p14) => !revertedSet.has(p14.id));
+        const allPatches = [...existingPatches, ...newPatches];
+        const commitOpts = options2 ? {
+          cliVersion: options2.cliVersion ?? "unknown",
+          generatorVersions: options2.generatorVersions ?? {},
+          baseBranchHead: options2.baseBranchHead
+        } : void 0;
+        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: options2?.baseBranchHead ?? null,
+          _prepared: {
+            kind: "active",
+            flow: "normal-regeneration",
+            patchesToApply: allPatches,
+            newPatchIds: new Set(newPatches.map((p14) => p14.id)),
+            preRebaseCounts,
+            detectorWarnings,
+            revertedCount: revertedPatchIds.length,
+            genSha: genRecord.commit_sha,
+            optionsSnapshot: options2
+          }
+        };
+      }
+      async apply(prep, options2) {
+        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.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.service.rebasePatches(results, genSha);
+        const newPatches = allPatches.filter((p14) => newPatchIds.has(p14.id));
+        for (const patch5 of newPatches) {
+          if (!rebaseCounts.absorbedPatchIds.has(patch5.id)) {
+            this.service.lockManager.addPatch(patch5);
+          }
+        }
+        for (const result of results) {
+          if (result.status === "conflict") {
+            try {
+              this.service.lockManager.markPatchUnresolved(result.patch.id);
+            } catch {
+            }
+          }
+        }
+        this.service.lockManager.save();
+        this.service.warnings.push(...this.service.lockManager.warnings);
+        if (options2?.stageOnly) {
+          await this.service.committer.stageAll();
+        } else {
+          const appliedCount = results.filter((r5) => r5.status === "applied").length;
+          const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, allPatches);
+          await this.service.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
+        }
+        const warnings = [...detectorWarnings, ...this.service.warnings];
+        return this.service.buildReport(
+          "normal-regeneration",
+          allPatches,
+          results,
+          prep._prepared.optionsSnapshot,
+          warnings,
+          rebaseCounts,
+          prep._prepared.preRebaseCounts,
+          prep._prepared.revertedCount
+        );
+      }
+    };
+    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 `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()`.
+       * 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 (FER-9791, I2).
+       * to inspect the inter-patch accumulator after runReplay() completes (invariant I2).
        */
       get applicatorRef() {
         return this.applicator;
@@ -363092,8 +363637,8 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
       /**
        * @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.
+       * 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;
@@ -363106,6 +363651,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         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),
@@ -363122,18 +363668,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
       async prepareReplay(options2) {
         this.warnings = [];
         this.detector.warnings.length = 0;
-        if (options2?.skipApplication) {
-          return this._prepareSkipApplication(options2);
-        }
-        const flow4 = this.determineFlow();
-        switch (flow4) {
-          case "first-generation":
-            return this._prepareFirstGeneration(options2);
-          case "no-patches":
-            return this._prepareNoPatchesRegeneration(options2);
-          case "normal-regeneration":
-            return this._prepareNormalRegeneration(options2);
-        }
+        return this.selectFlow(options2).prepare(options2);
       }
       /**
        * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
@@ -363145,18 +363680,33 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
        * its own post-commit logic), this returns the precomputed report.
        */
       async applyPreparedReplay(prep, options2) {
-        if (prep._prepared.terminal) {
+        if (prep._prepared.kind === "terminal") {
           return prep._prepared.preparedReport;
         }
-        switch (prep._prepared.flow) {
+        return this.flowForKind(prep._prepared.flow).apply(prep, options2);
+      }
+      /**
+       * Construct the flow for the current run. `selectFlow` is called from
+       * `prepareReplay` and decides based on options + lockfile state.
+       */
+      selectFlow(options2) {
+        if (options2?.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 this._applyFirstGeneration(prep);
-          case "skip-application":
-            return this._applySkipApplication(prep, options2);
+            return new FirstGenerationFlow(this);
           case "no-patches":
-            return this._applyNoPatchesRegeneration(prep, options2);
+            return new NoPatchesFlow(this);
           case "normal-regeneration":
-            return this._applyNormalRegeneration(prep, options2);
+            return new NormalRegenerationFlow(this);
+          case "skip-application":
+            return new SkipApplicationFlow(this);
         }
       }
       /**
@@ -363240,423 +363790,12 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           throw error50;
         }
       }
-      firstGenerationReport() {
-        return {
-          flow: "first-generation",
-          patchesDetected: 0,
-          patchesApplied: 0,
-          patchesWithConflicts: 0,
-          patchesSkipped: 0,
-          conflicts: []
-        };
-      }
-      async _prepareFirstGeneration(options2) {
-        if (options2?.dryRun) {
-          const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s9) => s9.trim()).catch(() => "");
-          return {
-            flow: "first-generation",
-            previousGenerationSha: null,
-            currentGenerationSha: headSha,
-            baseBranchHead: options2.baseBranchHead ?? null,
-            _prepared: {
-              flow: "first-generation",
-              terminal: true,
-              preparedReport: this.firstGenerationReport(),
-              patchesToApply: [],
-              newPatchIds: /* @__PURE__ */ new Set(),
-              detectorWarnings: [],
-              revertedCount: 0,
-              genSha: headSha,
-              optionsSnapshot: options2
-            }
-          };
-        }
-        const commitOpts = options2 ? {
-          cliVersion: options2.cliVersion ?? "unknown",
-          generatorVersions: options2.generatorVersions ?? {},
-          baseBranchHead: options2.baseBranchHead
-        } : void 0;
-        await this.committer.commitGeneration("Initial SDK generation", commitOpts);
-        const genRecord = await this.committer.createGenerationRecord(commitOpts);
-        this.lockManager.initializeInMemory(genRecord);
-        return {
-          flow: "first-generation",
-          previousGenerationSha: null,
-          currentGenerationSha: genRecord.commit_sha,
-          baseBranchHead: options2?.baseBranchHead ?? null,
-          _prepared: {
-            flow: "first-generation",
-            terminal: false,
-            patchesToApply: [],
-            newPatchIds: /* @__PURE__ */ new Set(),
-            detectorWarnings: [],
-            revertedCount: 0,
-            genSha: genRecord.commit_sha,
-            optionsSnapshot: options2
-          }
-        };
-      }
-      async _applyFirstGeneration(_prep) {
-        this.lockManager.save();
-        return this.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(options2) {
-        const commitOpts = options2 ? {
-          cliVersion: options2.cliVersion ?? "unknown",
-          generatorVersions: options2.generatorVersions ?? {},
-          baseBranchHead: options2.baseBranchHead
-        } : void 0;
-        await this.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
-        await this.cleanupStaleConflictMarkers();
-        const genRecord = await this.committer.createGenerationRecord(commitOpts);
-        let previousGenerationSha = null;
-        try {
-          const lock = this.lockManager.read();
-          previousGenerationSha = lock.current_generation ?? null;
-          this.lockManager.addGeneration(genRecord);
-        } catch (error50) {
-          if (error50 instanceof LockfileNotFoundError) {
-            this.lockManager.initializeInMemory(genRecord);
-          } else {
-            throw error50;
-          }
-        }
-        this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
-        return {
-          flow: "skip-application",
-          previousGenerationSha,
-          currentGenerationSha: genRecord.commit_sha,
-          baseBranchHead: options2?.baseBranchHead ?? null,
-          _prepared: {
-            flow: "skip-application",
-            terminal: false,
-            patchesToApply: [],
-            newPatchIds: /* @__PURE__ */ new Set(),
-            detectorWarnings: [],
-            revertedCount: 0,
-            genSha: genRecord.commit_sha,
-            optionsSnapshot: options2
-          }
-        };
-      }
-      async _applySkipApplication(_prep, options2) {
-        this.lockManager.save();
-        const credentialWarnings = [...this.lockManager.warnings];
-        if (!options2?.stageOnly) {
-          await this.committer.commitReplay(0);
-        } else {
-          await this.committer.stageAll();
-        }
-        return {
-          flow: "skip-application",
-          patchesDetected: 0,
-          patchesApplied: 0,
-          patchesWithConflicts: 0,
-          patchesSkipped: 0,
-          conflicts: [],
-          warnings: credentialWarnings.length > 0 ? credentialWarnings : void 0
-        };
-      }
-      async _prepareNoPatchesRegeneration(options2) {
-        const preLock = this.lockManager.read();
-        const previousGenerationSha = preLock.current_generation ?? null;
-        let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
-        const detectorWarnings = [...this.detector.warnings];
-        if (options2?.dryRun) {
-          const dryRunWarnings = [...detectorWarnings, ...this.warnings];
-          const preparedReport = {
-            flow: "no-patches",
-            patchesDetected: newPatches.length,
-            patchesApplied: 0,
-            patchesWithConflicts: 0,
-            patchesSkipped: 0,
-            patchesReverted: revertedPatchIds.length,
-            conflicts: [],
-            wouldApply: newPatches,
-            warnings: dryRunWarnings.length > 0 ? dryRunWarnings : void 0
-          };
-          const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s9) => s9.trim()).catch(() => "");
-          return {
-            flow: "no-patches",
-            previousGenerationSha,
-            currentGenerationSha: headSha,
-            baseBranchHead: options2.baseBranchHead ?? null,
-            _prepared: {
-              flow: "no-patches",
-              terminal: true,
-              preparedReport,
-              patchesToApply: [],
-              newPatchIds: /* @__PURE__ */ new Set(),
-              detectorWarnings,
-              revertedCount: revertedPatchIds.length,
-              genSha: headSha,
-              optionsSnapshot: options2
-            }
-          };
-        }
-        {
-          const preCurrentGen = preLock.current_generation;
-          const uniqueFiles = [...new Set(newPatches.flatMap((p14) => p14.files))];
-          const absorbedFiles = /* @__PURE__ */ new Set();
-          for (const file4 of uniqueFiles) {
-            const diff2 = await this.git.exec(["diff", preCurrentGen, "HEAD", "--", file4]).catch(() => null);
-            if (diff2 !== null && !diff2.trim()) {
-              absorbedFiles.add(file4);
-            }
-          }
-          if (absorbedFiles.size > 0) {
-            newPatches = newPatches.filter(
-              (p14) => p14.files.length === 0 || !p14.files.every((f4) => absorbedFiles.has(f4))
-            );
-          }
-        }
-        for (const id2 of revertedPatchIds) {
-          try {
-            this.lockManager.removePatch(id2);
-          } catch {
-          }
-        }
-        const commitOpts = options2 ? {
-          cliVersion: options2.cliVersion ?? "unknown",
-          generatorVersions: options2.generatorVersions ?? {},
-          baseBranchHead: options2.baseBranchHead
-        } : void 0;
-        await this.committer.commitGeneration("Update SDK", commitOpts);
-        await this.cleanupStaleConflictMarkers();
-        const genRecord = await this.committer.createGenerationRecord(commitOpts);
-        this.lockManager.addGeneration(genRecord);
-        return {
-          flow: "no-patches",
-          previousGenerationSha,
-          currentGenerationSha: genRecord.commit_sha,
-          baseBranchHead: options2?.baseBranchHead ?? null,
-          _prepared: {
-            flow: "no-patches",
-            terminal: false,
-            patchesToApply: newPatches,
-            newPatchIds: new Set(newPatches.map((p14) => p14.id)),
-            detectorWarnings,
-            revertedCount: revertedPatchIds.length,
-            genSha: genRecord.commit_sha,
-            optionsSnapshot: options2
-          }
-        };
-      }
-      async _applyNoPatchesRegeneration(prep, options2) {
-        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);
-          for (const result of results) {
-            if (result.status === "conflict") {
-              result.patch.status = "unresolved";
-            }
-          }
-        }
-        const rebaseCounts = await this.rebasePatches(results, genSha);
-        for (const patch5 of newPatches) {
-          if (!rebaseCounts.absorbedPatchIds.has(patch5.id)) {
-            this.lockManager.addPatch(patch5);
-          }
-        }
-        this.lockManager.save();
-        this.warnings.push(...this.lockManager.warnings);
-        if (newPatches.length > 0) {
-          if (!options2?.stageOnly) {
-            const appliedCount = results.filter((r5) => r5.status === "applied").length;
-            const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, newPatches);
-            await this.committer.commitReplay(appliedCount, newPatches, void 0, { buckets });
-          } else {
-            await this.committer.stageAll();
-          }
-        }
-        const warnings = [...detectorWarnings, ...this.warnings];
-        return this.buildReport(
-          "no-patches",
-          newPatches,
-          results,
-          prep._prepared.optionsSnapshot,
-          warnings,
-          rebaseCounts,
-          void 0,
-          prep._prepared.revertedCount
-        );
-      }
-      async _prepareNormalRegeneration(options2) {
-        const preLock = this.lockManager.read();
-        const previousGenerationSha = preLock.current_generation ?? null;
-        if (options2?.dryRun) {
-          const existingPatches2 = this.lockManager.getPatches();
-          const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.detector.detectNewPatches();
-          const warnings = [...this.detector.warnings, ...this.warnings];
-          const allPatches2 = [...existingPatches2, ...newPatches2];
-          const preparedReport = {
-            flow: "normal-regeneration",
-            patchesDetected: allPatches2.length,
-            patchesApplied: 0,
-            patchesWithConflicts: 0,
-            patchesSkipped: 0,
-            patchesReverted: dryRunReverted.length,
-            conflicts: [],
-            wouldApply: allPatches2,
-            warnings: warnings.length > 0 ? warnings : void 0
-          };
-          const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s9) => s9.trim()).catch(() => "");
-          return {
-            flow: "normal-regeneration",
-            previousGenerationSha,
-            currentGenerationSha: headSha,
-            baseBranchHead: options2.baseBranchHead ?? null,
-            _prepared: {
-              flow: "normal-regeneration",
-              terminal: true,
-              preparedReport,
-              patchesToApply: [],
-              newPatchIds: /* @__PURE__ */ new Set(),
-              detectorWarnings: [...this.detector.warnings],
-              revertedCount: dryRunReverted.length,
-              genSha: headSha,
-              optionsSnapshot: options2
-            }
-          };
-        }
-        let existingPatches = this.lockManager.getPatches();
-        const preRebasePatchIds = new Set(existingPatches.map((p14) => p14.id));
-        const preRebaseCounts = await this.preGenerationRebase(existingPatches);
-        const postRebasePatchIds = new Set(this.lockManager.getPatches().map((p14) => p14.id));
-        const removedByPreRebase = existingPatches.filter(
-          (p14) => preRebasePatchIds.has(p14.id) && !postRebasePatchIds.has(p14.id)
-        );
-        existingPatches = this.lockManager.getPatches();
-        const seenHashes = /* @__PURE__ */ new Map();
-        for (const p14 of existingPatches) {
-          const priorPatchId = seenHashes.get(p14.content_hash);
-          if (priorPatchId !== void 0) {
-            this.lockManager.removePatch(p14.id);
-            this.warnings.push(
-              `Consolidated patch ${p14.id} (commit ${(p14.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(p14.content_hash, p14.id);
-          }
-        }
-        existingPatches = this.lockManager.getPatches();
-        let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
-        const detectorWarnings = [...this.detector.warnings];
-        if (removedByPreRebase.length > 0) {
-          const removedOriginalCommits = new Set(removedByPreRebase.map((p14) => p14.original_commit));
-          const removedOriginalMessages = new Set(removedByPreRebase.map((p14) => p14.original_message));
-          newPatches = newPatches.filter((p14) => {
-            if (removedOriginalCommits.has(p14.original_commit)) return false;
-            if (isRevertCommit(p14.original_message)) {
-              const revertedMsg = parseRevertedMessage(p14.original_message);
-              if (revertedMsg && removedOriginalMessages.has(revertedMsg)) return false;
-            }
-            return true;
-          });
-        }
-        for (const id2 of revertedPatchIds) {
-          try {
-            this.lockManager.removePatch(id2);
-          } catch {
-          }
-        }
-        const revertedSet = new Set(revertedPatchIds);
-        existingPatches = existingPatches.filter((p14) => !revertedSet.has(p14.id));
-        const allPatches = [...existingPatches, ...newPatches];
-        const commitOpts = options2 ? {
-          cliVersion: options2.cliVersion ?? "unknown",
-          generatorVersions: options2.generatorVersions ?? {},
-          baseBranchHead: options2.baseBranchHead
-        } : void 0;
-        await this.committer.commitGeneration("Update SDK", commitOpts);
-        await this.cleanupStaleConflictMarkers();
-        const genRecord = await this.committer.createGenerationRecord(commitOpts);
-        this.lockManager.addGeneration(genRecord);
-        return {
-          flow: "normal-regeneration",
-          previousGenerationSha,
-          currentGenerationSha: genRecord.commit_sha,
-          baseBranchHead: options2?.baseBranchHead ?? null,
-          _prepared: {
-            flow: "normal-regeneration",
-            terminal: false,
-            patchesToApply: allPatches,
-            newPatchIds: new Set(newPatches.map((p14) => p14.id)),
-            preRebaseCounts,
-            detectorWarnings,
-            revertedCount: revertedPatchIds.length,
-            genSha: genRecord.commit_sha,
-            optionsSnapshot: options2
-          }
-        };
-      }
-      async _applyNormalRegeneration(prep, options2) {
-        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);
-        for (const result of results) {
-          if (result.status === "conflict") {
-            result.patch.status = "unresolved";
-          }
-        }
-        const rebaseCounts = await this.rebasePatches(results, genSha);
-        const newPatches = allPatches.filter((p14) => newPatchIds.has(p14.id));
-        for (const patch5 of newPatches) {
-          if (!rebaseCounts.absorbedPatchIds.has(patch5.id)) {
-            this.lockManager.addPatch(patch5);
-          }
-        }
-        for (const result of results) {
-          if (result.status === "conflict") {
-            try {
-              this.lockManager.markPatchUnresolved(result.patch.id);
-            } catch {
-            }
-          }
-        }
-        this.lockManager.save();
-        this.warnings.push(...this.lockManager.warnings);
-        if (options2?.stageOnly) {
-          await this.committer.stageAll();
-        } else {
-          const appliedCount = results.filter((r5) => r5.status === "applied").length;
-          const buckets = computeCommitBuckets(results, rebaseCounts.absorbedPatchIds, allPatches);
-          await this.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
-        }
-        const warnings = [...detectorWarnings, ...this.warnings];
-        return this.buildReport(
-          "normal-regeneration",
-          allPatches,
-          results,
-          prep._prepared.optionsSnapshot,
-          warnings,
-          rebaseCounts,
-          prep._prepared.preRebaseCounts,
-          prep._prepared.revertedCount
-        );
-      }
       /**
        * 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;
@@ -363666,6 +363805,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         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 patch5 = result.patch;
@@ -363710,21 +363850,20 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
               }
             }
             const isUserOwnedPerFile = await Promise.all(
-              patch5.files.map(async (file4) => {
-                if (file4 === ".fernignore") return true;
-                if (fernignorePatterns.some((p14) => file4 === p14 || (0, import_minimatch22.minimatch)(file4, p14))) {
-                  return true;
-                }
-                if (patch5.user_owned) return true;
-                if (this.fileIsCreationInPatchContent(patch5.patch_content, originalByResolved[file4] ?? file4)) {
-                  return true;
-                }
-                const content5 = await this.git.showFile(currentGenSha, file4);
-                return content5 === null;
-              })
+              patch5.files.map(
+                (file4) => this.fileOwnership.resolveCanonical({
+                  file: file4,
+                  originalFileName: originalByResolved[file4],
+                  patch: patch5,
+                  currentGenSha,
+                  fernignorePatterns,
+                  warnedGens,
+                  warnings: this.warnings
+                })
+              )
             );
             const hasProtectedFiles = patch5.files.some(
-              (file4) => file4 === ".fernignore" || fernignorePatterns.some((p14) => file4 === p14 || (0, import_minimatch22.minimatch)(file4, p14))
+              (file4) => file4 === ".fernignore" || fernignorePatterns.some((p14) => file4 === p14 || (0, import_minimatch32.minimatch)(file4, p14))
             );
             const allUserOwned = isUserOwnedPerFile.every(Boolean);
             if (allUserOwned && patch5.files.length > 0) {
@@ -363848,7 +363987,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         for (const file4 of files) {
           if (isBinaryFile(file4)) continue;
           try {
-            const content5 = await (0, import_promises410.readFile)((0, import_node_path52.join)(this.outputDir, file4), "utf-8");
+            const content5 = await (0, import_promises610.readFile)((0, import_node_path82.join)(this.outputDir, file4), "utf-8");
             snapshot[file4] = content5;
           } catch {
           }
@@ -363856,10 +363995,16 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         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;
@@ -363888,10 +364033,15 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         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(patch5, currentGen) {
         if (!patch5.theirs_snapshot) return null;
@@ -363939,7 +364089,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
        * **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
@@ -364001,72 +364151,6 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           );
         }
       }
-      /**
-       * 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(file4, patch5, currentGenSha, fernignorePatterns, warnedGens, originalFileName) {
-        if (patch5.user_owned) return true;
-        if (file4 === ".fernignore") return true;
-        if (fernignorePatterns.some((p14) => file4 === p14 || (0, import_minimatch22.minimatch)(file4, p14))) return true;
-        if (this.fileIsCreationInPatchContent(patch5.patch_content, originalFileName ?? file4)) {
-          return true;
-        }
-        const base4 = patch5.base_generation;
-        if (base4 && base4 !== currentGenSha) {
-          const reachable = await this.git.commitExists(base4) || await this.git.treeExists(base4);
-          if (!reachable) {
-            if (!warnedGens.has(base4)) {
-              warnedGens.add(base4);
-              this.warnings.push(
-                `Base generation ${base4.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(base4, originalFileName ?? file4) === null;
-        }
-        return await this.git.showFile(currentGenSha, originalFileName ?? file4) === 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, file4) {
-        const lines = patchContent.split("\n");
-        let inFileSection = false;
-        for (const line of lines) {
-          if (line.startsWith("diff --git ")) {
-            inFileSection = line.includes(` b/${file4}`) || line.endsWith(` b/${file4}`);
-            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).
@@ -364085,7 +364169,15 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
         const warnedGens = /* @__PURE__ */ new Set();
         const generatorCleanFiles = [];
         for (const file4 of cleanFiles) {
-          if (await this.isFileUserOwned(file4, patch5, currentGenSha, fernignorePatterns, warnedGens)) {
+          const userOwned = await this.fileOwnership.resolveCanonical({
+            file: file4,
+            patch: patch5,
+            currentGenSha,
+            fernignorePatterns,
+            warnedGens,
+            warnings: this.warnings
+          });
+          if (userOwned) {
             continue;
           }
           generatorCleanFiles.push(file4);
@@ -364114,6 +364206,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
        * 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;
@@ -364152,7 +364245,15 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
           if (patch5.user_owned) return true;
           if (patch5.files.length === 0) return false;
           for (const file4 of patch5.files) {
-            if (!await this.isFileUserOwned(file4, patch5, currentGen, fernignorePatterns, warnedGens)) {
+            const userOwned = await this.fileOwnership.resolveCanonical({
+              file: file4,
+              patch: patch5,
+              currentGenSha: currentGen,
+              fernignorePatterns,
+              warnedGens,
+              warnings: this.warnings
+            });
+            if (!userOwned) {
               return false;
             }
           }
@@ -364202,7 +364303,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
                 );
                 if (snapHasStaleMarkers) continue;
                 const isProtectedSnap = patch5.files.some(
-                  (file4) => file4 === ".fernignore" || fernignorePatterns.some((p14) => file4 === p14 || (0, import_minimatch22.minimatch)(file4, p14))
+                  (file4) => file4 === ".fernignore" || fernignorePatterns.some((p14) => file4 === p14 || (0, import_minimatch32.minimatch)(file4, p14))
                 );
                 if (isProtectedSnap) continue;
                 const snapHash = this.detector.computeContentHash(snapshotDiff);
@@ -364237,7 +364338,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
                 continue;
               }
               const isProtected = patch5.files.some(
-                (file4) => file4 === ".fernignore" || fernignorePatterns.some((p14) => file4 === p14 || (0, import_minimatch22.minimatch)(file4, p14))
+                (file4) => file4 === ".fernignore" || fernignorePatterns.some((p14) => file4 === p14 || (0, import_minimatch32.minimatch)(file4, p14))
               );
               if (isProtected) {
                 continue;
@@ -364344,6 +364445,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
        * 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) {
@@ -364366,12 +364468,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 = (0, import_node_path52.join)(this.outputDir, fileResult.file);
+            const filePath = (0, import_node_path82.join)(this.outputDir, fileResult.file);
             try {
               const content5 = (0, import_node_fs210.readFileSync)(filePath, "utf-8");
               const stripped = stripConflictMarkers(content5);
@@ -364387,13 +364490,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 file4 of files) {
-          if (fernignorePatterns.some((pattern) => (0, import_minimatch22.minimatch)(file4, pattern))) continue;
+          if (fernignorePatterns.some((pattern) => (0, import_minimatch32.minimatch)(file4, pattern))) continue;
           try {
             await this.git.exec(["checkout", "HEAD", "--", file4]);
           } catch {
@@ -364401,10 +364505,11 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         }
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_node_path52.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_node_path82.join)(this.outputDir, ".fernignore");
         if (!(0, import_node_fs210.existsSync)(fernignorePath)) return [];
         return (0, import_node_fs210.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
       }
+      /** @internal Used by Flow implementations in `src/flows/`. */
       buildReport(flow4, patches, results, options2, warnings, rebaseCounts, preRebaseCounts, patchesReverted) {
         const conflictResults = results.filter((r5) => r5.status === "conflict");
         const conflictDetails = conflictResults.map((r5) => {
@@ -364478,8 +364583,8 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     }
     var import_node_crypto22 = require("crypto");
     var import_node_fs33 = require("fs");
-    var import_node_path62 = require("path");
-    var import_minimatch32 = require_commonjs3();
+    var import_node_path92 = require("path");
+    var import_minimatch42 = require_commonjs3();
     var import_yaml22 = require_dist11();
     var FernignoreMigrator = class {
       git;
@@ -364491,10 +364596,10 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         this.outputDir = outputDir;
       }
       fernignoreExists() {
-        return (0, import_node_fs33.existsSync)((0, import_node_path62.join)(this.outputDir, ".fernignore"));
+        return (0, import_node_fs33.existsSync)((0, import_node_path92.join)(this.outputDir, ".fernignore"));
       }
       readFernignorePatterns() {
-        const fernignorePath = (0, import_node_path62.join)(this.outputDir, ".fernignore");
+        const fernignorePath = (0, import_node_path92.join)(this.outputDir, ".fernignore");
         if (!(0, import_node_fs33.existsSync)(fernignorePath)) {
           return [];
         }
@@ -364511,7 +364616,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         const commitsOnly = [];
         const syntheticPatches = [];
         for (const pattern of patterns) {
-          const matchingPatch = patches.find((p14) => p14.files.some((f4) => (0, import_minimatch32.minimatch)(f4, pattern) || f4 === pattern));
+          const matchingPatch = patches.find((p14) => p14.files.some((f4) => (0, import_minimatch42.minimatch)(f4, pattern) || f4 === pattern));
           if (matchingPatch) {
             trackedByBoth.push({
               file: pattern,
@@ -364584,7 +364689,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
           fernignoreOnly.push(...remainingFernignoreOnly);
         }
         for (const patch5 of patches) {
-          const hasUnprotectedFiles = patch5.files.some((f4) => !patterns.some((p14) => (0, import_minimatch32.minimatch)(f4, p14) || f4 === p14));
+          const hasUnprotectedFiles = patch5.files.some((f4) => !patterns.some((p14) => (0, import_minimatch42.minimatch)(f4, p14) || f4 === p14));
           if (hasUnprotectedFiles) {
             commitsOnly.push(patch5);
           }
@@ -364596,14 +364701,14 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         const results = [];
         for (const pattern of patterns) {
           const matching = allFiles.filter(
-            (f4) => (0, import_minimatch32.minimatch)(f4, pattern) || f4 === pattern || f4.startsWith(pattern + "/")
+            (f4) => (0, import_minimatch42.minimatch)(f4, pattern) || f4 === pattern || f4.startsWith(pattern + "/")
           );
           results.push({ pattern, files: matching.length > 0 ? matching : [pattern] });
         }
         return results;
       }
       readFileContent(filePath) {
-        const fullPath = (0, import_node_path62.join)(this.outputDir, filePath);
+        const fullPath = (0, import_node_path92.join)(this.outputDir, filePath);
         if (!(0, import_node_fs33.existsSync)(fullPath)) {
           return null;
         }
@@ -364668,7 +364773,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         };
       }
       movePatternsToReplayYml(patterns) {
-        const replayYmlPath = (0, import_node_path62.join)(this.outputDir, ".fern", "replay.yml");
+        const replayYmlPath = (0, import_node_path92.join)(this.outputDir, ".fern", "replay.yml");
         let config5 = {};
         if ((0, import_node_fs33.existsSync)(replayYmlPath)) {
           const content5 = (0, import_node_fs33.readFileSync)(replayYmlPath, "utf-8");
@@ -364677,7 +364782,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         const existing = config5.exclude ?? [];
         const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
         config5.exclude = merged;
-        const dir = (0, import_node_path62.dirname)(replayYmlPath);
+        const dir = (0, import_node_path92.dirname)(replayYmlPath);
         if (!(0, import_node_fs33.existsSync)(dir)) {
           (0, import_node_fs33.mkdirSync)(dir, { recursive: true });
         }
@@ -364686,7 +364791,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     };
     var import_node_crypto32 = require("crypto");
     var import_node_fs42 = require("fs");
-    var import_node_path72 = require("path");
+    var import_node_path102 = require("path");
     init_GitClient();
     async function bootstrap(outputDir, options2) {
       const git = new GitClient(outputDir);
@@ -364853,7 +364958,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     }
     var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
     function ensureFernignoreEntries(outputDir) {
-      const fernignorePath = (0, import_node_path72.join)(outputDir, ".fernignore");
+      const fernignorePath = (0, import_node_path102.join)(outputDir, ".fernignore");
       let content5 = "";
       if ((0, import_node_fs42.existsSync)(fernignorePath)) {
         content5 = (0, import_node_fs42.readFileSync)(fernignorePath, "utf-8");
@@ -364877,7 +364982,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     }
     var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
     function ensureGitattributesEntries(outputDir) {
-      const gitattributesPath = (0, import_node_path72.join)(outputDir, ".gitattributes");
+      const gitattributesPath = (0, import_node_path102.join)(outputDir, ".gitattributes");
       let content5 = "";
       if ((0, import_node_fs42.existsSync)(gitattributesPath)) {
         content5 = (0, import_node_fs42.readFileSync)(gitattributesPath, "utf-8");
@@ -364905,7 +365010,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
       const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
       return `sha256:${(0, import_node_crypto32.createHash)("sha256").update(normalized).digest("hex")}`;
     }
-    var import_minimatch42 = require_commonjs3();
+    var import_minimatch52 = require_commonjs3();
     function parseDiffStat(patchContent) {
       let additions = 0;
       let deletions = 0;
@@ -364935,7 +365040,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
     }
     function matchesPatch(patch5, pattern) {
       const fileMatch = patch5.files.some(
-        (file4) => file4 === pattern || (0, import_minimatch42.minimatch)(file4, pattern)
+        (file4) => file4 === pattern || (0, import_minimatch52.minimatch)(file4, pattern)
       );
       if (fileMatch) return true;
       return patch5.original_message.toLowerCase().includes(pattern.toLowerCase());
@@ -365069,8 +365174,8 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         nothingToReset: false
       };
     }
-    var import_promises510 = require("fs/promises");
-    var import_node_path82 = require("path");
+    var import_promises710 = require("fs/promises");
+    var import_node_path112 = require("path");
     init_GitClient();
     async function resolve15(outputDir, options2) {
       const lockManager = new LockfileManager(outputDir);
@@ -365119,7 +365224,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
           const result = await computePerPatchDiffWithFallback(
             patch5,
             (f4) => git.showFile(currentGen, f4),
-            (f4) => (0, import_promises510.readFile)((0, import_node_path82.join)(outputDir, f4), "utf-8").catch(() => null),
+            (f4) => (0, import_promises710.readFile)((0, import_node_path112.join)(outputDir, f4), "utf-8").catch(() => null),
             (files) => git.exec(["diff", currentGen, "--", ...files]).catch(() => null)
           );
           if (result === null) {
@@ -365175,7 +365280,7 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
           const theirsSnapshot = {};
           for (const file4 of filesForSnapshot) {
             if (isBinaryFile(file4)) continue;
-            const content5 = await (0, import_promises510.readFile)((0, import_node_path82.join)(outputDir, file4), "utf-8").catch(() => null);
+            const content5 = await (0, import_promises710.readFile)((0, import_node_path112.join)(outputDir, file4), "utf-8").catch(() => null);
             if (content5 != null) {
               theirsSnapshot[file4] = content5;
             }
@@ -667965,7 +668070,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.27.5",
+          version: "5.27.7",
           usingAccessToken: true,
           ...getRunIdProperties()
         }
@@ -668029,7 +668134,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.27.5",
+        version: "5.27.7",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -859608,7 +859713,7 @@ var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 var MAX_LOGS_DIR_SIZE_BYTES = 100 * 1024 * 1024;
 function getCliSource() {
-  const version7 = "5.27.5";
+  const version7 = "5.27.7";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -873608,7 +873713,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.27.5",
+        cliVersion: "5.27.7",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -948013,7 +948118,7 @@ function getAutomationContextFromEnv() {
     config_branch: process.env.FERN_CONFIG_BRANCH,
     config_pr_number: process.env.FERN_CONFIG_PR_NUMBER,
     trigger: process.env.GITHUB_EVENT_NAME,
-    cli_version: "5.27.5"
+    cli_version: "5.27.7"
   };
 }
 function isAutomationMode() {
@@ -948839,7 +948944,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.27.5";
+    return "5.27.7";
   }
   getCliName() {
     if (false) {