@fern-api/replay 0.18.0 → 0.19.1

package/dist/index.js

@@ -407,18 +407,18 @@ __export(PatchApplyTheirs_exports, {
 });
 import { mkdtemp as mkdtemp3, mkdir as mkdir3, writeFile as writeFile4, readFile as readFile3, rm as rm3 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname4, join as join5 } from "path";
+import { dirname as dirname4, join as join6 } from "path";
 async function applyPatchToContent(base, patchContent, filePath) {
   const fileDiff = extractFileDiff(patchContent, filePath);
   if (!fileDiff) return null;
-  const tempDir = await mkdtemp3(join5(tmpdir3(), "replay-migrate-"));
+  const tempDir = await mkdtemp3(join6(tmpdir3(), "replay-migrate-"));
   const tempGit = new GitClient(tempDir);
   try {
     await tempGit.exec(["init"]);
     await tempGit.exec(["config", "user.email", "migrate@fern.com"]);
     await tempGit.exec(["config", "user.name", "Fern Replay Migration"]);
     await tempGit.exec(["config", "commit.gpgSign", "false"]);
-    const tempFilePath = join5(tempDir, filePath);
+    const tempFilePath = join6(tempDir, filePath);
     await mkdir3(dirname4(tempFilePath), { recursive: true });
     await writeFile4(tempFilePath, base);
     await tempGit.exec(["add", filePath]);
@@ -695,6 +695,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");
@@ -862,12 +878,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;
@@ -875,6 +893,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;
@@ -945,6 +972,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: [] };
     }
@@ -953,6 +984,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 */
@@ -992,54 +1029,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;
       }
@@ -1116,6 +1126,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.
    *
