@fern-api/replay 0.18.0 → 0.19.1

package/dist/cli.cjs

@@ -13245,15 +13245,15 @@ __export(PatchApplyTheirs_exports, {
 async function applyPatchToContent(base, patchContent, filePath) {
   const fileDiff = extractFileDiff(patchContent, filePath);
   if (!fileDiff) return null;
-  const tempDir = await (0, import_promises5.mkdtemp)((0, import_node_path8.join)((0, import_node_os3.tmpdir)(), "replay-migrate-"));
+  const tempDir = await (0, import_promises5.mkdtemp)((0, import_node_path9.join)((0, import_node_os3.tmpdir)(), "replay-migrate-"));
   const tempGit = new GitClient(tempDir);
   try {
     await tempGit.exec(["init"]);
     await tempGit.exec(["config", "user.email", "migrate@fern.com"]);
     await tempGit.exec(["config", "user.name", "Fern Replay Migration"]);
     await tempGit.exec(["config", "commit.gpgSign", "false"]);
-    const tempFilePath = (0, import_node_path8.join)(tempDir, filePath);
-    await (0, import_promises5.mkdir)((0, import_node_path8.dirname)(tempFilePath), { recursive: true });
+    const tempFilePath = (0, import_node_path9.join)(tempDir, filePath);
+    await (0, import_promises5.mkdir)((0, import_node_path9.dirname)(tempFilePath), { recursive: true });
     await (0, import_promises5.writeFile)(tempFilePath, base);
     await tempGit.exec(["add", filePath]);
     await tempGit.exec(["commit", "-m", `base for ${filePath}`, "--allow-empty"]);
@@ -13284,20 +13284,20 @@ function extractFileDiff(patchContent, filePath) {
   }
   return out.length > 0 ? out.join("\n") + "\n" : null;
 }
-var import_promises5, import_node_os3, import_node_path8;
+var import_promises5, import_node_os3, import_node_path9;
 var init_PatchApplyTheirs = __esm({
   "src/PatchApplyTheirs.ts"() {
     "use strict";
     import_promises5 = require("fs/promises");
     import_node_os3 = require("os");
-    import_node_path8 = require("path");
+    import_node_path9 = require("path");
     init_GitClient();
   }
 });
 
 // src/cli.ts
-var import_node_path13 = require("path");
-var import_node_fs6 = require("fs");
+var import_node_path14 = require("path");
+var import_node_fs7 = require("fs");
 var import_node_readline = require("readline");
 init_GitClient();
 
@@ -14827,6 +14827,22 @@ var LockfileManager = class {
       this.lock.forgotten_hashes.push(hash);
     }
   }
+  /**
+   * Record a dismissed customization: visibility metadata in `dismissals`
+   * plus a tombstone in `forgotten_hashes` for every content hash.
+   * `forgotten_hashes` stays the only list the detector consults; the
+   * metadata exists so `status` can show what was dismissed.
+   */
+  addDismissal(record) {
+    this.ensureLoaded();
+    if (!this.lock.dismissals) {
+      this.lock.dismissals = [];
+    }
+    this.lock.dismissals.push(record);
+    for (const hash of record.content_hashes) {
+      this.addForgottenHash(hash);
+    }
+  }
   getUnresolvedPatches() {
     this.ensureLoaded();
     return this.lock.patches.filter((p) => p.status === "unresolved");
@@ -15035,12 +15051,14 @@ async function capturePatchSnapshot(git, files, treeish) {
   return snapshot;
 }
 function filterInfrastructureAndSensitiveFiles(rawFilesOutput, fernignorePatterns) {
-  const allFiles = rawFilesOutput.trim().split("\n").filter(Boolean).filter((f) => !INFRASTRUCTURE_FILES.has(f)).filter((f) => !f.startsWith(".fern/"));
+  const rawFiles = rawFilesOutput.trim().split("\n").filter(Boolean);
+  const infrastructureFiles = rawFiles.filter((f) => INFRASTRUCTURE_FILES.has(f) || f.startsWith(".fern/"));
+  const allFiles = rawFiles.filter((f) => !INFRASTRUCTURE_FILES.has(f) && !f.startsWith(".fern/"));
   const sensitiveFiles = allFiles.filter((f) => isSensitiveFile(f));
   const nonSensitive = allFiles.filter((f) => !isSensitiveFile(f));
   const fernignoredFiles = nonSensitive.filter((f) => matchesFernignorePattern(f, fernignorePatterns));
   const files = nonSensitive.filter((f) => !matchesFernignorePattern(f, fernignorePatterns));
-  return { files, sensitiveFiles, fernignoredFiles };
+  return { files, sensitiveFiles, fernignoredFiles, infrastructureFiles };
 }
 var ReplayDetector = class {
   git;
@@ -15048,6 +15066,15 @@ var ReplayDetector = class {
   sdkOutputDir;
   fernignorePatterns;
   warnings = [];
+  /**
+   * Structured degraded-state channel, mirroring `warnings`. Populated when
+   * detection cannot guarantee customizations were carried forward (baseline
+   * unreachable in this clone). Cleared per-run by `ReplayService.prepareReplay`
+   * alongside `warnings`. Merged into `ReplayReport.degradedReasons` by each
+   * flow handler. Degraded is observability only: detection results are
+   * unchanged.
+   */
+  degradedReasons = [];
   constructor(git, lockManager, sdkOutputDir, fernignorePatterns = []) {
     this.git = git;
     this.lockManager = lockManager;
@@ -15118,6 +15145,10 @@ var ReplayDetector = class {
         this.warnings.push(
           `No generation boundary found in git history and the lockfile's recorded generation (${lock.current_generation.slice(0, 7)}) matches no entry in its generation records. Customer customizations may differ from the last known generation and could be lost on the next regeneration. Run \`fern-replay bootstrap --force\` to re-initialize tracking.`
         );
+        this.degradedReasons.push({
+          code: "baseline-unresolvable",
+          message: `The previous generation recorded in the lockfile (${lock.current_generation.slice(0, 7)}) could not be resolved to any reachable baseline during this run. Customizations may not have been carried forward \u2014 review the result before merging.`
+        });
       }
       return { patches: [], revertedPatchIds: [] };
     }
@@ -15126,6 +15157,12 @@ var ReplayDetector = class {
       this.warnings.push(
         `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to tree-diff detection (likely a shallow clone).`
       );
+      if (lock.patches.length > 0) {
+        this.degradedReasons.push({
+          code: "generation-anchor-unreachable",
+          message: `The previous generation (${lastGen.commit_sha.slice(0, 7)}) was not reachable during this run, and ${lock.patches.length} tracked customization(s) could not be verified against it. Customizations may not have been carried forward \u2014 review the result before merging.`
+        });
+      }
       return this.detectPatchesViaTreeDiff(
         lastGen,
         /* commitKnownMissing */
@@ -15165,54 +15202,27 @@ var ReplayDetector = class {
       if (lock.patches.find((p) => p.original_commit === commit.sha)) {
         continue;
       }
-      const parents = await this.git.getCommitParents(commit.sha);
-      let filesOutput;
-      try {
-        filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-      } catch {
+      const materialized = await this.materializeCommitPatch(commit.sha);
+      if (materialized.sensitiveFiles.length > 0) {
         this.warnings.push(
-          `Could not generate patch for commit ${commit.sha.slice(0, 7)} \u2014 it may be unreachable in a shallow clone. Skipping.`
+          `Sensitive file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${materialized.sensitiveFiles.join(", ")}. These files will not be tracked by replay.`
         );
-        continue;
       }
-      const { files, sensitiveFiles, fernignoredFiles } = filterInfrastructureAndSensitiveFiles(
-        filesOutput,
-        this.fernignorePatterns
-      );
-      if (sensitiveFiles.length > 0) {
+      if (materialized.fernignoredFiles.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.`
+          `.fernignore-protected file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${materialized.fernignoredFiles.join(", ")}. These files are managed by .fernignore, not Replay.`
         );
       }
-      if (fernignoredFiles.length > 0) {
+      if (materialized.status === "unreachable") {
         this.warnings.push(
-          `.fernignore-protected file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${fernignoredFiles.join(", ")}. These files are managed by .fernignore, not Replay.`
+          `Could not generate patch for commit ${commit.sha.slice(0, 7)} \u2014 it may be unreachable in a shallow clone. Skipping.`
         );
-      }
-      if (files.length === 0) {
         continue;
       }
-      const wasFiltered = sensitiveFiles.length > 0 || fernignoredFiles.length > 0;
-      const parentSha = parents[0];
-      let patchContent;
-      if (wasFiltered && parentSha) {
-        try {
-          patchContent = await this.git.exec(["diff", parentSha, commit.sha, "--", ...files]);
-        } catch {
-          continue;
-        }
-        if (!patchContent.trim()) continue;
-      } else {
-        try {
-          patchContent = await this.git.formatPatch(commit.sha);
-        } catch {
-          this.warnings.push(
-            `Could not generate patch for commit ${commit.sha.slice(0, 7)} \u2014 it may be unreachable in a shallow clone. Skipping.`
-          );
-          continue;
-        }
+      if (materialized.status === "empty") {
+        continue;
       }
-      const contentHash = this.computeContentHash(patchContent);
+      const { files, patchContent, contentHash } = materialized;
       if (lock.patches.find((p) => p.content_hash === contentHash) || forgottenHashes.has(contentHash)) {
         continue;
       }
@@ -15289,6 +15299,63 @@ var ReplayDetector = class {
     const filteredPatches = survivingPatches.filter((_, i) => !revertIndicesToRemove.has(i));
     return { patches: filteredPatches, revertedPatchIds: [...revertedPatchIdSet] };
   }
+  /**
+   * Materialize a commit into patch content exactly as detection does.
+   *
+   * Pipeline: `diff-tree --name-only` → filter infrastructure / sensitive /
+   * `.fernignore`d files → scoped `git diff` when files were stripped,
+   * otherwise full `git format-patch` → content hash.
+   *
+   * This is THE definition of a commit's re-emission identity: the content
+   * hash this method returns is what `detectPatchesInRange` will compute if
+   * the commit re-enters the scan range (e.g. after a regen PR is merged
+   * with a merge commit). Callers that tombstone a dismissed patch must use
+   * this hash — the stored `content_hash` drifts every time the patch is
+   * carried forward, so it does not identify the commit on re-detection.
+   *
+   * Never throws; failures are reported through the `status` discriminant.
+   */
+  async materializeCommitPatch(sha) {
+    let parents;
+    let filesOutput;
+    try {
+      parents = await this.git.getCommitParents(sha);
+      filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", sha]);
+    } catch {
+      return { status: "unreachable", sensitiveFiles: [], fernignoredFiles: [] };
+    }
+    const { files, sensitiveFiles, fernignoredFiles, infrastructureFiles } = filterInfrastructureAndSensitiveFiles(filesOutput, this.fernignorePatterns);
+    if (files.length === 0) {
+      return { status: "empty", sensitiveFiles, fernignoredFiles };
+    }
+    const wasFiltered = sensitiveFiles.length > 0 || fernignoredFiles.length > 0 || infrastructureFiles.length > 0;
+    const parentSha = parents[0];
+    let patchContent;
+    if (wasFiltered && parentSha) {
+      try {
+        patchContent = await this.git.exec(["diff", parentSha, sha, "--", ...files]);
+      } catch {
+        return { status: "empty", sensitiveFiles, fernignoredFiles };
+      }
+      if (!patchContent.trim()) {
+        return { status: "empty", sensitiveFiles, fernignoredFiles };
+      }
+    } else {
+      try {
+        patchContent = await this.git.formatPatch(sha);
+      } catch {
+        return { status: "unreachable", sensitiveFiles, fernignoredFiles };
+      }
+    }
+    return {
+      status: "ok",
+      files,
+      sensitiveFiles,
+      fernignoredFiles,
+      patchContent,
+      contentHash: this.computeContentHash(patchContent)
+    };
+  }
   /**
    * Compute content hash for deduplication.
    *
@@ -15393,6 +15460,13 @@ var ReplayDetector = class {
   async detectPatchesViaTreeDiff(lastGen, commitKnownMissing) {
     const diffBase = await this.resolveDiffBase(lastGen, commitKnownMissing);
     if (!diffBase) {
+      this.warnings.push(
+        `Neither the previous generation's commit (${lastGen.commit_sha.slice(0, 7)}) nor its recorded tree was reachable during this run. Falling back to a bounded commit scan, which cannot see customizations older than the clone window. Widen the clone window (e.g. \`git fetch --unshallow\`) and re-run replay to verify customizations were carried forward.`
+      );
+      this.degradedReasons.push({
+        code: "generation-tree-unreachable",
+        message: `The previous generation (${lastGen.commit_sha.slice(0, 7)}) was not reachable during this run \u2014 neither its commit nor its recorded tree. Customizations may not have been carried forward \u2014 review the result before merging, or widen the clone window and re-run replay.`
+      });
       return this.detectPatchesViaCommitScan();
     }
     const lockForGuard = this.lockManager.read();
@@ -15505,10 +15579,7 @@ var ReplayDetector = class {
         continue;
       }
       const filesOutput = await this.git.exec(["diff-tree", "--no-commit-id", "--name-only", "-r", commit.sha]);
-      const { files, sensitiveFiles, fernignoredFiles } = filterInfrastructureAndSensitiveFiles(
-        filesOutput,
-        this.fernignorePatterns
-      );
+      const { files, sensitiveFiles, fernignoredFiles, infrastructureFiles } = filterInfrastructureAndSensitiveFiles(filesOutput, this.fernignorePatterns);
       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.`
@@ -15519,7 +15590,8 @@ var ReplayDetector = class {
           `.fernignore-protected file(s) excluded from patch for commit ${commit.sha.slice(0, 7)}: ${fernignoredFiles.join(", ")}. These files are managed by .fernignore, not Replay.`
         );
       }
-      if ((sensitiveFiles.length > 0 || fernignoredFiles.length > 0) && files.length > 0) {
+      const wasFiltered = sensitiveFiles.length > 0 || fernignoredFiles.length > 0 || infrastructureFiles.length > 0;
+      if (wasFiltered && files.length > 0) {
         if (parents.length === 0) {
           continue;
         }
@@ -15623,9 +15695,9 @@ var ReplayDetector = class {
 };
 
 // src/ReplayService.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_promises6 = require("fs/promises");
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 init_GitClient();
 
 // src/ReplayApplicator.ts
@@ -16377,6 +16449,51 @@ async function buildMergePlan(args) {
 // src/applicator/runMergeAndRecord.ts
 var import_promises2 = require("fs/promises");
 var import_node_path5 = require("path");
+
+// src/autoversion.ts
+var AUTOVERSION_PLACEHOLDERS = [
+  "v0.0.0-fern-placeholder",
+  // Go -- a superstring of the default; check first
+  "0.0.0-fern-placeholder",
+  // TS/Java/C#/Ruby/PHP/Rust/default
+  "0.0.0.dev0"
+  // Python (PEP 440 -- Poetry rejects hyphens)
+];
+var VERSION_TOKEN = /(?:v)?\d+\.\d+\.\d+[0-9A-Za-z.+-]*/g;
+var VERSION_MASK = "@@FERN_VERSION@@";
+function maskVersions(line) {
+  return line.replace(VERSION_TOKEN, VERSION_MASK);
+}
+function containsPlaceholder(content) {
+  if (!content) return false;
+  return AUTOVERSION_PLACEHOLDERS.some((p) => content.includes(p));
+}
+function remapManagedLines(genBase, target, theirs) {
+  if (!containsPlaceholder(genBase)) return theirs;
+  const managedMasks = /* @__PURE__ */ new Set();
+  for (const line of genBase.split("\n")) {
+    if (AUTOVERSION_PLACEHOLDERS.some((p) => line.includes(p))) managedMasks.add(maskVersions(line));
+  }
+  if (managedMasks.size === 0) return theirs;
+  const targetByMask = /* @__PURE__ */ new Map();
+  for (const line of target.split("\n")) {
+    const mask = maskVersions(line);
+    if (managedMasks.has(mask) && !targetByMask.has(mask)) targetByMask.set(mask, line);
+  }
+  return theirs.split("\n").map((line) => {
+    const mask = maskVersions(line);
+    const replacement = managedMasks.has(mask) ? targetByMask.get(mask) : void 0;
+    return replacement !== void 0 && replacement !== line ? replacement : line;
+  }).join("\n");
+}
+function neutralizeAutoversionTheirs(genBase, theirs) {
+  return remapManagedLines(genBase, genBase, theirs);
+}
+function alignAutoversionToOurs(genBase, ours, theirs) {
+  return remapManagedLines(genBase, ours, theirs);
+}
+
+// src/applicator/runMergeAndRecord.ts
 async function runMergeAndRecord(args) {
   const { plan, inputs, patch, accumulator } = args;
   const { resolvedPath, metadata, oursPath, ours } = inputs;
@@ -16407,11 +16524,13 @@ async function runMergeAndRecord(args) {
     accumulator.recordMerge(resolvedPath, merged2.content, patch.base_generation);
     return { file: resolvedPath, status: "merged", ...unreachableFlag };
   }
-  const merged = threeWayMerge(plan.mergeBase, ours, plan.theirs);
+  const mergeBase = inputs.base != null ? alignAutoversionToOurs(inputs.base, ours, plan.mergeBase) : plan.mergeBase;
+  const theirs = inputs.base != null ? alignAutoversionToOurs(inputs.base, ours, plan.theirs) : plan.theirs;
+  const merged = threeWayMerge(mergeBase, ours, theirs);
   await (0, import_promises2.mkdir)((0, import_node_path5.dirname)(oursPath), { recursive: true });
   await (0, import_promises2.writeFile)(oursPath, merged.content);
   if (merged.hasConflicts) {
-    accumulator.recordConflict(resolvedPath, plan.theirs, patch.base_generation);
+    accumulator.recordConflict(resolvedPath, theirs, patch.base_generation);
     return {
       file: resolvedPath,
       status: "conflict",
@@ -16420,7 +16539,7 @@ async function runMergeAndRecord(args) {
       conflictMetadata: metadata
     };
   }
-  accumulator.recordMerge(resolvedPath, plan.theirs, patch.base_generation);
+  accumulator.recordMerge(resolvedPath, theirs, patch.base_generation);
   return {
     file: resolvedPath,
     status: "merged",
@@ -16935,6 +17054,15 @@ function isDiffLineForFile(diffLine, filePath) {
   return match2 !== null && match2[1] === filePath;
 }
 
+// src/shared/fernignore.ts
+var import_node_fs2 = require("fs");
+var import_node_path7 = require("path");
+function readFernignorePatterns(outputDir) {
+  const fernignorePath = (0, import_node_path7.join)(outputDir, ".fernignore");
+  if (!(0, import_node_fs2.existsSync)(fernignorePath)) return [];
+  return (0, import_node_fs2.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+}
+
 // src/ReplayCommitter.ts
 var ReplayCommitter = class {
   git;
@@ -17040,7 +17168,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
 // src/PatchRegionDiff.ts
 var import_promises4 = require("fs/promises");
 var import_node_os2 = require("os");
-var import_node_path7 = require("path");
+var import_node_path8 = require("path");
 var import_node_child_process = require("child_process");
 init_HybridReconstruction();
 function normalizeHunkBody(hunk) {
@@ -17258,10 +17386,10 @@ function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locI
 }
 async function unifiedDiff(beforeContent, afterContent, filePath) {
   if (beforeContent === afterContent) return "";
-  const tmp = await (0, import_promises4.mkdtemp)((0, import_node_path7.join)((0, import_node_os2.tmpdir)(), "fern-replay-pp-"));
+  const tmp = await (0, import_promises4.mkdtemp)((0, import_node_path8.join)((0, import_node_os2.tmpdir)(), "fern-replay-pp-"));
   try {
-    const beforePath = (0, import_node_path7.join)(tmp, "before");
-    const afterPath = (0, import_node_path7.join)(tmp, "after");
+    const beforePath = (0, import_node_path8.join)(tmp, "before");
+    const afterPath = (0, import_node_path8.join)(tmp, "after");
     await (0, import_promises4.writeFile)(beforePath, beforeContent, "utf-8");
     await (0, import_promises4.writeFile)(afterPath, afterContent, "utf-8");
     const raw = await runGitDiffNoIndex(beforePath, afterPath);
@@ -17436,6 +17564,7 @@ var FirstGenerationFlow = class {
         patchesToApply: [],
         newPatchIds: /* @__PURE__ */ new Set(),
         detectorWarnings: [],
+        detectorDegraded: [],
         revertedCount: 0,
         genSha: genRecord.commit_sha,
         optionsSnapshot: options
@@ -17495,6 +17624,7 @@ var SkipApplicationFlow = class {
         patchesToApply: [],
         newPatchIds: /* @__PURE__ */ new Set(),
         detectorWarnings: [],
+        detectorDegraded: [],
         revertedCount: 0,
         genSha: genRecord.commit_sha,
         optionsSnapshot: options
@@ -17532,8 +17662,10 @@ var NoPatchesFlow = class {
     const previousGenerationSha = preLock.current_generation ?? null;
     let { patches: newPatches, revertedPatchIds } = await this.service.detector.detectNewPatches();
     const detectorWarnings = [...this.service.detector.warnings];
+    const detectorDegraded = [...this.service.detector.degradedReasons];
     if (options?.dryRun) {
       const dryRunWarnings = [...detectorWarnings, ...this.service.warnings];
+      const dryRunDegraded = dedupeDegradedReasons([...detectorDegraded, ...this.service.degradedReasons]);
       const preparedReport = {
         flow: "no-patches",
         patchesDetected: newPatches.length,
@@ -17543,7 +17675,9 @@ var NoPatchesFlow = class {
         patchesReverted: revertedPatchIds.length,
         conflicts: [],
         wouldApply: newPatches,
-        warnings: dryRunWarnings.length > 0 ? dryRunWarnings : void 0
+        warnings: dryRunWarnings.length > 0 ? dryRunWarnings : void 0,
+        degraded: dryRunDegraded.length > 0 ? true : void 0,
+        degradedReasons: dryRunDegraded.length > 0 ? dryRunDegraded : void 0
       };
       const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
       return {
@@ -17597,6 +17731,7 @@ var NoPatchesFlow = class {
         patchesToApply: newPatches,
         newPatchIds: new Set(newPatches.map((p) => p.id)),
         detectorWarnings,
+        detectorDegraded,
         revertedCount: revertedPatchIds.length,
         genSha: genRecord.commit_sha,
         optionsSnapshot: options
@@ -17640,6 +17775,7 @@ var NoPatchesFlow = class {
       }
     }
     const warnings = [...detectorWarnings, ...this.service.warnings];
+    const degradedReasons = [...prep._prepared.detectorDegraded, ...this.service.degradedReasons];
     return this.service.buildReport(
       "no-patches",
       newPatches,
@@ -17648,7 +17784,8 @@ var NoPatchesFlow = class {
       warnings,
       rebaseCounts,
       void 0,
-      prep._prepared.revertedCount
+      prep._prepared.revertedCount,
+      degradedReasons
     );
   }
 };
@@ -17665,6 +17802,10 @@ var NormalRegenerationFlow = class {
       const existingPatches2 = this.service.lockManager.getPatches();
       const { patches: newPatches2, revertedPatchIds: dryRunReverted } = await this.service.detector.detectNewPatches();
       const warnings = [...this.service.detector.warnings, ...this.service.warnings];
+      const dryRunDegraded = dedupeDegradedReasons([
+        ...this.service.detector.degradedReasons,
+        ...this.service.degradedReasons
+      ]);
       const allPatches2 = [...existingPatches2, ...newPatches2];
       const preparedReport = {
         flow: "normal-regeneration",
@@ -17675,7 +17816,9 @@ var NormalRegenerationFlow = class {
         patchesReverted: dryRunReverted.length,
         conflicts: [],
         wouldApply: allPatches2,
-        warnings: warnings.length > 0 ? warnings : void 0
+        warnings: warnings.length > 0 ? warnings : void 0,
+        degraded: dryRunDegraded.length > 0 ? true : void 0,
+        degradedReasons: dryRunDegraded.length > 0 ? dryRunDegraded : void 0
       };
       const headSha = await this.service.git.exec(["rev-parse", "HEAD"]).then((s) => s.trim()).catch(() => "");
       return {
@@ -17714,6 +17857,7 @@ var NormalRegenerationFlow = class {
     existingPatches = this.service.lockManager.getPatches();
     let { patches: newPatches, revertedPatchIds } = await this.service.detector.detectNewPatches();
     const detectorWarnings = [...this.service.detector.warnings];
+    const detectorDegraded = [...this.service.detector.degradedReasons];
     if (removedByPreRebase.length > 0) {
       const removedOriginalCommits = new Set(removedByPreRebase.map((p) => p.original_commit));
       const removedOriginalMessages = new Set(removedByPreRebase.map((p) => p.original_message));
@@ -17754,6 +17898,7 @@ var NormalRegenerationFlow = class {
         newPatchIds: new Set(newPatches.map((p) => p.id)),
         preRebaseCounts,
         detectorWarnings,
+        detectorDegraded,
         revertedCount: revertedPatchIds.length,
         genSha: genRecord.commit_sha,
         optionsSnapshot: options
@@ -17802,6 +17947,7 @@ var NormalRegenerationFlow = class {
       await this.service.committer.commitReplay(appliedCount, allPatches, void 0, { buckets });
     }
     const warnings = [...detectorWarnings, ...this.service.warnings];
+    const degradedReasons = [...prep._prepared.detectorDegraded, ...this.service.degradedReasons];
     return this.service.buildReport(
       "normal-regeneration",
       allPatches,
@@ -17810,7 +17956,8 @@ var NormalRegenerationFlow = class {
       warnings,
       rebaseCounts,
       prep._prepared.preRebaseCounts,
-      prep._prepared.revertedCount
+      prep._prepared.revertedCount,
+      degradedReasons
     );
   }
 };
@@ -17850,6 +17997,16 @@ var ReplayService = class {
    * @internal Used by Flow implementations in `src/flows/`.
    */
   warnings = [];
+  /**
+   * Service-level structured degraded reasons, mirroring `warnings`.
+   * Populated at apply time (e.g. `recordUnreachableBaseWarnings` when a
+   * patch's base-generation tree is unreachable). Merged with
+   * `detector.degradedReasons` into `ReplayReport.degradedReasons` by each
+   * flow handler. Cleared at the top of `prepareReplay()`.
+   *
+   * @internal Used by Flow implementations in `src/flows/`.
+   */
+  degradedReasons = [];
   /**
    * @internal Test-only accessor.
    * Returns the ReplayApplicator instance used for the last run. Tests use this
@@ -17893,7 +18050,10 @@ var ReplayService = class {
   async prepareReplay(options) {
     this.warnings = [];
     this.detector.warnings.length = 0;
+    this.degradedReasons = [];
+    this.detector.degradedReasons.length = 0;
     this.cleanseLegacyFernignoreEntries();
+    this.cleanseInfrastructureFileEntries();
     return this.selectFlow(options).prepare(options);
   }
   /**
@@ -17947,6 +18107,50 @@ var ReplayService = class {
       this.lockManager.save();
     }
   }
+  /**
+   * Migration step: strips infrastructure file diffs (`.fernignore`, `.fern/*`)
+   * from existing patches' `patch_content`. These diffs were bundled by older
+   * detection logic that did not scope `git diff` when only infrastructure files
+   * were stripped. Patches that end up with no surviving diff sections are
+   * removed entirely.
+   *
+   * Idempotent: a second run is a no-op because the first run already removed
+   * all infrastructure sections. Per-patch try/catch ensures isolation.
+   */
+  cleanseInfrastructureFileEntries() {
+    if (!this.lockManager.exists()) return;
+    this.lockManager.read();
+    let lockfileMutated = false;
+    const patches = this.lockManager.getPatches();
+    for (const patch of patches) {
+      try {
+        const result = computeInfrastructureFileCleanse(
+          patch,
+          (content) => this.detector.computeContentHash(content)
+        );
+        if (result.unchanged) continue;
+        if (result.remove) {
+          this.lockManager.removePatch(patch.id);
+          this.warnings.push(
+            `Stripped infrastructure file diffs from patch ${patch.id}: patch contained only infrastructure file changes (${result.strippedPaths.join(", ")}) \u2014 removed.`
+          );
+        } else {
+          this.lockManager.updatePatch(patch.id, {
+            patch_content: result.patch_content,
+            content_hash: result.content_hash
+          });
+          this.warnings.push(
+            `Stripped infrastructure file diffs from patch ${patch.id}: removed bundled diffs for ${result.strippedPaths.join(", ")}.`
+          );
+        }
+        lockfileMutated = true;
+      } catch {
+      }
+    }
+    if (lockfileMutated) {
+      this.lockManager.save();
+    }
+  }
   /**
    * Phase 2 of the two-phase replay flow. Applies patches, rebases them against
    * the generation, saves the lockfile, and commits `[fern-replay]` (or stages
@@ -18113,7 +18317,9 @@ var ReplayService = class {
           if (baseChanged) repointed++;
           continue;
         }
-        const diff = await this.git.exec(["diff", currentGenSha, "--", ...patch.files]).catch(() => null);
+        const rawDiff = await this.git.exec(["diff", currentGenSha, "--", ...patch.files]).catch(() => null);
+        const neutralizedRebase = rawDiff != null && containsPlaceholder(rawDiff) ? await this.computeAutoversionNeutralizedRebase(patch.files, currentGenSha) : null;
+        const diff = neutralizedRebase ? neutralizedRebase.diff : rawDiff;
         if (diff === null) continue;
         if (!diff.trim()) {
           if (hasProtectedFiles) {
@@ -18169,7 +18375,7 @@ var ReplayService = class {
         patch.base_generation = currentGenSha;
         patch.patch_content = diff;
         patch.content_hash = newContentHash;
-        const snapshot = await this.readSnapshotFromDisk(patch.files);
+        const snapshot = neutralizedRebase ? neutralizedRebase.snapshot : await this.readSnapshotFromDisk(patch.files);
         const snapshotIsNonEmpty = Object.keys(snapshot).length > 0;
         if (snapshotIsNonEmpty) {
           patch.theirs_snapshot = snapshot;
@@ -18202,13 +18408,54 @@ var ReplayService = class {
     for (const file of files) {
       if (isBinaryFile(file)) continue;
       try {
-        const content = await (0, import_promises6.readFile)((0, import_node_path9.join)(this.outputDir, file), "utf-8");
+        const content = await (0, import_promises6.readFile)((0, import_node_path10.join)(this.outputDir, file), "utf-8");
         snapshot[file] = content;
       } catch {
       }
     }
     return snapshot;
   }
+  /**
+   * Autoversion-aware replacement for the naive `git diff currentGen -- files`
+   * + on-disk snapshot used when rebasing a cleanly-applied patch.
+   *
+   * The generation tree (BASE) still carries the placeholder on version lines
+   * (autoversion runs after `[fern-generated]`), but the working tree holds
+   * autoversion's resolved semver. A raw diff/snapshot would fold the
+   * placeholder->semver swap into the customer's patch_content/theirs_snapshot,
+   * pinning a stale version. This re-derives both against a version-neutralized
+   * THEIRS so the pipeline-owned version line never enters the patch.
+   *
+   * Returns null when no file is under autoversion (fixed `--version`, i.e. no
+   * placeholder in the generation tree) — callers keep their existing behavior.
+   */
+  async computeAutoversionNeutralizedRebase(files, currentGenSha) {
+    const genByFile = /* @__PURE__ */ new Map();
+    let anyPlaceholder = false;
+    for (const file of files) {
+      const gen = await this.git.showFile(currentGenSha, file).catch(() => null);
+      genByFile.set(file, gen);
+      if (containsPlaceholder(gen)) anyPlaceholder = true;
+    }
+    if (!anyPlaceholder) return null;
+    const snapshot = {};
+    const fragments = [];
+    for (const file of files) {
+      if (isBinaryFile(file)) continue;
+      const disk = await (0, import_promises6.readFile)((0, import_node_path10.join)(this.outputDir, file), "utf-8").catch(() => null);
+      if (disk == null) continue;
+      const gen = genByFile.get(file) ?? null;
+      const neutralized = gen != null ? neutralizeAutoversionTheirs(gen, disk) : disk;
+      snapshot[file] = neutralized;
+      if (gen == null) {
+        fragments.push(synthesizeNewFileDiff(file, neutralized));
+      } else if (gen !== neutralized) {
+        const fileDiff = await unifiedDiff(gen, neutralized, file);
+        if (fileDiff.trim()) fragments.push(fileDiff);
+      }
+    }
+    return { diff: fragments.join(""), snapshot };
+  }
   /**
    * Detects autoversion contamination — returns true when a
    * `[fern-autoversion]` commit between `fromSha` and `toSha` touched any
@@ -18719,6 +18966,12 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         );
       }
     }
+    if (warned.size > 0) {
+      this.degradedReasons.push({
+        code: "patch-base-unreachable",
+        message: `${warned.size} customization file(s) could not be checked against the generation they were made on because that generation's tree was not reachable during this run. Customizations may not have been carried forward \u2014 review the result before merging, or widen the clone window and re-run replay.`
+      });
+    }
   }
   /**
    * After applyPatches(), strip conflict markers from conflicting files
@@ -18730,11 +18983,11 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
       if (result.status !== "conflict" || !result.fileResults) continue;
       for (const fileResult of result.fileResults) {
         if (fileResult.status !== "conflict") continue;
-        const filePath = (0, import_node_path9.join)(this.outputDir, fileResult.file);
+        const filePath = (0, import_node_path10.join)(this.outputDir, fileResult.file);
         try {
-          const content = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
+          const content = (0, import_node_fs3.readFileSync)(filePath, "utf-8");
           const stripped = stripConflictMarkers(content);
-          (0, import_node_fs2.writeFileSync)(filePath, stripped);
+          (0, import_node_fs3.writeFileSync)(filePath, stripped);
         } catch {
         }
       }
@@ -18762,12 +19015,11 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
   }
   /** @internal Used by Flow implementations in `src/flows/`. */
   readFernignorePatterns() {
-    const fernignorePath = (0, import_node_path9.join)(this.outputDir, ".fernignore");
-    if (!(0, import_node_fs2.existsSync)(fernignorePath)) return [];
-    return (0, import_node_fs2.readFileSync)(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    return readFernignorePatterns(this.outputDir);
   }
   /** @internal Used by Flow implementations in `src/flows/`. */
-  buildReport(flow, patches, results, options, warnings, rebaseCounts, preRebaseCounts, patchesReverted) {
+  buildReport(flow, patches, results, options, warnings, rebaseCounts, preRebaseCounts, patchesReverted, degradedReasons) {
+    const degraded = dedupeDegradedReasons(degradedReasons ?? []);
     const conflictResults = results.filter((r) => r.status === "conflict");
     const conflictDetails = conflictResults.map((r) => {
       const conflictFiles = r.fileResults?.filter((f) => f.status === "conflict") ?? [];
@@ -18807,10 +19059,23 @@ If you want to keep these lines, restore them in a follow-up commit and re-run r
         conflictDetails: r.fileResults?.filter((f) => f.status === "conflict") ?? []
       })) : void 0,
       wouldApply: options?.dryRun ? patches : void 0,
-      warnings: warnings && warnings.length > 0 ? warnings : void 0
+      warnings: warnings && warnings.length > 0 ? warnings : void 0,
+      degraded: degraded.length > 0 ? true : void 0,
+      degradedReasons: degraded.length > 0 ? degraded : void 0
     };
   }
 };
+function dedupeDegradedReasons(reasons) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const reason of reasons) {
+    const key = `${reason.code}\0${reason.message}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(reason);
+  }
+  return out;
+}
 function computeCommitBuckets(results, absorbedPatchIds, patchesPassedToCommit) {
   const resultByPatchId = /* @__PURE__ */ new Map();
   for (const r of results) resultByPatchId.set(r.patch.id, r);
@@ -18859,7 +19124,7 @@ function computeLegacyFernignoreCleanse(patch, fernignorePatterns, computeConten
       }
     }
   }
-  const { stripped: patchContentStripped, content: newPatchContent, strippedSectionPaths } = stripFernignoreDiffSections(patch.patch_content, matchesFernignore);
+  const { stripped: patchContentStripped, content: newPatchContent, strippedSectionPaths } = stripDiffSectionsByPredicate(patch.patch_content, matchesFernignore);
   const unchanged = strippedFromFiles.length === 0 && !snapshotChanged && !patchContentStripped;
   if (unchanged) {
     return {
@@ -18894,7 +19159,38 @@ function computeLegacyFernignoreCleanse(patch, fernignorePatterns, computeConten
     strippedPaths
   };
 }
-function stripFernignoreDiffSections(patchContent, matchesFernignore) {
+function isInfrastructureFile(filePath) {
+  return filePath === ".fernignore" || filePath.startsWith(".fern/");
+}
+function computeInfrastructureFileCleanse(patch, computeContentHash2) {
+  const { stripped, content: newPatchContent, strippedSectionPaths } = stripDiffSectionsByPredicate(patch.patch_content, isInfrastructureFile);
+  if (!stripped) {
+    return {
+      unchanged: true,
+      remove: false,
+      patch_content: patch.patch_content,
+      content_hash: patch.content_hash,
+      strippedPaths: []
+    };
+  }
+  if (newPatchContent.trim() === "" || patch.files.length === 0) {
+    return {
+      unchanged: false,
+      remove: true,
+      patch_content: "",
+      content_hash: "",
+      strippedPaths: strippedSectionPaths
+    };
+  }
+  return {
+    unchanged: false,
+    remove: false,
+    patch_content: newPatchContent,
+    content_hash: computeContentHash2(newPatchContent),
+    strippedPaths: strippedSectionPaths
+  };
+}
+function stripDiffSectionsByPredicate(patchContent, shouldStrip) {
   const lines = patchContent.split("\n");
   const sectionStarts = [];
   for (let i = 0; i < lines.length; i++) {
@@ -18916,7 +19212,7 @@ function stripFernignoreDiffSections(patchContent, matchesFernignore) {
     const section = sectionStarts[i];
     const next = sectionStarts[i + 1];
     const endIdx = next ? next.idx : lines.length;
-    if (section.path !== null && matchesFernignore(section.path)) {
+    if (section.path !== null && shouldStrip(section.path)) {
       stripped = true;
       strippedSectionPaths.push(section.path);
       continue;
@@ -18928,8 +19224,8 @@ function stripFernignoreDiffSections(patchContent, matchesFernignore) {
 
 // src/FernignoreMigrator.ts
 var import_node_crypto2 = require("crypto");
-var import_node_fs3 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path11 = require("path");
 var import_yaml2 = __toESM(require_dist3(), 1);
 var FernignoreMigrator = class {
   git;
@@ -18941,14 +19237,14 @@ var FernignoreMigrator = class {
     this.outputDir = outputDir;
   }
   fernignoreExists() {
-    return (0, import_node_fs3.existsSync)((0, import_node_path10.join)(this.outputDir, ".fernignore"));
+    return (0, import_node_fs4.existsSync)((0, import_node_path11.join)(this.outputDir, ".fernignore"));
   }
   readFernignorePatterns() {
-    const fernignorePath = (0, import_node_path10.join)(this.outputDir, ".fernignore");
-    if (!(0, import_node_fs3.existsSync)(fernignorePath)) {
+    const fernignorePath = (0, import_node_path11.join)(this.outputDir, ".fernignore");
+    if (!(0, import_node_fs4.existsSync)(fernignorePath)) {
       return [];
     }
-    const content = (0, import_node_fs3.readFileSync)(fernignorePath, "utf-8");
+    const content = (0, import_node_fs4.readFileSync)(fernignorePath, "utf-8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   }
   /** Analyze .fernignore patterns vs git history. Creates synthetic patches for files differing from pristine generation. */
@@ -19053,16 +19349,16 @@ var FernignoreMigrator = class {
     return results;
   }
   readFileContent(filePath) {
-    const fullPath = (0, import_node_path10.join)(this.outputDir, filePath);
-    if (!(0, import_node_fs3.existsSync)(fullPath)) {
+    const fullPath = (0, import_node_path11.join)(this.outputDir, filePath);
+    if (!(0, import_node_fs4.existsSync)(fullPath)) {
       return null;
     }
     try {
-      const stat = (0, import_node_fs3.statSync)(fullPath);
+      const stat = (0, import_node_fs4.statSync)(fullPath);
       if (stat.isDirectory()) {
         return null;
       }
-      return (0, import_node_fs3.readFileSync)(fullPath, "utf-8");
+      return (0, import_node_fs4.readFileSync)(fullPath, "utf-8");
     } catch {
       return null;
     }
@@ -19118,27 +19414,27 @@ var FernignoreMigrator = class {
     };
   }
   movePatternsToReplayYml(patterns) {
-    const replayYmlPath = (0, import_node_path10.join)(this.outputDir, ".fern", "replay.yml");
+    const replayYmlPath = (0, import_node_path11.join)(this.outputDir, ".fern", "replay.yml");
     let config = {};
-    if ((0, import_node_fs3.existsSync)(replayYmlPath)) {
-      const content = (0, import_node_fs3.readFileSync)(replayYmlPath, "utf-8");
+    if ((0, import_node_fs4.existsSync)(replayYmlPath)) {
+      const content = (0, import_node_fs4.readFileSync)(replayYmlPath, "utf-8");
       config = (0, import_yaml2.parse)(content) ?? {};
     }
     const existing = config.exclude ?? [];
     const merged = [.../* @__PURE__ */ new Set([...existing, ...patterns])];
     config.exclude = merged;
-    const dir = (0, import_node_path10.dirname)(replayYmlPath);
-    if (!(0, import_node_fs3.existsSync)(dir)) {
-      (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_node_path11.dirname)(replayYmlPath);
+    if (!(0, import_node_fs4.existsSync)(dir)) {
+      (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_node_fs3.writeFileSync)(replayYmlPath, (0, import_yaml2.stringify)(config, { lineWidth: 0 }), "utf-8");
+    (0, import_node_fs4.writeFileSync)(replayYmlPath, (0, import_yaml2.stringify)(config, { lineWidth: 0 }), "utf-8");
   }
 };
 
 // src/commands/bootstrap.ts
 var import_node_crypto3 = require("crypto");
-var import_node_fs4 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path12 = require("path");
 init_GitClient();
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
@@ -19305,10 +19601,10 @@ function parseGitLog(log) {
 }
 var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = (0, import_node_path11.join)(outputDir, ".fernignore");
+  const fernignorePath = (0, import_node_path12.join)(outputDir, ".fernignore");
   let content = "";
-  if ((0, import_node_fs4.existsSync)(fernignorePath)) {
-    content = (0, import_node_fs4.readFileSync)(fernignorePath, "utf-8");
+  if ((0, import_node_fs5.existsSync)(fernignorePath)) {
+    content = (0, import_node_fs5.readFileSync)(fernignorePath, "utf-8");
   }
   const lines = content.split("\n");
   const toAdd = [];
@@ -19324,15 +19620,15 @@ function ensureFernignoreEntries(outputDir) {
     content += "\n";
   }
   content += toAdd.join("\n") + "\n";
-  (0, import_node_fs4.writeFileSync)(fernignorePath, content, "utf-8");
+  (0, import_node_fs5.writeFileSync)(fernignorePath, content, "utf-8");
   return true;
 }
 var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = (0, import_node_path11.join)(outputDir, ".gitattributes");
+  const gitattributesPath = (0, import_node_path12.join)(outputDir, ".gitattributes");
   let content = "";
-  if ((0, import_node_fs4.existsSync)(gitattributesPath)) {
-    content = (0, import_node_fs4.readFileSync)(gitattributesPath, "utf-8");
+  if ((0, import_node_fs5.existsSync)(gitattributesPath)) {
+    content = (0, import_node_fs5.readFileSync)(gitattributesPath, "utf-8");
   }
   const lines = content.split("\n");
   const toAdd = [];
@@ -19348,7 +19644,7 @@ function ensureGitattributesEntries(outputDir) {
     content += "\n";
   }
   content += toAdd.join("\n") + "\n";
-  (0, import_node_fs4.writeFileSync)(gitattributesPath, content, "utf-8");
+  (0, import_node_fs5.writeFileSync)(gitattributesPath, content, "utf-8");
 }
 function computeContentHash(patchContent) {
   const lines = patchContent.split("\n");
@@ -19359,6 +19655,7 @@ function computeContentHash(patchContent) {
 }
 
 // src/commands/forget.ts
+init_GitClient();
 function parseDiffStat(patchContent) {
   let additions = 0;
   let deletions = 0;
@@ -19417,7 +19714,28 @@ var EMPTY_RESULT = {
   totalPatches: 0,
   warnings: []
 };
-function forget(outputDir, options) {
+async function dismissPatches(outputDir, lockManager, patches) {
+  const git = new GitClient(outputDir);
+  const detector = new ReplayDetector(git, lockManager, outputDir, readFernignorePatterns(outputDir));
+  for (const patch of patches) {
+    const hashes = [patch.content_hash];
+    if (patch.original_commit) {
+      const materialized = await detector.materializeCommitPatch(patch.original_commit);
+      if (materialized.status === "ok" && !hashes.includes(materialized.contentHash)) {
+        hashes.push(materialized.contentHash);
+      }
+    }
+    lockManager.addDismissal({
+      patch_id: patch.id,
+      original_commit: patch.original_commit,
+      original_message: patch.original_message,
+      content_hashes: hashes,
+      dismissed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      via: "forget"
+    });
+  }
+}
+async function forget(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
     return { ...EMPTY_RESULT };
@@ -19428,9 +19746,7 @@ function forget(outputDir, options) {
     const removed = lock.patches.map(toMatchedPatch);
     const warnings = buildWarnings(lock.patches);
     if (!options.dryRun) {
-      for (const patch of lock.patches) {
-        lockManager.addForgottenHash(patch.content_hash);
-      }
+      await dismissPatches(outputDir, lockManager, lock.patches);
       lockManager.clearPatches();
       lockManager.save();
     }
@@ -19459,8 +19775,8 @@ function forget(outputDir, options) {
     }
     const warnings = buildWarnings(patchesToRemove);
     if (!options.dryRun) {
+      await dismissPatches(outputDir, lockManager, patchesToRemove);
       for (const patch of patchesToRemove) {
-        lockManager.addForgottenHash(patch.content_hash);
         lockManager.removePatch(patch.id);
       }
       lockManager.save();
@@ -19501,7 +19817,7 @@ function forget(outputDir, options) {
 }
 
 // src/commands/reset.ts
-var import_node_fs5 = require("fs");
+var import_node_fs6 = require("fs");
 function reset(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
@@ -19515,7 +19831,7 @@ function reset(outputDir, options) {
   const lock = lockManager.read();
   const patchCount = lock.patches.length;
   if (!options?.dryRun) {
-    (0, import_node_fs5.unlinkSync)(lockManager.lockfilePath);
+    (0, import_node_fs6.unlinkSync)(lockManager.lockfilePath);
   }
   return {
     success: true,
@@ -19527,7 +19843,7 @@ function reset(outputDir, options) {
 
 // src/commands/resolve.ts
 var import_promises7 = require("fs/promises");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 init_GitClient();
 async function resolve(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
@@ -19568,15 +19884,16 @@ async function resolve(outputDir, options) {
   const patchesToCommit = [...resolvingPatches, ...unresolvedPatches];
   if (patchesToCommit.length > 0) {
     const currentGen = lock.current_generation;
-    const detector = new ReplayDetector(git, lockManager, outputDir);
+    const detector = new ReplayDetector(git, lockManager, outputDir, readFernignorePatterns(outputDir));
     const warnings = [];
+    const patchesDismissed = [];
     let patchesResolved = 0;
     const pass1 = [];
     for (const patch of patchesToCommit) {
       const result = await computePerPatchDiffWithFallback(
         patch,
         (f) => git.showFile(currentGen, f),
-        (f) => (0, import_promises7.readFile)((0, import_node_path12.join)(outputDir, f), "utf-8").catch(() => null),
+        (f) => (0, import_promises7.readFile)((0, import_node_path13.join)(outputDir, f), "utf-8").catch(() => null),
         (files) => git.exec(["diff", currentGen, "--", ...files]).catch(() => null)
       );
       if (result === null) {
@@ -19610,7 +19927,27 @@ async function resolve(outputDir, options) {
       const r = pass1[i];
       if (r.kind === "skip") continue;
       if (r.kind === "revert") {
+        const hashes = [patch.content_hash];
+        if (patch.original_commit) {
+          const materialized = await detector.materializeCommitPatch(patch.original_commit);
+          if (materialized.status === "ok" && !hashes.includes(materialized.contentHash)) {
+            hashes.push(materialized.contentHash);
+          } else if (materialized.status === "unreachable") {
+            warnings.push(
+              `Patch ${patch.id}: original commit ${patch.original_commit.slice(0, 7)} is unreachable; dismissed using the stored content hash only. If this commit reappears in history, the customization may be re-detected once.`
+            );
+          }
+        }
+        lockManager.addDismissal({
+          patch_id: patch.id,
+          original_commit: patch.original_commit,
+          original_message: patch.original_message,
+          content_hashes: hashes,
+          dismissed_at: (/* @__PURE__ */ new Date()).toISOString(),
+          via: "resolve"
+        });
         lockManager.removePatch(patch.id);
+        patchesDismissed.push({ id: patch.id, message: patch.original_message });
         continue;
       }
       if (lastIndexByHash.get(r.hash) !== i) {
@@ -19632,7 +19969,7 @@ async function resolve(outputDir, options) {
       const theirsSnapshot = {};
       for (const file of filesForSnapshot) {
         if (isBinaryFile(file)) continue;
-        const content = await (0, import_promises7.readFile)((0, import_node_path12.join)(outputDir, file), "utf-8").catch(() => null);
+        const content = await (0, import_promises7.readFile)((0, import_node_path13.join)(outputDir, file), "utf-8").catch(() => null);
         if (content != null) {
           theirsSnapshot[file] = content;
         }
@@ -19659,6 +19996,7 @@ async function resolve(outputDir, options) {
       commitSha: commitSha2,
       phase: "committed",
       patchesResolved,
+      patchesDismissed: patchesDismissed.length > 0 ? patchesDismissed : void 0,
       warnings: warnings.length > 0 ? warnings : void 0
     };
   }
@@ -19706,7 +20044,9 @@ function status(outputDir) {
       lastGeneration: void 0,
       patches: [],
       unresolvedCount: 0,
-      excludePatterns: []
+      excludePatterns: [],
+      dismissed: [],
+      legacyDismissedCount: 0
     };
   }
   const lock = lockManager.read();
@@ -19735,13 +20075,24 @@ function status(outputDir) {
   }
   const config = lockManager.getCustomizationsConfig();
   const excludePatterns = config.exclude ?? [];
+  const dismissals = lock.dismissals ?? [];
+  const dismissed = dismissals.map((d) => ({
+    message: d.original_message,
+    sha: d.original_commit.slice(0, 7),
+    via: d.via,
+    dismissedAt: d.dismissed_at
+  }));
+  const coveredHashes = new Set(dismissals.flatMap((d) => d.content_hashes));
+  const legacyDismissedCount = (lock.forgotten_hashes ?? []).filter((h) => !coveredHashes.has(h)).length;
   return {
     initialized: true,
     generationCount: lock.generations.length,
     lastGeneration,
     patches,
     unresolvedCount,
-    excludePatterns
+    excludePatterns,
+    dismissed,
+    legacyDismissedCount
   };
 }
 
@@ -19829,7 +20180,7 @@ function parseArgs(argv) {
       positionals.push(arg);
     }
   }
-  return { command, dir: (0, import_node_path13.resolve)(dir), flags, positionals };
+  return { command, dir: (0, import_node_path14.resolve)(dir), flags, positionals };
 }
 async function runBootstrap(dir, flags) {
   const dryRun = !!flags.dryRun;
@@ -19907,6 +20258,7 @@ async function runStatus(dir, flags) {
   }
   if (result.patches.length === 0) {
     console.log("\nNo customizations tracked. Edit SDK files and commit \u2014 Replay will detect them on next generation.");
+    printDismissedSection(result);
     return;
   }
   const unresolvedSuffix = result.unresolvedCount > 0 ? `, ${result.unresolvedCount} unresolved` : "";
@@ -19944,6 +20296,26 @@ ${prefix}${patch.id}  [${patch.type}]  "${patch.message}"`);
       console.log(`  ... and ${result.patches.length - maxDisplay} more`);
     }
   }
+  printDismissedSection(result);
+}
+function printDismissedSection(result) {
+  if (result.dismissed.length === 0 && result.legacyDismissedCount === 0) {
+    return;
+  }
+  const total = result.dismissed.length + result.legacyDismissedCount;
+  console.log(`
+Dismissed customizations: ${total}`);
+  for (const d of result.dismissed) {
+    const shaSuffix = d.sha ? ` (${d.sha})` : "";
+    const date = d.dismissedAt ? d.dismissedAt.slice(0, 10) : "";
+    const dateSuffix = date ? ` on ${date}` : "";
+    console.log(`  "${d.message}"${shaSuffix} \u2014 dismissed via ${d.via}${dateSuffix}`);
+  }
+  if (result.legacyDismissedCount > 0) {
+    console.log(
+      `  ... and ${result.legacyDismissedCount} dismissed before this version \u2014 details unavailable`
+    );
+  }
 }
 async function runDetect(dir) {
   const lockManager = new LockfileManager(dir);
@@ -19955,6 +20327,7 @@ async function runDetect(dir) {
   const git = new GitClient(dir);
   const detector = new ReplayDetector(git, lockManager, dir);
   const { patches, revertedPatchIds } = await detector.detectNewPatches();
+  printDegradedBanner(detector.degradedReasons);
   if (detector.warnings.length > 0) {
     for (const w of detector.warnings) console.log(`Warning: ${w}`);
     console.log();
@@ -19985,7 +20358,20 @@ async function runReplay(dir, flags) {
   const report = await service.runReplay({ dryRun });
   printReport(report);
 }
+function printDegradedBanner(reasons) {
+  if (reasons.length === 0) return;
+  console.log("============================================================");
+  console.log("  REPLAY DEGRADED \u2014 customizations may not have been");
+  console.log("  carried forward in this run. Review the result before");
+  console.log("  merging.");
+  console.log("============================================================");
+  for (const reason of reasons) {
+    console.log(`  [${reason.code}] ${reason.message}`);
+  }
+  console.log();
+}
 function printReport(report) {
+  printDegradedBanner(report.degradedReasons ?? []);
   console.log(`Flow: ${report.flow}`);
   console.log(`Patches detected: ${report.patchesDetected}`);
   console.log(`Patches applied: ${report.patchesApplied}`);
@@ -20153,7 +20539,7 @@ async function runForget(dir, flags, positionals) {
   const pattern = !isPatchIdMode && positionals.length > 0 ? positionals[0] : void 0;
   const patchIds = isPatchIdMode ? positionals : void 0;
   if (all) {
-    const preview = forget(dir, { all: true, dryRun: true });
+    const preview = await forget(dir, { all: true, dryRun: true });
     if (!preview.initialized) {
       console.log("Replay is not initialized. Run 'fern replay init' to get started.");
       process.exit(1);
@@ -20172,14 +20558,14 @@ async function runForget(dir, flags, positionals) {
         return;
       }
     }
-    const finalResult = dryRun ? preview : forget(dir, { all: true });
+    const finalResult = dryRun ? preview : await forget(dir, { all: true });
     printForgetWarnings(finalResult.warnings);
     const verb2 = dryRun ? "Would remove" : "Removed";
     console.log(`${verb2} ${finalResult.removed.length} patches. ${finalResult.remaining} patches remaining.`);
     return;
   }
   if (isPatchIdMode && patchIds) {
-    const result2 = forget(dir, { patchIds, dryRun });
+    const result2 = await forget(dir, { patchIds, dryRun });
     if (!result2.initialized) {
       console.log("Replay is not initialized. Run 'fern replay init' to get started.");
       process.exit(1);
@@ -20206,7 +20592,7 @@ async function runForget(dir, flags, positionals) {
     console.log(`${result2.remaining} patches remaining.`);
     return;
   }
-  const searchResult = pattern ? forget(dir, { pattern }) : forget(dir);
+  const searchResult = pattern ? await forget(dir, { pattern }) : await forget(dir);
   if (!searchResult.initialized) {
     console.log("Replay is not initialized. Run 'fern replay init' to get started.");
     process.exit(1);
@@ -20254,7 +20640,7 @@ This will remove ${selectedIds.length} patch(es). Affected files will be overwri
       return;
     }
   }
-  const result = forget(dir, { patchIds: selectedIds, dryRun });
+  const result = await forget(dir, { patchIds: selectedIds, dryRun });
   printForgetWarnings(result.warnings);
   const verb = dryRun ? "Would remove" : "Removed";
   console.log(`
@@ -20321,12 +20707,23 @@ Resolve the conflicts in your editor, then run 'fern-replay resolve ${dir}' agai
   if (result.patchesResolved) {
     console.log(`Resolution complete. Updated ${result.patchesResolved} patch(es) in lockfile.`);
   }
+  if (result.patchesDismissed && result.patchesDismissed.length > 0) {
+    console.log(`Permanently dismissed ${result.patchesDismissed.length} customization(s) (you kept the generated code):`);
+    for (const d of result.patchesDismissed) {
+      console.log(`  "${d.message}" (${d.id}) \u2014 will not return on future generations`);
+    }
+  }
+  if (result.warnings) {
+    for (const w of result.warnings) {
+      console.log(`Warning: ${w}`);
+    }
+  }
   console.log(`Created [fern-replay] commit: ${result.commitSha?.slice(0, 7)}`);
   console.log("Push to update the PR.");
 }
 async function main() {
   const { command, dir, flags, positionals } = parseArgs(process.argv);
-  if (!(0, import_node_fs6.existsSync)(dir)) {
+  if (!(0, import_node_fs7.existsSync)(dir)) {
     console.error(`Directory not found: ${dir}`);
     process.exit(1);
   }