@fern-api/generator-cli 0.9.8 → 0.9.9

package/dist/cli.js

@@ -20098,9 +20098,10 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.10.4/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.11.0/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  CREDENTIAL_PATTERNS: () => CREDENTIAL_PATTERNS,
   FERN_BOT_EMAIL: () => FERN_BOT_EMAIL2,
   FERN_BOT_LOGIN: () => FERN_BOT_LOGIN2,
   FERN_BOT_NAME: () => FERN_BOT_NAME2,
@@ -20112,15 +20113,18 @@ __export(dist_exports, {
   ReplayCommitter: () => ReplayCommitter,
   ReplayDetector: () => ReplayDetector,
   ReplayService: () => ReplayService,
+  SENSITIVE_FILE_PATTERNS: () => SENSITIVE_FILE_PATTERNS,
   bootstrap: () => bootstrap,
   forget: () => forget,
   isGenerationCommit: () => isGenerationCommit,
   isReplayCommit: () => isReplayCommit,
   isRevertCommit: () => isRevertCommit,
+  isSensitiveFile: () => isSensitiveFile,
   parseRevertedMessage: () => parseRevertedMessage,
   parseRevertedSha: () => parseRevertedSha,
   reset: () => reset,
   resolve: () => resolve7,
+  scanForCredentials: () => scanForCredentials,
   status: () => status,
   threeWayMerge: () => threeWayMerge
 });
@@ -20359,6 +20363,18 @@ function reconstructFromGhostPatch(fileDiff, ours) {
   }
   return assembleHybrid(located, oursLines);
 }
+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;
+}
 function isGenerationCommit(commit) {
   const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
   const isBotAuthor = !isFernSupport && (commit.authorLogin === FERN_BOT_LOGIN2 || commit.authorEmail === FERN_BOT_EMAIL2 || commit.authorName === FERN_BOT_NAME2);
@@ -20382,6 +20398,37 @@ function parseRevertedMessage(subject) {
   const match2 = subject.match(/^Revert "(.+)"$/);
   return match2?.[1];
 }
+function parsePatchFileHeaders(patchContent) {
+  const results = [];
+  let currentPath = null;
+  let currentIsCreate = false;
+  let currentIsDelete = false;
+  const 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;
+}
 function threeWayMerge(base, ours, theirs) {
   const baseLines = base.split("\n");
   const oursLines = ours.split("\n");
@@ -20771,7 +20818,10 @@ function ensureGitattributesEntries(outputDir) {
   (0, import_fs9.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_crypto3.createHash)("sha256").update(normalized).digest("hex")}`;
 }
 function parseDiffStat(patchContent) {
@@ -21061,9 +21111,9 @@ function status(outputDir) {
     excludePatterns
   };
 }
-var import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os, import_path9, import_fs7, import_path10, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, FERN_BOT_NAME2, FERN_BOT_EMAIL2, FERN_BOT_LOGIN2, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
+var import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os, import_path9, import_fs7, import_path10, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, CREDENTIAL_PATTERNS, SENSITIVE_FILE_PATTERNS, FERN_BOT_NAME2, FERN_BOT_EMAIL2, FERN_BOT_LOGIN2, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileNotFoundError, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, CONFLICT_OPENER, CONFLICT_SEPARATOR, CONFLICT_CLOSER, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
 var init_dist3 = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.10.4/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.11.0/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_fs6 = require("fs");
@@ -21163,13 +21213,30 @@ var init_dist3 = __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] });
@@ -21226,6 +21293,25 @@ var init_dist3 = __esm({
         "use strict";
       }
     });
+    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/ }
+    ];
+    SENSITIVE_FILE_PATTERNS = [
+      /(^|\/)\.env(\.[^/]+)?$/,
+      /\.pem$/,
+      /\.key$/,
+      /\.pkce_state\.json$/,
+      /(^|\/)id_rsa$/,
+      /(^|\/)id_ed25519$/
+    ];
     init_GitClient();
     FERN_BOT_NAME2 = "fern-api";
     FERN_BOT_EMAIL2 = "115122769+fern-api[bot]@users.noreply.github.com";
@@ -21241,6 +21327,7 @@ var init_dist3 = __esm({
     LockfileManager = class {
       outputDir;
       lock = null;
+      warnings = [];
       constructor(outputDir) {
         this.outputDir = outputDir;
       }
@@ -21289,6 +21376,27 @@ var init_dist3 = __esm({
         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((f2) => isSensitiveFile(f2));
+          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_path8.dirname)(this.lockfilePath);
         if (!(0, import_fs6.existsSync)(dir)) {
           (0, import_fs6.mkdirSync)(dir, { recursive: true });
@@ -21468,12 +21576,31 @@ var init_dist3 = __esm({
             );
             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((f2) => !INFRASTRUCTURE_FILES.has(f2));
+          const allFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
+          const sensitiveFiles = allFiles.filter((f2) => isSensitiveFile(f2));
+          const files = allFiles.filter((f2) => !isSensitiveFile(f2));
+          if (sensitiveFiles.length > 0) {
+            this.warnings.push(
+              `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
+            );
+            if (files.length > 0) {
+              const parentSha = parents[0];
+              if (parentSha) {
+                try {
+                  patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
+                } catch {
+                  continue;
+                }
+                if (!patchContent.trim()) continue;
+                contentHash = this.computeContentHash(patchContent);
+              }
+            }
+          }
           if (files.length === 0) {
             continue;
           }
