@fern-api/replay 0.10.4 → 0.12.0

package/dist/cli.cjs

@@ -499,6 +499,121 @@ var require_browser = __commonJS({
   }
 });
 
+// node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "node_modules/has-flag/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "node_modules/supports-color/index.js"(exports2, module2) {
+    "use strict";
+    var os = require("os");
+    var tty = require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module2.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
 // node_modules/debug/src/node.js
 var require_node = __commonJS({
   "node_modules/debug/src/node.js"(exports2, module2) {
@@ -518,7 +633,7 @@ var require_node = __commonJS({
     );
     exports2.colors = [6, 2, 3, 4, 5, 1];
     try {
-      const supportsColor = require("supports-color");
+      const supportsColor = require_supports_color();
       if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
         exports2.colors = [
           20,
@@ -5301,13 +5416,30 @@ var init_GitClient = __esm({
         const output = await this.exec(["rev-parse", `${commitSha}^@`]);
         return output.trim().split("\n").filter(Boolean);
       }
+      /**
+       * Detects renames and copies between two trees.
+       *
+       * Both `R` (rename) and `C` (copy) entries are returned as `{from, to}` pairs.
+       * Copies are treated as rename-equivalent because the generator may produce the
+       * new path while the old path remains in the tree (e.g., imperfect cleanup,
+       * customer edits at the old path, or test helpers that only write new files).
+       * Callers that care about "is the source still present" should verify via
+       * `showFile(toTree, from)`.
+       */
       async detectRenames(fromTree, toTree) {
         try {
-          const output = await this.exec(["diff", "--find-renames", "--name-status", fromTree, toTree]);
+          const output = await this.exec([
+            "diff",
+            "--find-renames",
+            "--find-copies",
+            "--name-status",
+            fromTree,
+            toTree
+          ]);
           const renames = [];
           for (const line of output.trim().split("\n")) {
             if (!line) continue;
-            if (line.startsWith("R")) {
+            if (line.startsWith("R") || line.startsWith("C")) {
               const parts = line.split("	");
               if (parts.length >= 3) {
                 renames.push({ from: parts[1], to: parts[2] });
@@ -13110,6 +13242,41 @@ init_GitClient();
 var import_node_fs = require("fs");
 var import_node_path2 = require("path");
 var import_yaml = __toESM(require_dist3(), 1);
+
+// src/credentials.ts
+var CREDENTIAL_PATTERNS = [
+  { name: "PRIVATE KEY block", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+  { name: "OPENSSH key", re: /-----BEGIN OPENSSH PRIVATE KEY-----/ },
+  { name: "RSA key", re: /-----BEGIN RSA PRIVATE KEY-----/ },
+  { name: "CERTIFICATE", re: /-----BEGIN CERTIFICATE-----/ },
+  { name: "TOKEN=", re: /\bTOKEN\s*=\s*["']?[A-Za-z0-9._\-+/=]{10,}/ },
+  { name: "api_key=", re: /\bapi[_-]?key\s*=\s*["']?[A-Za-z0-9._\-+/=]{10,}/i },
+  { name: "password=", re: /\bpassword\s*=\s*["']?[^\s"']{6,}/i },
+  { name: "AWS_SECRET_ACCESS_KEY", re: /AWS_SECRET_ACCESS_KEY/ },
+  { name: "JWT (eyJ...)", re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/ }
+];
+var SENSITIVE_FILE_PATTERNS = [
+  /(^|\/)\.env(\.[^/]+)?$/,
+  /\.pem$/,
+  /\.key$/,
+  /\.pkce_state\.json$/,
+  /(^|\/)id_rsa$/,
+  /(^|\/)id_ed25519$/
+];
+function isSensitiveFile(filePath) {
+  return SENSITIVE_FILE_PATTERNS.some((re) => re.test(filePath));
+}
+function scanForCredentials(content) {
+  const matches = [];
+  for (const { name, re } of CREDENTIAL_PATTERNS) {
+    if (re.test(content)) {
+      matches.push(name);
+    }
+  }
+  return matches;
+}
+
+// src/LockfileManager.ts
 var LOCKFILE_HEADER = "# DO NOT EDIT MANUALLY - Managed by Fern Replay\n";
 var LockfileNotFoundError = class extends Error {
   constructor(path2) {
@@ -13120,6 +13287,7 @@ var LockfileNotFoundError = class extends Error {
 var LockfileManager = class {
   outputDir;
   lock = null;
+  warnings = [];
   constructor(outputDir) {
     this.outputDir = outputDir;
   }
@@ -13168,6 +13336,27 @@ var LockfileManager = class {
     if (!this.lock) {
       throw new Error("No lockfile data to save. Call read() or initialize() first.");
     }
+    this.warnings.length = 0;
+    const cleanPatches = [];
+    for (const patch of this.lock.patches) {
+      const credentialMatches = scanForCredentials(patch.patch_content);
+      const sensitiveFiles = patch.files.filter((f) => isSensitiveFile(f));
+      if (credentialMatches.length > 0 || sensitiveFiles.length > 0) {
+        const reasons = [];
+        if (credentialMatches.length > 0) {
+          reasons.push(`credential patterns: ${credentialMatches.join(", ")}`);
+        }
+        if (sensitiveFiles.length > 0) {
+          reasons.push(`sensitive files: ${sensitiveFiles.join(", ")}`);
+        }
+        this.warnings.push(
+          `Patch ${patch.id} removed from lockfile: ${reasons.join("; ")}. This prevents credential exposure in committed lockfiles.`
+        );
+      } else {
+        cleanPatches.push(patch);
+      }
+    }
+    this.lock.patches = cleanPatches;
     const dir = (0, import_node_path2.dirname)(this.lockfilePath);
     if (!(0, import_node_fs.existsSync)(dir)) {
       (0, import_node_fs.mkdirSync)(dir, { recursive: true });
@@ -13280,7 +13469,7 @@ var FERN_SUPPORT_NAMES = ["fern-support", "Fern Support"];
 function isGenerationCommit(commit) {
   const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
   const isBotAuthor = !isFernSupport && (commit.authorLogin === FERN_BOT_LOGIN || commit.authorEmail === FERN_BOT_EMAIL || commit.authorName === FERN_BOT_NAME);
-  const hasGenerationMarker = commit.message.startsWith("[fern-generated]") || commit.message.startsWith("[fern-replay]") || commit.message.includes("Generated by Fern") || commit.message.includes("\u{1F916} Generated with Fern") || // Squash merge of a Fern-generated PR uses the PR title as commit message.
+  const hasGenerationMarker = commit.message.startsWith("[fern-generated]") || commit.message.startsWith("[fern-replay]") || commit.message.startsWith("[fern-autoversion]") || commit.message.includes("Generated by Fern") || commit.message.includes("\u{1F916} Generated with Fern") || // Squash merge of a Fern-generated PR uses the PR title as commit message.
   // The default PR title is "SDK Generation" (from GithubStep's commitMessage default).
   // GitHub appends "(#N)" for the PR number, e.g. "SDK Generation (#70)".
   commit.message.startsWith("SDK Generation");
@@ -13303,6 +13492,37 @@ function parseRevertedMessage(subject) {
 
 // src/ReplayDetector.ts
 var INFRASTRUCTURE_FILES = /* @__PURE__ */ new Set([".fernignore"]);
+function parsePatchFileHeaders(patchContent) {
+  const results = [];
+  let currentPath = null;
+  let currentIsCreate = false;
+  let currentIsDelete = false;
+  const flush = () => {
+    if (currentPath !== null) {
+      results.push({ path: currentPath, isCreate: currentIsCreate, isDelete: currentIsDelete });
+    }
+  };
+  for (const line of patchContent.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      flush();
+      currentPath = null;
+      currentIsCreate = false;
+      currentIsDelete = false;
+      const match2 = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
+      if (match2) {
+        currentPath = match2[2] ?? null;
+      }
+    } else if (currentPath !== null) {
+      if (line.startsWith("new file mode ")) {
+        currentIsCreate = true;
+      } else if (line.startsWith("deleted file mode ")) {
+        currentIsDelete = true;
+      }
+    }
+  }
+  flush();
+  return results;
+}
 var ReplayDetector = class {
   git;
   lockManager;
@@ -13381,12 +13601,31 @@ var ReplayDetector = class {
         );
         continue;
       }
-      const contentHash = this.computeContentHash(patchContent);
+      let contentHash = this.computeContentHash(patchContent);
       if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
         continue;
       }
       const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-      const files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f));
+      const allFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+      const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
+      const files = allFiles.filter((f) => !isSensitiveFile(f));
+      if (sensitiveFiles.length > 0) {
+        this.warnings.push(
+          `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
+        );
+        if (files.length > 0) {
+          const parentSha = parents[0];
+          if (parentSha) {
+            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;
       }
@@ -13398,14 +13637,16 @@ var ReplayDetector = class {
         original_author: `${commit.authorName} <${commit.authorEmail}>`,
         base_generation: lastGen.commit_sha,
         files,
-        patch_content: patchContent
+        patch_content: patchContent,
+        ...this.isCreationOnlyPatch(patchContent) ? { user_owned: true } : {}
       });
     }
-    newPatches.reverse();
+    const survivingPatches = await this.collapseNetZeroFiles(newPatches);
+    survivingPatches.reverse();
     const revertedPatchIdSet = /* @__PURE__ */ new Set();
     const revertIndicesToRemove = /* @__PURE__ */ new Set();
-    for (let i = 0; i < newPatches.length; i++) {
-      const patch = newPatches[i];
+    for (let i = 0; i < survivingPatches.length; i++) {
+      const patch = survivingPatches[i];
       if (!isRevertCommit(patch.original_message)) continue;
       let body = "";
       try {
@@ -13434,7 +13675,7 @@ var ReplayDetector = class {
       if (matchedExisting) continue;
       let matchedNew = false;
       if (revertedSha) {
-        const idx = newPatches.findIndex(
+        const idx = survivingPatches.findIndex(
           (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_commit === revertedSha
         );
         if (idx !== -1) {
@@ -13444,7 +13685,7 @@ var ReplayDetector = class {
         }
       }
       if (!matchedNew && revertedMessage) {
-        const idx = newPatches.findIndex(
+        const idx = survivingPatches.findIndex(
           (p, j) => j !== i && !revertIndicesToRemove.has(j) && p.original_message === revertedMessage
         );
         if (idx !== -1) {
@@ -13456,18 +13697,107 @@ var ReplayDetector = class {
         revertIndicesToRemove.add(i);
       }
     }
-    const filteredPatches = newPatches.filter((_, i) => !revertIndicesToRemove.has(i));
+    const filteredPatches = survivingPatches.filter((_, i) => !revertIndicesToRemove.has(i));
     return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
   }
   /**
    * Compute content hash for deduplication.
-   * Removes commit SHA line and index lines before hashing,
-   * so rebased commits with same content produce the same hash.
+   *
+   * 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 normalized = patchContent.split("\n").filter((line) => !line.startsWith("From ") && !line.startsWith("index ") && !line.startsWith("Date: ")).join("\n");
+    const lines = patchContent.split("\n");
+    const diffStart = lines.findIndex((l) => l.startsWith("diff --git "));
+    const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
+    const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
     return `sha256:${(0, import_node_crypto.createHash)("sha256").update(normalized).digest("hex")}`;
   }
+  /**
+   * FER-9805 — Drop patches whose files were transiently created and then
+   * deleted within the current linear detection window, and are absent from
+   * HEAD at the end of the window.
+   *
+   * Rationale: on a merge commit, createMergeCompositePatch already diffs
+   * firstParent..mergeCommit so net-zero files never enter the composite. On
+   * linear history each commit becomes its own patch, so a file that was
+   * briefly added and later removed survives as a create+delete pair whose
+   * cumulative diff is empty. We drop such patches before they reach the
+   * lockfile.
+   *
+   * A file is "transient" when:
+   *   1. some patch in the window sets `new file mode` for it (a creation), AND
+   *   2. some patch in the window sets `deleted file mode` for it (a deletion), AND
+   *   3. it is absent from HEAD's tree.
+   *
+   * The HEAD guard (#3) prevents false positives when a file is deleted
+   * and then recreated with different content — the cumulative diff of
+   * such a pair is non-empty and must be preserved.
+   *
+   * This only drops patches whose `files` are a subset of the transient
+   * set. A partial-transient patch (one that touches a transient file
+   * alongside a persistent one) is left unmodified; surgical stripping of
+   * single files from a multi-file patch would require a follow-up that
+   * regenerates the patch content via `git format-patch -- <files>`. No
+   * current failing test exercises this, and leaving the patch intact
+   * preserves today's behaviour. TODO(FER-9805): revisit if a future
+   * adversarial test demands per-file stripping.
+   */
+  async collapseNetZeroFiles(patches) {
+    if (patches.length === 0) return patches;
+    const stateByFile = /* @__PURE__ */ new Map();
+    for (const patch of patches) {
+      for (const header of parsePatchFileHeaders(patch.patch_content)) {
+        if (!header.isCreate && !header.isDelete) continue;
+        const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
+        if (header.isCreate) prior.created = true;
+        if (header.isDelete) prior.deleted = true;
+        stateByFile.set(header.path, prior);
+      }
+    }
+    let anyCandidate = false;
+    for (const state of stateByFile.values()) {
+      if (state.created && state.deleted) {
+        anyCandidate = true;
+        break;
+      }
+    }
+    if (!anyCandidate) return patches;
+    const headFiles = await this.listHeadFiles();
+    const transient = /* @__PURE__ */ new Set();
+    for (const [file, state] of stateByFile) {
+      if (state.created && state.deleted && !headFiles.has(file)) {
+        transient.add(file);
+      }
+    }
+    if (transient.size === 0) return patches;
+    return patches.filter((patch) => !patch.files.every((f) => transient.has(f)));
+  }
+  /**
+   * List every tracked path at HEAD (one `git ls-tree -r` invocation).
+   * Returns an empty Set if HEAD is unborn or the invocation fails — the
+   * caller then treats every candidate as "not in HEAD" and may collapse
+   * more aggressively. On typical SDK repos this is a single sub-10ms call.
+   */
+  async listHeadFiles() {
+    try {
+      const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
+      return new Set(out.split("\n").map((l) => l.trim()).filter(Boolean));
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
   /**
    * Create a single composite patch for a merge commit by diffing the merge
    * commit against its first parent. This captures the net change of the
@@ -13483,7 +13813,14 @@ var ReplayDetector = class {
       firstParent,
       mergeCommit.sha
     ]);
-    const files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+    const allMergeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+    const sensitiveMergeFiles = allMergeFiles.filter((f) => isSensitiveFile(f));
+    const files = allMergeFiles.filter((f) => !isSensitiveFile(f));
+    if (sensitiveMergeFiles.length > 0) {
+      this.warnings.push(
+        `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveMergeFiles.join(", ")}. These files will not be tracked by replay.`
+      );
+    }
     if (files.length === 0) return null;
     const diff = await this.git.exec([
       "diff",
@@ -13505,7 +13842,8 @@ var ReplayDetector = class {
       original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
       base_generation: lastGen.commit_sha,
       files,
-      patch_content: diff
+      patch_content: diff,
+      ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
     };
   }
   /**
@@ -13519,7 +13857,14 @@ var ReplayDetector = class {
       return this.detectPatchesViaCommitScan();
     }
     const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
-    const files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+    const allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+    const sensitiveTreeFiles = allTreeFiles.filter((f) => isSensitiveFile(f));
+    const files = allTreeFiles.filter((f) => !isSensitiveFile(f));
+    if (sensitiveTreeFiles.length > 0) {
+      this.warnings.push(
+        `Sensitive file(s) excluded from composite patch: ${sensitiveTreeFiles.join(", ")}. These files will not be tracked by replay.`
+      );
+    }
     if (files.length === 0) return { patches: [], revertedPatchIds: [] };
     const diff = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
     if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
@@ -13539,7 +13884,8 @@ var ReplayDetector = class {
       // reference to find base file content. diffBase may be the tree_hash.
       base_generation: commitKnownMissing ? diffBase : lastGen.commit_sha,
       files,
-      patch_content: diff
+      patch_content: diff,
+      ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
     };
     return { patches: [compositePatch], revertedPatchIds: [] };
   }
@@ -13586,7 +13932,7 @@ var ReplayDetector = class {
       } catch {
         continue;
       }
-      const contentHash = this.computeContentHash(patchContent);
+      let contentHash = this.computeContentHash(patchContent);
       if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
         continue;
       }
@@ -13594,7 +13940,26 @@ var ReplayDetector = class {
         continue;
       }
       const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-      const files = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f));
+      const allScanFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f));
+      const sensitiveScanFiles = allScanFiles.filter((f) => isSensitiveFile(f));
+      const files = allScanFiles.filter((f) => !isSensitiveFile(f));
+      if (sensitiveScanFiles.length > 0) {
+        this.warnings.push(
+          `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveScanFiles.join(", ")}. These files will not be tracked by replay.`
+        );
+        if (files.length > 0) {
+          if (parents.length === 0) {
+            continue;
+          }
+          try {
+            patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
+          } catch {
+            continue;
+          }
+          if (!patchContent.trim()) continue;
+          contentHash = this.computeContentHash(patchContent);
+        }
+      }
       if (files.length === 0) {
         continue;
       }
@@ -15506,6 +15871,20 @@ var ReplayApplicator = class {
   resetAccumulator() {
     this.fileTheirsAccumulator.clear();
   }
+  /**
+   * @internal Test-only.
+   * Returns a defensive copy of the inter-patch accumulator. Used by the
+   * adversarial test suite (FER-9791) to assert invariant I2: after every
+   * applied patch, the accumulator has an entry for each file the patch
+   * touched, and the entry's content matches on-disk.
+   */
+  getAccumulatorSnapshot() {
+    const snapshot = /* @__PURE__ */ new Map();
+    for (const [path2, entry] of this.fileTheirsAccumulator) {
+      snapshot.set(path2, { content: entry.content, baseGeneration: entry.baseGeneration });
+    }
+    return snapshot;
+  }
   /**
    * Apply all patches, returning results for each.
    * Skips patches that match exclude patterns in replay.yml
@@ -15571,7 +15950,7 @@ var ReplayApplicator = class {
         const base = await this.git.showFile(baseGen.tree_hash, filePath);
         const theirs = await this.applyPatchToContent(base, patch.patch_content, filePath, tempGit, tempDir);
         const effectiveTheirs = theirs ?? await (0, import_promises.readFile)((0, import_node_path3.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
-        if (effectiveTheirs) {
+        if (effectiveTheirs != null) {
           this.fileTheirsAccumulator.set(resolvedPath, {
             content: effectiveTheirs,
             baseGeneration: patch.base_generation
@@ -15595,16 +15974,20 @@ var ReplayApplicator = class {
         return this.fileTheirsAccumulator.has(resolved);
       })
     ).then((results) => results.some(Boolean));
-    if (!needsAccumulation) {
+    const resolvedFiles = {};
+    for (const filePath of patch.files) {
+      const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
+      if (resolvedPath !== filePath) {
+        resolvedFiles[filePath] = resolvedPath;
+      }
+    }
+    const patchIsRenameAware = /^rename from /m.test(patch.patch_content);
+    const hasGeneratorRename = Object.keys(resolvedFiles).length > 0 && !patchIsRenameAware;
+    if (!needsAccumulation && !hasGeneratorRename) {
       const snapshots = /* @__PURE__ */ new Map();
-      const resolvedFiles = {};
       for (const filePath of patch.files) {
-        const resolvedPath = baseGen ? await this.resolveFilePath(filePath, baseGen.tree_hash, currentTreeHash) : filePath;
-        if (resolvedPath !== filePath) {
-          resolvedFiles[filePath] = resolvedPath;
-        }
-        const fullPath = (0, import_node_path3.join)(this.outputDir, resolvedPath);
-        snapshots.set(resolvedPath, await (0, import_promises.readFile)(fullPath, "utf-8").catch(() => null));
+        const fullPath = (0, import_node_path3.join)(this.outputDir, filePath);
+        snapshots.set(filePath, await (0, import_promises.readFile)(fullPath, "utf-8").catch(() => null));
       }
       try {
         await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
@@ -15616,8 +15999,8 @@ var ReplayApplicator = class {
           ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
         };
       } catch {
-        for (const [resolvedPath, content] of snapshots) {
-          const fullPath = (0, import_node_path3.join)(this.outputDir, resolvedPath);
+        for (const [filePath, content] of snapshots) {
+          const fullPath = (0, import_node_path3.join)(this.outputDir, filePath);
           if (content != null) {
             await (0, import_promises.writeFile)(fullPath, content);
           } else {
@@ -15737,7 +16120,7 @@ var ReplayApplicator = class {
       }
       let useAccumulatorAsMergeBase = false;
       const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
-      if (accumulatorEntry && (!theirs || base == null)) {
+      if (accumulatorEntry && (theirs == null || base == null)) {
         theirs = await this.applyPatchToContent(
           accumulatorEntry.content,
           patch.patch_content,
@@ -15745,7 +16128,16 @@ var ReplayApplicator = class {
           tempGit,
           tempDir
         );
-        if (theirs) {
+        if (theirs != null) {
+          useAccumulatorAsMergeBase = true;
+        } else if (await this.isPatchAlreadyApplied(
+          patch.patch_content,
+          filePath,
+          accumulatorEntry.content,
+          tempGit,
+          tempDir
+        )) {
+          theirs = accumulatorEntry.content;
           useAccumulatorAsMergeBase = true;
         }
       }
@@ -15762,7 +16154,7 @@ var ReplayApplicator = class {
       }
       let effective_theirs = theirs;
       let baseMismatchSkipped = false;
-      if (theirs && base && !useAccumulatorAsMergeBase) {
+      if (theirs != null && base != null && !useAccumulatorAsMergeBase) {
         if (accumulatorEntry && accumulatorEntry.baseGeneration === patch.base_generation) {
           try {
             const preMerged = threeWayMerge(base, accumulatorEntry.content, theirs);
@@ -15778,7 +16170,7 @@ var ReplayApplicator = class {
           baseMismatchSkipped = true;
         }
       }
-      if (base == null && !ours && effective_theirs) {
+      if (base == null && ours == null && effective_theirs != null) {
         this.fileTheirsAccumulator.set(resolvedPath, {
           content: effective_theirs,
           baseGeneration: patch.base_generation
@@ -15788,7 +16180,7 @@ var ReplayApplicator = class {
         await (0, import_promises.writeFile)(oursPath, effective_theirs);
         return { file: resolvedPath, status: "merged", reason: "new-file" };
       }
-      if (base == null && ours && effective_theirs && !useAccumulatorAsMergeBase) {
+      if (base == null && ours != null && effective_theirs != null && !useAccumulatorAsMergeBase) {
         const merged2 = threeWayMerge("", ours, effective_theirs);
         const outDir2 = (0, import_node_path3.dirname)(oursPath);
         await (0, import_promises.mkdir)(outDir2, { recursive: true });
@@ -15802,16 +16194,20 @@ var ReplayApplicator = class {
             conflictMetadata: metadata
           };
         }
+        this.fileTheirsAccumulator.set(resolvedPath, {
+          content: merged2.content,
+          baseGeneration: patch.base_generation
+        });
         return { file: resolvedPath, status: "merged" };
       }
-      if (!effective_theirs) {
+      if (effective_theirs == null) {
         return {
           file: resolvedPath,
           status: "skipped",
           reason: "missing-content"
         };
       }
-      if (base == null && !useAccumulatorAsMergeBase || !ours) {
+      if (base == null && !useAccumulatorAsMergeBase || ours == null) {
         return {
           file: resolvedPath,
           status: "skipped",
@@ -15830,7 +16226,7 @@ var ReplayApplicator = class {
       const outDir = (0, import_node_path3.dirname)(oursPath);
       await (0, import_promises.mkdir)(outDir, { recursive: true });
       await (0, import_promises.writeFile)(oursPath, merged.content);
-      if (effective_theirs && !merged.hasConflicts) {
+      if (effective_theirs != null && !merged.hasConflicts) {
         this.fileTheirsAccumulator.set(resolvedPath, {
           content: effective_theirs,
           baseGeneration: patch.base_generation
@@ -15928,6 +16324,28 @@ var ReplayApplicator = class {
       return null;
     }
   }
+  /**
+   * Detects whether a patch's additions are already present in `content`.
+   * Uses `git apply --reverse --check` — if the reverse patch applies cleanly,
+   * the forward patch is effectively a no-op (its +lines are already there and
+   * its -lines are already gone). Used to distinguish "patch already applied"
+   * from "patch base mismatch" after a forward-apply fails.
+   */
+  async isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
+    const fileDiff = this.extractFileDiff(patchContent, filePath);
+    if (!fileDiff) return false;
+    try {
+      const tempFilePath = (0, import_node_path3.join)(tempDir, filePath);
+      await (0, import_promises.mkdir)((0, import_node_path3.dirname)(tempFilePath), { recursive: true });
+      await (0, import_promises.writeFile)(tempFilePath, content);
+      await tempGit.exec(["add", filePath]);
+      await tempGit.exec(["commit", "-m", `check already-applied ${filePath}`, "--allow-empty"]);
+      await tempGit.execWithInput(["apply", "--reverse", "--check", "--allow-empty"], fileDiff);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   extractFileDiff(patchContent, filePath) {
     const lines = patchContent.split("\n");
     const diffLines = [];
@@ -16092,6 +16510,33 @@ var ReplayService = class {
   committer;
   lockManager;
   outputDir;
+  /** @internal Test-only. Captures the last ReplayResult[] returned from applicator.applyPatches(). */
+  _lastApplyResults = [];
+  /**
+   * Service-level warnings accumulated during a single runReplay() call.
+   * Merged with `detector.warnings` into `ReplayReport.warnings` by each flow handler.
+   * Populated by `isFileUserOwned` when a patch's base generation tree is unreachable
+   * (shallow clone / aggressive `git gc --prune`) and we fall back to a conservative
+   * heuristic. Cleared at the top of `runReplay()`.
+   */
+  warnings = [];
+  /**
+   * @internal Test-only accessor.
+   * Returns the ReplayApplicator instance used for the last run. Tests use this
+   * to inspect the inter-patch accumulator after runReplay() completes (FER-9791, I2).
+   */
+  get applicatorRef() {
+    return this.applicator;
+  }
+  /**
+   * @internal Test-only accessor.
+   * Returns the ReplayResult[] from the most recent applyPatches() call. Tests use
+   * this to filter applied-vs-conflicted-vs-absorbed patches for invariant assertions
+   * (FER-9791). Returns an empty array if no patches have been applied yet.
+   */
+  getLastResults() {
+    return this._lastApplyResults;
+  }
   constructor(outputDir, _config) {
     const git = new GitClient(outputDir);
     this.git = git;
@@ -16101,20 +16546,66 @@ var ReplayService = class {
     this.applicator = new ReplayApplicator(git, this.lockManager, outputDir);
     this.committer = new ReplayCommitter(git, outputDir);
   }
-  async runReplay(options) {
+  /**
+   * Phase 1 of the two-phase replay flow. Runs preGenerationRebase (when applicable),
+   * detects new patches, and creates the `[fern-generated]` commit. Leaves HEAD at
+   * the generation commit (or unchanged for dry-run).
+   *
+   * Does NOT apply patches — the returned handle must be passed to
+   * `applyPreparedReplay()` to complete the run. No disk writes to the lockfile
+   * happen here; lockfile persistence is deferred to phase 2.
+   *
+   * Callers may land additional commits on HEAD between `prepareReplay` and
+   * `applyPreparedReplay` (e.g., `[fern-autoversion]`).
+   */
+  async prepareReplay(options) {
+    this.warnings = [];
+    this.detector.warnings.length = 0;
     if (options?.skipApplication) {
-      return this.handleSkipApplication(options);
+      return this._prepareSkipApplication(options);
     }
     const flow = this.determineFlow();
     switch (flow) {
       case "first-generation":
-        return this.handleFirstGeneration(options);
+        return this._prepareFirstGeneration(options);
       case "no-patches":
-        return this.handleNoPatchesRegeneration(options);
+        return this._prepareNoPatchesRegeneration(options);
       case "normal-regeneration":
-        return this.handleNormalRegeneration(options);
+        return this._prepareNormalRegeneration(options);
     }
   }
+  /**
+   * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
+   * the generation, saves the lockfile, and commits `[fern-replay]` (or stages
+   * under `stageOnly`). Operates on HEAD at call time — mid-phase commits are
+   * respected.
+   *
+   * For terminal handles (dry-run, first-gen has no patch work, skip-app does
+   * its own post-commit logic), this returns the precomputed report.
+   */
+  async applyPreparedReplay(prep, options) {
+    if (prep._prepared.terminal) {
+      return prep._prepared.preparedReport;
+    }
+    switch (prep._prepared.flow) {
+      case "first-generation":
+        return this._applyFirstGeneration(prep);
+      case "skip-application":
+        return this._applySkipApplication(prep, options);
+      case "no-patches":
+        return this._applyNoPatchesRegeneration(prep, options);
+      case "normal-regeneration":
+        return this._applyNormalRegeneration(prep, options);
+    }
+  }
+  /**
+   * Backwards-compatible atomic entry point. Composes `prepareReplay` + `applyPreparedReplay`.
+   * Behavior is byte-identical to the pre-split implementation for all existing callers.
+   */
+  async runReplay(options) {
+    const prep = await this.prepareReplay(options);
+    return this.applyPreparedReplay(prep, options);
+  }
   /**
    * Sync the lockfile after a divergent PR was squash-merged.
    * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
@@ -16175,6 +16666,7 @@ var ReplayService = class {
       );
     }
     this.lockManager.save();
+    this.detector.warnings.push(...this.lockManager.warnings);
   }
   determineFlow() {
     try {
@@ -16187,15 +16679,35 @@ var ReplayService = class {
       throw error;
     }
   }
-  async handleFirstGeneration(options) {
+  firstGenerationReport() {
+    return {
+      flow: "first-generation",
+      patchesDetected: 0,
+      patchesApplied: 0,
+      patchesWithConflicts: 0,
+      patchesSkipped: 0,
+      conflicts: []
+    };
+  }
+  async _prepareFirstGeneration(options) {
     if (options?.dryRun) {
+      const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
       return {
         flow: "first-generation",
-        patchesDetected: 0,
-        patchesApplied: 0,
-        patchesWithConflicts: 0,
-        patchesSkipped: 0,
-        conflicts: []
+        previousGenerationSha: null,
+        currentGenerationSha: headSha,
+        baseBranchHead: options.baseBranchHead ?? null,
+        _prepared: {
+          flow: "first-generation",
+          terminal: true,
+          preparedReport: this.firstGenerationReport(),
+          patchesToApply: [],
+          newPatchIds: /* @__PURE__ */ new Set(),
+          detectorWarnings: [],
+          revertedCount: 0,
+          genSha: headSha,
+          optionsSnapshot: options
+        }
       };
     }
     const commitOpts = options ? {
@@ -16205,22 +16717,36 @@ var ReplayService = class {
     } : void 0;
     await this.committer.commitGeneration("Initial SDK generation", commitOpts);
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
-    this.lockManager.initialize(genRecord);
+    this.lockManager.initializeInMemory(genRecord);
     return {
       flow: "first-generation",
-      patchesDetected: 0,
-      patchesApplied: 0,
-      patchesWithConflicts: 0,
-      patchesSkipped: 0,
-      conflicts: []
+      previousGenerationSha: null,
+      currentGenerationSha: genRecord.commit_sha,
+      baseBranchHead: options?.baseBranchHead ?? null,
+      _prepared: {
+        flow: "first-generation",
+        terminal: false,
+        patchesToApply: [],
+        newPatchIds: /* @__PURE__ */ new Set(),
+        detectorWarnings: [],
+        revertedCount: 0,
+        genSha: genRecord.commit_sha,
+        optionsSnapshot: options
+      }
     };
   }
+  async _applyFirstGeneration(_prep) {
+    this.lockManager.save();
+    return this.firstGenerationReport();
+  }
   /**
-   * Skip-application mode: commit the generation and update the lockfile
-   * but don't detect or apply patches. Sets a marker so the next normal
-   * run skips revert detection in preGenerationRebase().
+   * 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 handleSkipApplication(options) {
+  async _prepareSkipApplication(options) {
     const commitOpts = options ? {
       cliVersion: options.cliVersion ?? "unknown",
       generatorVersions: options.generatorVersions ?? {},
@@ -16229,8 +16755,10 @@ var ReplayService = class {
     await this.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
     await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
+    let previousGenerationSha = null;
     try {
-      this.lockManager.read();
+      const lock = this.lockManager.read();
+      previousGenerationSha = lock.current_generation ?? null;
       this.lockManager.addGeneration(genRecord);
     } catch (error) {
       if (error instanceof LockfileNotFoundError) {
@@ -16240,7 +16768,26 @@ var ReplayService = class {
       }
     }
     this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
+    return {
+      flow: "skip-application",
+      previousGenerationSha,
+      currentGenerationSha: genRecord.commit_sha,
+      baseBranchHead: options?.baseBranchHead ?? null,
+      _prepared: {
+        flow: "skip-application",
+        terminal: false,
+        patchesToApply: [],
+        newPatchIds: /* @__PURE__ */ new Set(),
+        detectorWarnings: [],
+        revertedCount: 0,
+        genSha: genRecord.commit_sha,
+        optionsSnapshot: options
+      }
+    };
+  }
+  async _applySkipApplication(_prep, options) {
     this.lockManager.save();
+    const credentialWarnings = [...this.lockManager.warnings];
     if (!options?.stageOnly) {
       await this.committer.commitReplay(0);
     } else {
@@ -16252,14 +16799,18 @@ var ReplayService = class {
       patchesApplied: 0,
       patchesWithConflicts: 0,
       patchesSkipped: 0,
-      conflicts: []
+      conflicts: [],
+      warnings: credentialWarnings.length > 0 ? credentialWarnings : void 0
     };
   }
-  async handleNoPatchesRegeneration(options) {
-    const { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
-    const warnings = [...this.detector.warnings];
+  async _prepareNoPatchesRegeneration(options) {
+    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 (options?.dryRun) {
-      return {
+      const dryRunWarnings = [...detectorWarnings, ...this.warnings];
+      const preparedReport = {
         flow: "no-patches",
         patchesDetected: newPatches.length,
         patchesApplied: 0,
@@ -16268,9 +16819,43 @@ var ReplayService = class {
         patchesReverted: revertedPatchIds.length,
         conflicts: [],
         wouldApply: newPatches,
-        warnings: warnings.length > 0 ? warnings : void 0
+        warnings: dryRunWarnings.length > 0 ? dryRunWarnings : void 0
+      };
+      const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+      return {
+        flow: "no-patches",
+        previousGenerationSha,
+        currentGenerationSha: headSha,
+        baseBranchHead: options.baseBranchHead ?? null,
+        _prepared: {
+          flow: "no-patches",
+          terminal: true,
+          preparedReport,
+          patchesToApply: [],
+          newPatchIds: /* @__PURE__ */ new Set(),
+          detectorWarnings,
+          revertedCount: revertedPatchIds.length,
+          genSha: headSha,
+          optionsSnapshot: options
+        }
       };
     }
+    {
+      const preCurrentGen = preLock.current_generation;
+      const uniqueFiles = [...new Set(newPatches.flatMap((p) => p.files))];
+      const absorbedFiles = /* @__PURE__ */ new Set();
+      for (const file of uniqueFiles) {
+        const diff = await this.git.exec(["diff", preCurrentGen, "HEAD", "--", file]).catch(() => null);
+        if (diff !== null && !diff.trim()) {
+          absorbedFiles.add(file);
+        }
+      }
+      if (absorbedFiles.size > 0) {
+        newPatches = newPatches.filter(
+          (p) => p.files.length === 0 || !p.files.every((f) => absorbedFiles.has(f))
+        );
+      }
+    }
     for (const id of revertedPatchIds) {
       try {
         this.lockManager.removePatch(id);
@@ -16286,9 +16871,31 @@ var ReplayService = class {
     await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
     this.lockManager.addGeneration(genRecord);
+    return {
+      flow: "no-patches",
+      previousGenerationSha,
+      currentGenerationSha: genRecord.commit_sha,
+      baseBranchHead: options?.baseBranchHead ?? null,
+      _prepared: {
+        flow: "no-patches",
+        terminal: false,
+        patchesToApply: newPatches,
+        newPatchIds: new Set(newPatches.map((p) => p.id)),
+        detectorWarnings,
+        revertedCount: revertedPatchIds.length,
+        genSha: genRecord.commit_sha,
+        optionsSnapshot: options
+      }
+    };
+  }
+  async _applyNoPatchesRegeneration(prep, options) {
+    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.revertConflictingFiles(results);
       for (const result of results) {
         if (result.status === "conflict") {
@@ -16296,13 +16903,14 @@ var ReplayService = class {
         }
       }
     }
-    const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
+    const rebaseCounts = await this.rebasePatches(results, genSha);
     for (const patch of newPatches) {
       if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
         this.lockManager.addPatch(patch);
       }
     }
     this.lockManager.save();
+    this.warnings.push(...this.lockManager.warnings);
     if (newPatches.length > 0) {
       if (!options?.stageOnly) {
         const appliedCount = results.filter((r) => r.status === "applied").length;
@@ -16311,15 +16919,27 @@ var ReplayService = class {
         await this.committer.stageAll();
       }
     }
-    return this.buildReport("no-patches", newPatches, results, options, warnings, rebaseCounts, void 0, revertedPatchIds.length);
+    const warnings = [...detectorWarnings, ...this.warnings];
+    return this.buildReport(
+      "no-patches",
+      newPatches,
+      results,
+      prep._prepared.optionsSnapshot,
+      warnings,
+      rebaseCounts,
+      void 0,
+      prep._prepared.revertedCount
+    );
   }
-  async handleNormalRegeneration(options) {
+  async _prepareNormalRegeneration(options) {
+    const preLock = this.lockManager.read();
+    const previousGenerationSha = preLock.current_generation ?? null;
     if (options?.dryRun) {
       const existingPatches2 = this.lockManager.getPatches();
       const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.detector.detectNewPatches();
-      const warnings2 = [...this.detector.warnings];
+      const warnings = [...this.detector.warnings, ...this.warnings];
       const allPatches2 = [...existingPatches2, ...newPatches2];
-      return {
+      const preparedReport = {
         flow: "normal-regeneration",
         patchesDetected: allPatches2.length,
         patchesApplied: 0,
@@ -16328,7 +16948,25 @@ var ReplayService = class {
         patchesReverted: dryRunReverted.length,
         conflicts: [],
         wouldApply: allPatches2,
-        warnings: warnings2.length > 0 ? warnings2 : void 0
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+      const headSha = await this.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
+      return {
+        flow: "normal-regeneration",
+        previousGenerationSha,
+        currentGenerationSha: headSha,
+        baseBranchHead: options.baseBranchHead ?? null,
+        _prepared: {
+          flow: "normal-regeneration",
+          terminal: true,
+          preparedReport,
+          patchesToApply: [],
+          newPatchIds: /* @__PURE__ */ new Set(),
+          detectorWarnings: [...this.detector.warnings],
+          revertedCount: dryRunReverted.length,
+          genSha: headSha,
+          optionsSnapshot: options
+        }
       };
     }
     let existingPatches = this.lockManager.getPatches();
@@ -16349,7 +16987,7 @@ var ReplayService = class {
     }
     existingPatches = this.lockManager.getPatches();
     let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
-    const warnings = [...this.detector.warnings];
+    const detectorWarnings = [...this.detector.warnings];
     if (removedByPreRebase.length > 0) {
       const removedOriginalCommits = new Set(removedByPreRebase.map((p) => p.original_commit));
       const removedOriginalMessages = new Set(removedByPreRebase.map((p) => p.original_message));
@@ -16380,14 +17018,39 @@ var ReplayService = class {
     await this.cleanupStaleConflictMarkers();
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
     this.lockManager.addGeneration(genRecord);
+    return {
+      flow: "normal-regeneration",
+      previousGenerationSha,
+      currentGenerationSha: genRecord.commit_sha,
+      baseBranchHead: options?.baseBranchHead ?? null,
+      _prepared: {
+        flow: "normal-regeneration",
+        terminal: false,
+        patchesToApply: allPatches,
+        newPatchIds: new Set(newPatches.map((p) => p.id)),
+        preRebaseCounts,
+        detectorWarnings,
+        revertedCount: revertedPatchIds.length,
+        genSha: genRecord.commit_sha,
+        optionsSnapshot: options
+      }
+    };
+  }
+  async _applyNormalRegeneration(prep, options) {
+    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.revertConflictingFiles(results);
     for (const result of results) {
       if (result.status === "conflict") {
         result.patch.status = "unresolved";
       }
     }
-    const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
+    const rebaseCounts = await this.rebasePatches(results, genSha);
+    const newPatches = allPatches.filter((p) => newPatchIds.has(p.id));
     for (const patch of newPatches) {
       if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
         this.lockManager.addPatch(patch);
@@ -16402,21 +17065,23 @@ var ReplayService = class {
       }
     }
     this.lockManager.save();
+    this.warnings.push(...this.lockManager.warnings);
     if (options?.stageOnly) {
       await this.committer.stageAll();
     } else {
       const appliedCount = results.filter((r) => r.status === "applied").length;
       await this.committer.commitReplay(appliedCount, allPatches);
     }
+    const warnings = [...detectorWarnings, ...this.warnings];
     return this.buildReport(
       "normal-regeneration",
       allPatches,
       results,
-      options,
+      prep._prepared.optionsSnapshot,
       warnings,
       rebaseCounts,
-      preRebaseCounts,
-      revertedPatchIds.length
+      prep._prepared.preRebaseCounts,
+      prep._prepared.revertedCount
     );
   }
   /**
@@ -16431,6 +17096,7 @@ var ReplayService = class {
     let keptAsUserOwned = 0;
     const seenContentHashes = /* @__PURE__ */ new Set();
     const absorbedPatchIds = /* @__PURE__ */ new Set();
+    const fernignorePatterns = this.readFernignorePatterns();
     for (const result of results) {
       if (result.resolvedFiles && Object.keys(result.resolvedFiles).length > 0) {
         const patch = result.patch;
@@ -16451,34 +17117,78 @@ var ReplayService = class {
       const patch = result.patch;
       if (patch.base_generation === currentGenSha) continue;
       try {
-        const fernignorePatterns = this.readFernignorePatterns();
-        const isUserOwned = await Promise.all(
+        const originalByResolved = {};
+        if (result.resolvedFiles) {
+          for (const [orig, resolved] of Object.entries(result.resolvedFiles)) {
+            originalByResolved[resolved] = orig;
+          }
+        }
+        const isUserOwnedPerFile = await Promise.all(
           patch.files.map(async (file) => {
-            if (file === ".fernignore") {
+            if (file === ".fernignore") return true;
+            if (fernignorePatterns.some((p) => file === p || minimatch(file, p))) {
               return true;
             }
-            if (fernignorePatterns.some((p) => file === p || minimatch(file, p))) {
+            if (patch.user_owned) return true;
+            if (this.fileIsCreationInPatchContent(patch.patch_content, originalByResolved[file] ?? file)) {
               return true;
             }
             const content = await this.git.showFile(currentGenSha, file);
             return content === null;
           })
         );
-        const hasUserOwnedFiles = isUserOwned.some(Boolean);
-        if (hasUserOwnedFiles) {
-          this.lockManager.updatePatch(patch.id, {
-            base_generation: currentGenSha
-          });
+        const hasProtectedFiles = patch.files.some(
+          (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || minimatch(file, p))
+        );
+        const allUserOwned = isUserOwnedPerFile.every(Boolean);
+        if (allUserOwned && patch.files.length > 0) {
+          const baseChanged = patch.base_generation !== currentGenSha;
+          const userDiff = await this.git.exec(["diff", currentGenSha, "--", ...patch.files]).catch(() => null);
+          if (userDiff != null && userDiff.trim()) {
+            const newHash = this.detector.computeContentHash(userDiff);
+            patch.patch_content = userDiff;
+            patch.content_hash = newHash;
+          }
+          patch.base_generation = currentGenSha;
+          try {
+            this.lockManager.updatePatch(patch.id, {
+              base_generation: currentGenSha,
+              ...!patch.user_owned ? { user_owned: true } : {},
+              ...userDiff != null && userDiff.trim() ? { patch_content: patch.patch_content, content_hash: patch.content_hash } : {}
+            });
+          } catch {
+          }
+          patch.user_owned = true;
           keptAsUserOwned++;
+          if (baseChanged) repointed++;
           continue;
         }
         const diff = await this.git.exec(["diff", currentGenSha, "--", ...patch.files]).catch(() => null);
-        if (!diff || !diff.trim()) {
+        if (diff === null) continue;
+        if (!diff.trim()) {
+          if (hasProtectedFiles) {
+            patch.base_generation = currentGenSha;
+            try {
+              this.lockManager.updatePatch(patch.id, { base_generation: currentGenSha });
+            } catch {
+            }
+            keptAsUserOwned++;
+            continue;
+          }
           this.lockManager.removePatch(patch.id);
           absorbedPatchIds.add(patch.id);
           absorbed++;
           continue;
         }
+        if (hasProtectedFiles) {
+          patch.base_generation = currentGenSha;
+          try {
+            this.lockManager.updatePatch(patch.id, { base_generation: currentGenSha });
+          } catch {
+          }
+          keptAsUserOwned++;
+          continue;
+        }
         const newContentHash = this.detector.computeContentHash(diff);
         if (seenContentHashes.has(newContentHash)) {
           this.lockManager.removePatch(patch.id);
@@ -16487,17 +17197,89 @@ var ReplayService = class {
           continue;
         }
         seenContentHashes.add(newContentHash);
-        this.lockManager.updatePatch(patch.id, {
-          base_generation: currentGenSha,
-          patch_content: diff,
-          content_hash: newContentHash
-        });
+        patch.base_generation = currentGenSha;
+        patch.patch_content = diff;
+        patch.content_hash = newContentHash;
+        try {
+          this.lockManager.updatePatch(patch.id, {
+            base_generation: currentGenSha,
+            patch_content: diff,
+            content_hash: newContentHash
+          });
+        } catch {
+        }
         contentRebased++;
       } catch {
       }
     }
     return { absorbed, repointed, contentRebased, keptAsUserOwned, absorbedPatchIds };
   }
+  /**
+   * Determine whether `file` is user-owned (never produced by the generator).
+   *
+   * Resolution order (first match wins):
+   *  1. `patch.user_owned === true` — authoritative, persisted across cycles.
+   *  2. `.fernignore` itself, or file matches a .fernignore pattern.
+   *  3. Legacy-safe signal: `patch_content` shows this file as a `--- /dev/null`
+   *     creation. Works for patches that predate the `user_owned` field or
+   *     whose flag was lost. Immune to rename tricks — relies on raw patch text.
+   *  4. Tree-based check against `patch.base_generation` when it is reachable
+   *     AND distinct from `currentGenSha`. If the base tree is unreachable
+   *     (shallow clone / aggressive `git gc --prune`), emit a one-time
+   *     customer-actionable warning (deduplicated via warnedGens) and
+   *     conservatively treat as user-owned — strictly safer than silent
+   *     absorption (FER-9809).
+   *  5. Final fallback — check `currentGenSha` when there is no usable base
+   *     (legacy one-gen lockfile). Preserves pre-fix behavior for that edge.
+   *
+   * `originalFileName` is the pre-rename path when the generator moved the
+   * file between the patch's base and the current generation. Tree lookups
+   * at ancestor generations use the original path — that's where the
+   * generator produced the content.
+   */
+  async isFileUserOwned(file, patch, currentGenSha, fernignorePatterns, warnedGens, originalFileName) {
+    if (patch.user_owned) return true;
+    if (file === ".fernignore") return true;
+    if (fernignorePatterns.some((p) => file === p || minimatch(file, p))) return true;
+    if (this.fileIsCreationInPatchContent(patch.patch_content, originalFileName ?? file)) {
+      return true;
+    }
+    const base = patch.base_generation;
+    if (base && base !== currentGenSha) {
+      const reachable = await this.git.commitExists(base) || await this.git.treeExists(base);
+      if (!reachable) {
+        if (!warnedGens.has(base)) {
+          warnedGens.add(base);
+          this.warnings.push(
+            `Base generation ${base.slice(0, 7)} is unreachable (shallow clone or pruned history). Treating affected files as user-owned to avoid silent data loss. Run \`git fetch --unshallow\` or avoid \`git gc --prune\` to restore full history.`
+          );
+        }
+        return true;
+      }
+      return await this.git.showFile(base, originalFileName ?? file) === null;
+    }
+    return await this.git.showFile(currentGenSha, originalFileName ?? file) === null;
+  }
+  /**
+   * Returns true if `file`'s diff section in `patchContent` starts with
+   * `--- /dev/null`, meaning this file was introduced by the patch (user
+   * creation). Used as a legacy-safe fallback when `patch.user_owned` is
+   * absent or cleared.
+   */
+  fileIsCreationInPatchContent(patchContent, file) {
+    const lines = patchContent.split("\n");
+    let inFileSection = false;
+    for (const line of lines) {
+      if (line.startsWith("diff --git ")) {
+        inFileSection = line.includes(` b/${file}`) || line.endsWith(` b/${file}`);
+        continue;
+      }
+      if (inFileSection && line.startsWith("--- ")) {
+        return line === "--- /dev/null";
+      }
+    }
+    return false;
+  }
   /**
    * For conflict patches with mixed results (some files merged, some conflicted),
    * check if the cleanly merged files were absorbed by the generator (empty diff).
@@ -16511,13 +17293,14 @@ var ReplayService = class {
     const cleanFiles = result.fileResults.filter((f) => f.status === "merged").map((f) => f.file);
     if (cleanFiles.length === 0) return;
     const patch = result.patch;
+    if (patch.user_owned) return;
     const fernignorePatterns = this.readFernignorePatterns();
+    const warnedGens = /* @__PURE__ */ new Set();
     const generatorCleanFiles = [];
     for (const file of cleanFiles) {
-      if (file === ".fernignore") continue;
-      if (fernignorePatterns.some((p) => file === p || minimatch(file, p))) continue;
-      const content = await this.git.showFile(currentGenSha, file);
-      if (content === null) continue;
+      if (await this.isFileUserOwned(file, patch, currentGenSha, fernignorePatterns, warnedGens)) {
+        continue;
+      }
       generatorCleanFiles.push(file);
     }
     if (generatorCleanFiles.length === 0) return;
@@ -16554,7 +17337,35 @@ var ReplayService = class {
     let conflictResolved = 0;
     let conflictAbsorbed = 0;
     let contentRefreshed = 0;
+    const fernignorePatterns = this.readFernignorePatterns();
+    const warnedGens = /* @__PURE__ */ new Set();
+    const reachabilityCache = /* @__PURE__ */ new Map();
+    const isReachable = async (sha) => {
+      const cached = reachabilityCache.get(sha);
+      if (cached !== void 0) return cached;
+      const reachable = await this.git.commitExists(sha) || await this.git.treeExists(sha);
+      reachabilityCache.set(sha, reachable);
+      return reachable;
+    };
+    const allPatchFilesUserOwned = async (patch) => {
+      if (patch.user_owned) return true;
+      if (patch.files.length === 0) return false;
+      for (const file of patch.files) {
+        if (!await this.isFileUserOwned(file, patch, currentGen, fernignorePatterns, warnedGens)) {
+          return false;
+        }
+      }
+      return true;
+    };
     for (const patch of patches) {
+      if (patch.base_generation && patch.base_generation !== currentGen && !warnedGens.has(patch.base_generation)) {
+        if (!await isReachable(patch.base_generation)) {
+          warnedGens.add(patch.base_generation);
+          this.warnings.push(
+            `Base generation ${patch.base_generation.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.`
+          );
+        }
+      }
       if (patch.status != null) {
         delete patch.status;
         continue;
@@ -16564,6 +17375,7 @@ var ReplayService = class {
           const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
           if (diff === null) continue;
           if (!diff.trim()) {
+            if (await allPatchFilesUserOwned(patch)) continue;
             this.lockManager.removePatch(patch.id);
             contentRefreshed++;
             continue;
@@ -16575,6 +17387,12 @@ var ReplayService = class {
           if (hasStaleMarkers) {
             continue;
           }
+          const isProtected = patch.files.some(
+            (file) => file === ".fernignore" || fernignorePatterns.some((p) => file === p || minimatch(file, p))
+          );
+          if (isProtected) {
+            continue;
+          }
           const newContentHash = this.detector.computeContentHash(diff);
           if (newContentHash !== patch.content_hash) {
             const filesOutput = await this.git.exec(["diff", "--name-only", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
@@ -16600,6 +17418,13 @@ var ReplayService = class {
         const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
         if (diff === null) continue;
         if (!diff.trim()) {
+          if (await allPatchFilesUserOwned(patch)) {
+            try {
+              this.lockManager.updatePatch(patch.id, { base_generation: currentGen });
+            } catch {
+            }
+            continue;
+          }
           this.lockManager.removePatch(patch.id);
           conflictAbsorbed++;
           continue;
@@ -17110,7 +17935,10 @@ function ensureGitattributesEntries(outputDir) {
   (0, import_node_fs4.writeFileSync)(gitattributesPath, content, "utf-8");
 }
 function computeContentHash(patchContent) {
-  const normalized = patchContent.split("\n").filter((line) => !line.startsWith("From ") && !line.startsWith("index ") && !line.startsWith("Date: ")).join("\n");
+  const lines = patchContent.split("\n");
+  const diffStart = lines.findIndex((l) => l.startsWith("diff --git "));
+  const relevantLines = diffStart > 0 ? lines.slice(diffStart) : lines;
+  const normalized = relevantLines.filter((line) => !line.startsWith("index ")).join("\n").replace(/\n-- \n[\d]+\.[\d]+[^\n]*\s*$/, "");
   return `sha256:${(0, import_node_crypto3.createHash)("sha256").update(normalized).digest("hex")}`;
 }