@@ -1220,6 +1287,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();
@@ -1332,10 +1406,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.`
@@ -1346,7 +1417,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;
         }
@@ -1955,6 +2027,51 @@ async function buildMergePlan(args) {
 // src/applicator/runMergeAndRecord.ts
 import { mkdir, writeFile } from "fs/promises";
 import { dirname as dirname2 } from "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;
@@ -1985,11 +2102,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 mkdir(dirname2(oursPath), { recursive: true });
   await 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",
@@ -1998,7 +2117,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",
@@ -2616,17 +2735,26 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
 };
 
 // src/ReplayService.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { readFile as readFileAsync } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { minimatch as minimatch5 } from "minimatch";
 init_GitClient();
 
+// src/shared/fernignore.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+function readFernignorePatterns(outputDir) {
+  const fernignorePath = join4(outputDir, ".fernignore");
+  if (!existsSync2(fernignorePath)) return [];
+  return readFileSync2(fernignorePath, "utf-8").split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+}
+
 // src/PatchRegionDiff.ts
 init_HybridReconstruction();
 import { mkdtemp as mkdtemp2, writeFile as writeFile3, rm as rm2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { spawn } from "child_process";
 function normalizeHunkBody(hunk) {
   let contextC = 0;
@@ -2843,10 +2971,10 @@ function overlayRegions(currentGenLines, locInCurrentGen, workingTreeLines, locI
 }
 async function unifiedDiff(beforeContent, afterContent, filePath) {
   if (beforeContent === afterContent) return "";
-  const tmp = await mkdtemp2(join4(tmpdir2(), "fern-replay-pp-"));
+  const tmp = await mkdtemp2(join5(tmpdir2(), "fern-replay-pp-"));
   try {
-    const beforePath = join4(tmp, "before");
-    const afterPath = join4(tmp, "after");
+    const beforePath = join5(tmp, "before");
+    const afterPath = join5(tmp, "after");
     await writeFile3(beforePath, beforeContent, "utf-8");
     await writeFile3(afterPath, afterContent, "utf-8");
     const raw = await runGitDiffNoIndex(beforePath, afterPath);
@@ -3022,6 +3150,7 @@ var FirstGenerationFlow = class {
         patchesToApply: [],
         newPatchIds: /* @__PURE__ */ new Set(),
         detectorWarnings: [],
+        detectorDegraded: [],
         revertedCount: 0,
         genSha: genRecord.commit_sha,
         optionsSnapshot: options
@@ -3081,6 +3210,7 @@ var SkipApplicationFlow = class {
         patchesToApply: [],
         newPatchIds: /* @__PURE__ */ new Set(),
         detectorWarnings: [],
+        detectorDegraded: [],
         revertedCount: 0,
         genSha: genRecord.commit_sha,
         optionsSnapshot: options
@@ -3118,8 +3248,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,
@@ -3129,7 +3261,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 {
@@ -3183,6 +3317,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
@@ -3226,6 +3361,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,
@@ -3234,7 +3370,8 @@ var NoPatchesFlow = class {
       warnings,
       rebaseCounts,
       void 0,
-      prep._prepared.revertedCount
+      prep._prepared.revertedCount,
+      degradedReasons
     );
   }
 };
@@ -3251,6 +3388,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",
@@ -3261,7 +3402,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 {
@@ -3300,6 +3443,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));
@@ -3340,6 +3484,7 @@ var NormalRegenerationFlow = class {
         newPatchIds: new Set(newPatches.map((p) => p.id)),
         preRebaseCounts,
         detectorWarnings,
+        detectorDegraded,
         revertedCount: revertedPatchIds.length,
         genSha: genRecord.commit_sha,
         optionsSnapshot: options
@@ -3388,6 +3533,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,
@@ -3396,7 +3542,8 @@ var NormalRegenerationFlow = class {
       warnings,
       rebaseCounts,
       prep._prepared.preRebaseCounts,
-      prep._prepared.revertedCount
+      prep._prepared.revertedCount,
+      degradedReasons
     );
   }
 };
@@ -3436,6 +3583,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
@@ -3479,7 +3636,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);
   }
   /**
@@ -3533,6 +3693,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
@@ -3699,7 +3903,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) {
@@ -3755,7 +3961,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;
@@ -3788,13 +3994,54 @@ var ReplayService = class {
     for (const file of files) {
       if (isBinaryFile(file)) continue;
       try {
-        const content = await readFileAsync(join6(this.outputDir, file), "utf-8");
+        const content = await readFileAsync(join7(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 readFileAsync(join7(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
@@ -4305,6 +4552,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
@@ -4316,9 +4569,9 @@ 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 = join6(this.outputDir, fileResult.file);
+        const filePath = join7(this.outputDir, fileResult.file);
         try {
-          const content = readFileSync2(filePath, "utf-8");
+          const content = readFileSync3(filePath, "utf-8");
           const stripped = stripConflictMarkers(content);
           writeFileSync2(filePath, stripped);
         } catch {
@@ -4348,12 +4601,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 = join6(this.outputDir, ".fernignore");
-    if (!existsSync2(fernignorePath)) return [];
-    return readFileSync2(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") ?? [];
@@ -4393,10 +4645,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);
@@ -4445,7 +4710,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 {
@@ -4480,7 +4745,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++) {
@@ -4502,7 +4798,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;
@@ -4514,8 +4810,8 @@ function stripFernignoreDiffSections(patchContent, matchesFernignore) {
 
 // src/FernignoreMigrator.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname5, join as join7 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname5, join as join8 } from "path";
 import { minimatch as minimatch6 } from "minimatch";
 import { parse as parse2, stringify as stringify2 } from "yaml";
 var FernignoreMigrator = class {
@@ -4528,14 +4824,14 @@ var FernignoreMigrator = class {
     this.outputDir = outputDir;
   }
   fernignoreExists() {
-    return existsSync3(join7(this.outputDir, ".fernignore"));
+    return existsSync3(join8(this.outputDir, ".fernignore"));
   }
   readFernignorePatterns() {
-    const fernignorePath = join7(this.outputDir, ".fernignore");
+    const fernignorePath = join8(this.outputDir, ".fernignore");
     if (!existsSync3(fernignorePath)) {
       return [];
     }
-    const content = readFileSync3(fernignorePath, "utf-8");
+    const content = readFileSync4(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. */
@@ -4640,7 +4936,7 @@ var FernignoreMigrator = class {
     return results;
   }
   readFileContent(filePath) {
-    const fullPath = join7(this.outputDir, filePath);
+    const fullPath = join8(this.outputDir, filePath);
     if (!existsSync3(fullPath)) {
       return null;
     }
@@ -4649,7 +4945,7 @@ var FernignoreMigrator = class {
       if (stat.isDirectory()) {
         return null;
       }
-      return readFileSync3(fullPath, "utf-8");
+      return readFileSync4(fullPath, "utf-8");
     } catch {
       return null;
     }
@@ -4705,10 +5001,10 @@ var FernignoreMigrator = class {
     };
   }
   movePatternsToReplayYml(patterns) {
-    const replayYmlPath = join7(this.outputDir, ".fern", "replay.yml");
+    const replayYmlPath = join8(this.outputDir, ".fern", "replay.yml");
     let config = {};
     if (existsSync3(replayYmlPath)) {
-      const content = readFileSync3(replayYmlPath, "utf-8");
+      const content = readFileSync4(replayYmlPath, "utf-8");
       config = parse2(content) ?? {};
     }
     const existing = config.exclude ?? [];
@@ -4724,8 +5020,8 @@ var FernignoreMigrator = class {
 
 // src/commands/bootstrap.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9 } from "path";
 init_GitClient();
 async function bootstrap(outputDir, options) {
   const git = new GitClient(outputDir);
@@ -4892,10 +5188,10 @@ function parseGitLog(log) {
 }
 var REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
 function ensureFernignoreEntries(outputDir) {
-  const fernignorePath = join8(outputDir, ".fernignore");
+  const fernignorePath = join9(outputDir, ".fernignore");
   let content = "";
   if (existsSync4(fernignorePath)) {
-    content = readFileSync4(fernignorePath, "utf-8");
+    content = readFileSync5(fernignorePath, "utf-8");
   }
   const lines = content.split("\n");
   const toAdd = [];
@@ -4916,10 +5212,10 @@ function ensureFernignoreEntries(outputDir) {
 }
 var GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
 function ensureGitattributesEntries(outputDir) {
-  const gitattributesPath = join8(outputDir, ".gitattributes");
+  const gitattributesPath = join9(outputDir, ".gitattributes");
   let content = "";
   if (existsSync4(gitattributesPath)) {
-    content = readFileSync4(gitattributesPath, "utf-8");
+    content = readFileSync5(gitattributesPath, "utf-8");
   }
   const lines = content.split("\n");
   const toAdd = [];
@@ -4946,6 +5242,7 @@ function computeContentHash(patchContent) {
 }
 
 // src/commands/forget.ts
+init_GitClient();
 import { minimatch as minimatch7 } from "minimatch";
 function parseDiffStat(patchContent) {
   let additions = 0;
@@ -5005,7 +5302,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 };
@@ -5016,9 +5334,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();
     }
@@ -5047,8 +5363,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();
@@ -5116,7 +5432,7 @@ function reset(outputDir, options) {
 // src/commands/resolve.ts
 init_GitClient();
 import { readFile as readFile4 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 async function resolve(outputDir, options) {
   const lockManager = new LockfileManager(outputDir);
   if (!lockManager.exists()) {
@@ -5156,15 +5472,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) => readFile4(join9(outputDir, f), "utf-8").catch(() => null),
+        (f) => readFile4(join10(outputDir, f), "utf-8").catch(() => null),
         (files) => git.exec(["diff", currentGen, "--", ...files]).catch(() => null)
       );
       if (result === null) {
@@ -5198,7 +5515,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) {
@@ -5220,7 +5557,7 @@ async function resolve(outputDir, options) {
       const theirsSnapshot = {};
       for (const file of filesForSnapshot) {
         if (isBinaryFile(file)) continue;
-        const content = await readFile4(join9(outputDir, file), "utf-8").catch(() => null);
+        const content = await readFile4(join10(outputDir, file), "utf-8").catch(() => null);
         if (content != null) {
           theirsSnapshot[file] = content;
         }
@@ -5247,6 +5584,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
     };
   }
@@ -5294,7 +5632,9 @@ function status(outputDir) {
       lastGeneration: void 0,
       patches: [],
       unresolvedCount: 0,
-      excludePatterns: []
+      excludePatterns: [],
+      dismissed: [],
+      legacyDismissedCount: 0
     };
   }
   const lock = lockManager.read();
@@ -5323,13 +5663,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
   };
 }
 export {