@@ -21485,14 +21612,16 @@ var init_dist3 = __esm({
             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 {
@@ -21521,7 +21650,7 @@ var init_dist3 = __esm({
           if (matchedExisting) continue;
           let matchedNew = false;
           if (revertedSha) {
-            const idx = newPatches.findIndex(
+            const idx = survivingPatches.findIndex(
               (p, j2) => j2 !== i && !revertIndicesToRemove.has(j2) && p.original_commit === revertedSha
             );
             if (idx !== -1) {
@@ -21531,7 +21660,7 @@ var init_dist3 = __esm({
             }
           }
           if (!matchedNew && revertedMessage) {
-            const idx = newPatches.findIndex(
+            const idx = survivingPatches.findIndex(
               (p, j2) => j2 !== i && !revertIndicesToRemove.has(j2) && p.original_message === revertedMessage
             );
             if (idx !== -1) {
@@ -21543,18 +21672,107 @@ var init_dist3 = __esm({
             revertIndicesToRemove.add(i);
           }
         }
-        const filteredPatches = newPatches.filter((_2, i) => !revertIndicesToRemove.has(i));
+        const filteredPatches = survivingPatches.filter((_2, 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_crypto.createHash)("sha256").update(normalized).digest("hex")}`;
       }
+      /**
+       * FER-9805 — Drop patches whose files were transiently created and then
+       * deleted within the current linear detection window, and are absent from
+       * HEAD at the end of the window.
+       *
+       * Rationale: on a merge commit, createMergeCompositePatch already diffs
+       * firstParent..mergeCommit so net-zero files never enter the composite. On
+       * linear history each commit becomes its own patch, so a file that was
+       * briefly added and later removed survives as a create+delete pair whose
+       * cumulative diff is empty. We drop such patches before they reach the
+       * lockfile.
+       *
+       * A file is "transient" when:
+       *   1. some patch in the window sets `new file mode` for it (a creation), AND
+       *   2. some patch in the window sets `deleted file mode` for it (a deletion), AND
+       *   3. it is absent from HEAD's tree.
+       *
+       * The HEAD guard (#3) prevents false positives when a file is deleted
+       * and then recreated with different content — the cumulative diff of
+       * such a pair is non-empty and must be preserved.
+       *
+       * This only drops patches whose `files` are a subset of the transient
+       * set. A partial-transient patch (one that touches a transient file
+       * alongside a persistent one) is left unmodified; surgical stripping of
+       * single files from a multi-file patch would require a follow-up that
+       * regenerates the patch content via `git format-patch -- <files>`. No
+       * current failing test exercises this, and leaving the patch intact
+       * preserves today's behaviour. TODO(FER-9805): revisit if a future
+       * adversarial test demands per-file stripping.
+       */
+      async collapseNetZeroFiles(patches) {
+        if (patches.length === 0) return patches;
+        const stateByFile = /* @__PURE__ */ new Map();
+        for (const patch of patches) {
+          for (const header of parsePatchFileHeaders(patch.patch_content)) {
+            if (!header.isCreate && !header.isDelete) continue;
+            const prior = stateByFile.get(header.path) ?? { created: false, deleted: false };
+            if (header.isCreate) prior.created = true;
+            if (header.isDelete) prior.deleted = true;
+            stateByFile.set(header.path, prior);
+          }
+        }
+        let anyCandidate = false;
+        for (const state of stateByFile.values()) {
+          if (state.created && state.deleted) {
+            anyCandidate = true;
+            break;
+          }
+        }
+        if (!anyCandidate) return patches;
+        const headFiles = await this.listHeadFiles();
+        const transient = /* @__PURE__ */ new Set();
+        for (const [file, state] of stateByFile) {
+          if (state.created && state.deleted && !headFiles.has(file)) {
+            transient.add(file);
+          }
+        }
+        if (transient.size === 0) return patches;
+        return patches.filter((patch) => !patch.files.every((f2) => transient.has(f2)));
+      }
+      /**
+       * List every tracked path at HEAD (one `git ls-tree -r` invocation).
+       * Returns an empty Set if HEAD is unborn or the invocation fails — the
+       * caller then treats every candidate as "not in HEAD" and may collapse
+       * more aggressively. On typical SDK repos this is a single sub-10ms call.
+       */
+      async listHeadFiles() {
+        try {
+          const out = await this.git.exec(["ls-tree", "-r", "--name-only", "HEAD"]);
+          return new Set(out.split("\n").map((l) => l.trim()).filter(Boolean));
+        } catch {
+          return /* @__PURE__ */ new Set();
+        }
+      }
       /**
        * Create a single composite patch for a merge commit by diffing the merge
        * commit against its first parent. This captures the net change of the
@@ -21570,7 +21788,14 @@ var init_dist3 = __esm({
           firstParent,
           mergeCommit.sha
         ]);
-        const files = filesOutput.trim().split("\n").filter(Boolean).filter((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
+        const allMergeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
+        const sensitiveMergeFiles = allMergeFiles.filter((f2) => isSensitiveFile(f2));
+        const files = allMergeFiles.filter((f2) => !isSensitiveFile(f2));
+        if (sensitiveMergeFiles.length > 0) {
+          this.warnings.push(
+            `Sensitive file(s) excluded from merge patch for commit ${mergeCommit.sha.slice(0, 7)}: ${sensitiveMergeFiles.join(", ")}. These files will not be tracked by replay.`
+          );
+        }
         if (files.length === 0) return null;
         const diff = await this.git.exec([
           "diff",
@@ -21592,7 +21817,8 @@ var init_dist3 = __esm({
           original_author: `${mergeCommit.authorName} <${mergeCommit.authorEmail}>`,
           base_generation: lastGen.commit_sha,
           files,
-          patch_content: diff
+          patch_content: diff,
+          ...this.isCreationOnlyPatch(diff) ? { user_owned: true } : {}
         };
       }
       /**
@@ -21606,7 +21832,14 @@ var init_dist3 = __esm({
           return this.detectPatchesViaCommitScan();
         }
         const filesOutput = await this.git.exec(["diff", "--name-only", diffBase, "HEAD"]);
-        const files = filesOutput.trim().split("\n").filter(Boolean).filter((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
+        const allTreeFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f2) => !INFRASTRUCTURE_FILES.has(f2)).filter((f2) => !f2.startsWith(".fern/"));
+        const sensitiveTreeFiles = allTreeFiles.filter((f2) => isSensitiveFile(f2));
+        const files = allTreeFiles.filter((f2) => !isSensitiveFile(f2));
+        if (sensitiveTreeFiles.length > 0) {
+          this.warnings.push(
+            `Sensitive file(s) excluded from composite patch: ${sensitiveTreeFiles.join(", ")}. These files will not be tracked by replay.`
+          );
+        }
         if (files.length === 0) return { patches: [], revertedPatchIds: [] };
         const diff = await this.git.exec(["diff", diffBase, "HEAD", "--", ...files]);
         if (!diff.trim()) return { patches: [], revertedPatchIds: [] };
@@ -21626,7 +21859,8 @@ var init_dist3 = __esm({
           // 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: [] };
       }
@@ -21673,7 +21907,7 @@ var init_dist3 = __esm({
           } catch {
             continue;
           }
-          const contentHash = this.computeContentHash(patchContent);
+          let contentHash = this.computeContentHash(patchContent);
           if (existingHashes.has(contentHash) || forgottenHashes.has(contentHash)) {
             continue;
           }
@@ -21681,7 +21915,26 @@ var init_dist3 = __esm({
             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((f2) => !INFRASTRUCTURE_FILES.has(f2));
+          const allScanFiles = filesOutput.trim().split("\n").filter(Boolean).filter((f2) => !INFRASTRUCTURE_FILES.has(f2));
+          const sensitiveScanFiles = allScanFiles.filter((f2) => isSensitiveFile(f2));
+          const files = allScanFiles.filter((f2) => !isSensitiveFile(f2));
+          if (sensitiveScanFiles.length > 0) {
+            this.warnings.push(
+              `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${sensitiveScanFiles.join(", ")}. These files will not be tracked by replay.`
+            );
+            if (files.length > 0) {
+              if (parents.length === 0) {
+                continue;
+              }
+              try {
+                patchContent = await this.git.exec(["diff", parents[0], commit.sha, "--", ...files]);
+              } catch {
+                continue;
+              }
+              if (!patchContent.trim()) continue;
+              contentHash = this.computeContentHash(patchContent);
+            }
+          }
           if (files.length === 0) {
             continue;
           }
@@ -21828,6 +22081,20 @@ var init_dist3 = __esm({
       resetAccumulator() {
         this.fileTheirsAccumulator.clear();
       }
+      /**
+       * @internal Test-only.
+       * Returns a defensive copy of the inter-patch accumulator. Used by the
+       * adversarial test suite (FER-9791) to assert invariant I2: after every
+       * applied patch, the accumulator has an entry for each file the patch
+       * touched, and the entry's content matches on-disk.
+       */
+      getAccumulatorSnapshot() {
+        const snapshot = /* @__PURE__ */ new Map();
+        for (const [path5, entry] of this.fileTheirsAccumulator) {
+          snapshot.set(path5, { content: entry.content, baseGeneration: entry.baseGeneration });
+        }
+        return snapshot;
+      }
       /**
        * Apply all patches, returning results for each.
        * Skips patches that match exclude patterns in replay.yml
@@ -21893,7 +22160,7 @@ var init_dist3 = __esm({
             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_promises4.readFile)((0, import_path9.join)(this.outputDir, resolvedPath), "utf-8").catch(() => null);
-            if (effectiveTheirs) {
+            if (effectiveTheirs != null) {
               this.fileTheirsAccumulator.set(resolvedPath, {
                 content: effectiveTheirs,
                 baseGeneration: patch.base_generation
@@ -21917,16 +22184,20 @@ var init_dist3 = __esm({
             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_path9.join)(this.outputDir, resolvedPath);
-            snapshots.set(resolvedPath, await (0, import_promises4.readFile)(fullPath, "utf-8").catch(() => null));
+            const fullPath = (0, import_path9.join)(this.outputDir, filePath);
+            snapshots.set(filePath, await (0, import_promises4.readFile)(fullPath, "utf-8").catch(() => null));
           }
           try {
             await this.git.execWithInput(["apply", "--3way"], patch.patch_content);
@@ -21938,8 +22209,8 @@ var init_dist3 = __esm({
               ...Object.keys(resolvedFiles).length > 0 && { resolvedFiles }
             };
           } catch {
-            for (const [resolvedPath, content] of snapshots) {
-              const fullPath = (0, import_path9.join)(this.outputDir, resolvedPath);
+            for (const [filePath, content] of snapshots) {
+              const fullPath = (0, import_path9.join)(this.outputDir, filePath);
               if (content != null) {
                 await (0, import_promises4.writeFile)(fullPath, content);
               } else {
@@ -22059,7 +22330,7 @@ var init_dist3 = __esm({
           }
           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,
@@ -22067,7 +22338,16 @@ var init_dist3 = __esm({
               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;
             }
           }
@@ -22084,7 +22364,7 @@ var init_dist3 = __esm({
           }
           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);
@@ -22100,7 +22380,7 @@ var init_dist3 = __esm({
               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
@@ -22110,7 +22390,7 @@ var init_dist3 = __esm({
             await (0, import_promises4.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_path9.dirname)(oursPath);
             await (0, import_promises4.mkdir)(outDir2, { recursive: true });
@@ -22124,16 +22404,20 @@ var init_dist3 = __esm({
                 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",
@@ -22152,7 +22436,7 @@ var init_dist3 = __esm({
           const outDir = (0, import_path9.dirname)(oursPath);
           await (0, import_promises4.mkdir)(outDir, { recursive: true });
           await (0, import_promises4.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
@@ -22250,6 +22534,28 @@ var init_dist3 = __esm({
           return null;
         }
       }
+      /**
+       * Detects whether a patch's additions are already present in `content`.
+       * Uses `git apply --reverse --check` — if the reverse patch applies cleanly,
+       * the forward patch is effectively a no-op (its +lines are already there and
+       * its -lines are already gone). Used to distinguish "patch already applied"
+       * from "patch base mismatch" after a forward-apply fails.
+       */
+      async isPatchAlreadyApplied(patchContent, filePath, content, tempGit, tempDir) {
+        const fileDiff = this.extractFileDiff(patchContent, filePath);
+        if (!fileDiff) return false;
+        try {
+          const tempFilePath = (0, import_path9.join)(tempDir, filePath);
+          await (0, import_promises4.mkdir)((0, import_path9.dirname)(tempFilePath), { recursive: true });
+          await (0, import_promises4.writeFile)(tempFilePath, content);
+          await tempGit.exec(["add", filePath]);
+          await tempGit.exec(["commit", "-m", `check already-applied ${filePath}`, "--allow-empty"]);
+          await tempGit.execWithInput(["apply", "--reverse", "--check", "--allow-empty"], fileDiff);
+          return true;
+        } catch {
+          return false;
+        }
+      }
       extractFileDiff(patchContent, filePath) {
         const lines = patchContent.split("\n");
         const diffLines = [];
@@ -22403,6 +22709,33 @@ CLI Version: ${options.cliVersion}`;
       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;
@@ -22413,6 +22746,7 @@ CLI Version: ${options.cliVersion}`;
         this.committer = new ReplayCommitter(git, outputDir);
       }
       async runReplay(options) {
+        this.warnings = [];
         if (options?.skipApplication) {
           return this.handleSkipApplication(options);
         }
@@ -22486,6 +22820,7 @@ CLI Version: ${options.cliVersion}`;
           );
         }
         this.lockManager.save();
+        this.detector.warnings.push(...this.lockManager.warnings);
       }
       determineFlow() {
         try {
@@ -22552,6 +22887,7 @@ CLI Version: ${options.cliVersion}`;
         }
         this.lockManager.setReplaySkippedAt((/* @__PURE__ */ new Date()).toISOString());
         this.lockManager.save();
+        const credentialWarnings = [...this.lockManager.warnings];
         if (!options?.stageOnly) {
           await this.committer.commitReplay(0);
         } else {
@@ -22563,13 +22899,15 @@ CLI Version: ${options.cliVersion}`;
           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];
+        let { patches: newPatches, revertedPatchIds } = await this.detector.detectNewPatches();
+        const detectorWarnings = [...this.detector.warnings];
         if (options?.dryRun) {
+          const dryRunWarnings = [...detectorWarnings, ...this.warnings];
           return {
             flow: "no-patches",
             patchesDetected: newPatches.length,
@@ -22579,9 +22917,26 @@ CLI Version: ${options.cliVersion}`;
             patchesReverted: revertedPatchIds.length,
             conflicts: [],
             wouldApply: newPatches,
-            warnings: warnings.length > 0 ? warnings : void 0
+            warnings: dryRunWarnings.length > 0 ? dryRunWarnings : void 0
           };
         }
+        {
+          const preLock = this.lockManager.read();
+          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((f2) => absorbedFiles.has(f2))
+            );
+          }
+        }
         for (const id of revertedPatchIds) {
           try {
             this.lockManager.removePatch(id);
@@ -22600,6 +22955,7 @@ CLI Version: ${options.cliVersion}`;
         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") {
@@ -22614,6 +22970,7 @@ CLI Version: ${options.cliVersion}`;
           }
         }
         this.lockManager.save();
+        this.warnings.push(...this.lockManager.warnings);
         if (newPatches.length > 0) {
           if (!options?.stageOnly) {
             const appliedCount = results.filter((r2) => r2.status === "applied").length;
@@ -22622,13 +22979,14 @@ CLI Version: ${options.cliVersion}`;
             await this.committer.stageAll();
           }
         }
+        const warnings = [...detectorWarnings, ...this.warnings];
         return this.buildReport("no-patches", newPatches, results, options, warnings, rebaseCounts, void 0, revertedPatchIds.length);
       }
       async handleNormalRegeneration(options) {
         if (options?.dryRun) {
           const existingPatches2 = this.lockManager.getPatches();
           const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.detector.detectNewPatches();
-          const warnings2 = [...this.detector.warnings];
+          const warnings2 = [...this.detector.warnings, ...this.warnings];
           const allPatches2 = [...existingPatches2, ...newPatches2];
           return {
             flow: "normal-regeneration",
@@ -22660,7 +23018,7 @@ CLI Version: ${options.cliVersion}`;
         }
         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));
@@ -22692,6 +23050,7 @@ CLI Version: ${options.cliVersion}`;
         const genRecord = await this.committer.createGenerationRecord(commitOpts);
         this.lockManager.addGeneration(genRecord);
         const results = await this.applicator.applyPatches(allPatches);
+        this._lastApplyResults = results;
         this.revertConflictingFiles(results);
         for (const result of results) {
           if (result.status === "conflict") {
@@ -22713,12 +23072,14 @@ CLI Version: ${options.cliVersion}`;
           }
         }
         this.lockManager.save();
+        this.warnings.push(...this.lockManager.warnings);
         if (options?.stageOnly) {
           await this.committer.stageAll();
         } else {
           const appliedCount = results.filter((r2) => r2.status === "applied").length;
           await this.committer.commitReplay(appliedCount, allPatches);
         }
+        const warnings = [...detectorWarnings, ...this.warnings];
         return this.buildReport(
           "normal-regeneration",
           allPatches,
@@ -22742,6 +23103,7 @@ CLI Version: ${options.cliVersion}`;
         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;
@@ -22762,34 +23124,78 @@ CLI Version: ${options.cliVersion}`;
           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);
@@ -22798,17 +23204,89 @@ CLI Version: ${options.cliVersion}`;
               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).
@@ -22822,13 +23300,14 @@ CLI Version: ${options.cliVersion}`;
         const cleanFiles = result.fileResults.filter((f2) => f2.status === "merged").map((f2) => f2.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;
@@ -22865,7 +23344,35 @@ CLI Version: ${options.cliVersion}`;
         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;
@@ -22875,6 +23382,7 @@ CLI Version: ${options.cliVersion}`;
               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;
@@ -22886,6 +23394,12 @@ CLI Version: ${options.cliVersion}`;
               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);
@@ -22911,6 +23425,13 @@ CLI Version: ${options.cliVersion}`;
             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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fern-api/generator-cli",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",
@@ -22,7 +22,7 @@
     "**"
   ],
   "dependencies": {
-    "@fern-api/replay": "0.10.4",
+    "@fern-api/replay": "0.11.0",
     "@octokit/rest": "^22.0.1",
     "es-toolkit": "^1.45.1",
     "tmp-promise": "^3.0.3"