@fern-api/replay 0.15.2 → 0.16.0

package/dist/index.d.cts

@@ -12,8 +12,6 @@ interface GenerationRecord {
     timestamp: string;
     cli_version: string;
     generator_versions: Record<string, string>;
-    /** SHA of the base branch HEAD before replay ran. Always on main's lineage. */
-    base_branch_head?: string;
 }
 interface StoredPatch {
     id: string;
@@ -259,22 +257,24 @@ declare class ReplayDetector {
     private sdkOutputDir;
     readonly warnings: string[];
     constructor(git: GitClient, lockManager: LockfileManager, sdkOutputDir: string);
-    detectNewPatches(): Promise<DetectionResult>;
     /**
-     * Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+     * Derive the previous-generation SHA from git history instead of trusting
+     * `lock.current_generation`.
+     *
+     * Walks `git log HEAD --first-parent` and returns the SHA of the most recent
+     * commit that `isGenerationBoundary` classifies as a customization-baseline
+     * boundary, or null if no such commit is reachable from HEAD on the mainline.
      *
-     * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
-     * `[fern-generated]`) is orphaned but still in git's object database. The
-     * merge-base is the commit on main from which the bot's branch was created —
-     * a reachable ancestor of HEAD. Walking that range and classifying each
-     * commit via `isGenerationCommit` mirrors the linear path and eliminates
-     * the bug class where pipeline-driven changes (autoversion, replay,
-     * generation) get bundled as customer customizations.
+     * `isGenerationBoundary` is intentionally narrower than `isGenerationCommit`:
+     * it excludes `[fern-autoversion]` (lightweight bumps that don't reset the
+     * baseline) and the GitHub merge-commit subject for fern-bot regen PRs
+     * (which sits on first-parent but where the customer fix-up commits live
+     * on second-parent — stopping at the merge would hide them).
      *
-     * Falls through to the legacy composite path when no common ancestor exists
-     * (truly disjoint history — orphan branches with no shared root).
+     * See docs/adr/0001-derived-scan-boundary.md.
      */
-    private detectPatchesViaMergeBase;
+    findPreviousGenerationFromHistory(): Promise<string | null>;
+    detectNewPatches(): Promise<DetectionResult>;
     /**
      * Walk `${rangeStart}..HEAD`, classify each commit, emit one
      * `StoredPatch` per customer commit. Body shared by the linear path
@@ -368,6 +368,13 @@ declare class ReplayDetector {
     private resolveDiffBase;
     private parseGitLog;
     private getLastGeneration;
+    /**
+     * Build a transient `GenerationRecord` from a SHA derived by walking git
+     * history. Only `commit_sha` (and `tree_hash` when needed downstream) is
+     * load-bearing here; the rest are filled with defensible placeholders.
+     * This record is consumed by `detectPatchesInRange` and is never persisted.
+     */
+    private synthesizeGenerationRecord;
 }
 
 /**
@@ -468,7 +475,6 @@ declare class ReplayApplicator {
 interface CommitOptions {
     cliVersion: string;
     generatorVersions: Record<string, string>;
-    baseBranchHead?: string;
 }
 declare class ReplayCommitter {
     private git;
@@ -587,12 +593,10 @@ interface ReplayOptions {
     generatorVersions?: Record<string, string>;
     /** Commit generation + update lockfile, skip detection/application */
     skipApplication?: boolean;
-    /** SHA of the base branch HEAD before replay runs. Stored in lockfile for squash merge recovery. */
-    baseBranchHead?: string;
 }
 /**
  * Options honored by `applyPreparedReplay()`. `cliVersion`, `generatorVersions`,
- * `baseBranchHead`, `dryRun`, and `skipApplication` were all captured in phase 1
+ * `dryRun`, and `skipApplication` were all captured in phase 1
  * and re-supplying them here is meaningless.
  */
 interface ApplyOptions {
@@ -612,8 +616,8 @@ interface ApplyOptions {
  *   respected. `rebasePatches` uses `currentGenerationSha` (the pure `[fern-generated]`
  *   SHA), NOT HEAD — mid-phase commits do not retarget patches' `base_generation`.
  * - The service instance is single-use across the phase boundary: do not call
- *   other service methods (`syncFromDivergentMerge`, another `prepareReplay`, etc.)
- *   between phases. In-memory lockfile and warning state would be corrupted.
+ *   another `prepareReplay()` between phases. In-memory lockfile and warning
+ *   state would be corrupted.
  * - If the caller's mid-phase work throws or `applyPreparedReplay` is never called,
  *   the repo is left with the new `[fern-generated]` commit but a stale lockfile.
  *   Consumers MUST either (a) still call `applyPreparedReplay` so the lockfile
@@ -628,8 +632,6 @@ interface ReplayPreparation {
     previousGenerationSha: string | null;
     /** SHA of the new [fern-generated] commit created by prepareReplay (or HEAD for dry-run terminals) */
     currentGenerationSha: string;
-    /** options.baseBranchHead passed through */
-    baseBranchHead: string | null;
     /** @internal Opaque state consumed by applyPreparedReplay */
     readonly _prepared: InternalPreparationState;
 }
@@ -749,21 +751,6 @@ declare class ReplayService {
      * Behavior is byte-identical to the pre-split implementation for all existing callers.
      */
     runReplay(options?: ReplayOptions): Promise<ReplayReport>;
-    /**
-     * Sync the lockfile after a divergent PR was squash-merged.
-     * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
-     *
-     * After updating the generation record, re-detects customer patches via
-     * tree diff between the generation tag (pure generation tree) and HEAD
-     * (which includes customer customizations after squash merge). This ensures
-     * patches survive the squash merge → regenerate cycle even when the lockfile
-     * was restored from the base branch during conflict PR creation.
-     */
-    syncFromDivergentMerge(generationCommitSha: string, options?: {
-        cliVersion?: string;
-        generatorVersions?: Record<string, string>;
-        baseBranchHead?: string;
-    }): Promise<void>;
     private determineFlow;
     /**
      * Rebase cleanly applied patches so they are relative to the current generation.

package/dist/index.d.ts

@@ -12,8 +12,6 @@ interface GenerationRecord {
     timestamp: string;
     cli_version: string;
     generator_versions: Record<string, string>;
-    /** SHA of the base branch HEAD before replay ran. Always on main's lineage. */
-    base_branch_head?: string;
 }
 interface StoredPatch {
     id: string;
@@ -259,22 +257,24 @@ declare class ReplayDetector {
     private sdkOutputDir;
     readonly warnings: string[];
     constructor(git: GitClient, lockManager: LockfileManager, sdkOutputDir: string);
-    detectNewPatches(): Promise<DetectionResult>;
     /**
-     * Non-linear-history detection via `merge-base(prevGen, HEAD)`.
+     * Derive the previous-generation SHA from git history instead of trusting
+     * `lock.current_generation`.
+     *
+     * Walks `git log HEAD --first-parent` and returns the SHA of the most recent
+     * commit that `isGenerationBoundary` classifies as a customization-baseline
+     * boundary, or null if no such commit is reachable from HEAD on the mainline.
      *
-     * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
-     * `[fern-generated]`) is orphaned but still in git's object database. The
-     * merge-base is the commit on main from which the bot's branch was created —
-     * a reachable ancestor of HEAD. Walking that range and classifying each
-     * commit via `isGenerationCommit` mirrors the linear path and eliminates
-     * the bug class where pipeline-driven changes (autoversion, replay,
-     * generation) get bundled as customer customizations.
+     * `isGenerationBoundary` is intentionally narrower than `isGenerationCommit`:
+     * it excludes `[fern-autoversion]` (lightweight bumps that don't reset the
+     * baseline) and the GitHub merge-commit subject for fern-bot regen PRs
+     * (which sits on first-parent but where the customer fix-up commits live
+     * on second-parent — stopping at the merge would hide them).
      *
-     * Falls through to the legacy composite path when no common ancestor exists
-     * (truly disjoint history — orphan branches with no shared root).
+     * See docs/adr/0001-derived-scan-boundary.md.
      */
-    private detectPatchesViaMergeBase;
+    findPreviousGenerationFromHistory(): Promise<string | null>;
+    detectNewPatches(): Promise<DetectionResult>;
     /**
      * Walk `${rangeStart}..HEAD`, classify each commit, emit one
      * `StoredPatch` per customer commit. Body shared by the linear path
@@ -368,6 +368,13 @@ declare class ReplayDetector {
     private resolveDiffBase;
     private parseGitLog;
     private getLastGeneration;
+    /**
+     * Build a transient `GenerationRecord` from a SHA derived by walking git
+     * history. Only `commit_sha` (and `tree_hash` when needed downstream) is
+     * load-bearing here; the rest are filled with defensible placeholders.
+     * This record is consumed by `detectPatchesInRange` and is never persisted.
+     */
+    private synthesizeGenerationRecord;
 }
 
 /**
@@ -468,7 +475,6 @@ declare class ReplayApplicator {
 interface CommitOptions {
     cliVersion: string;
     generatorVersions: Record<string, string>;
-    baseBranchHead?: string;
 }
 declare class ReplayCommitter {
     private git;
@@ -587,12 +593,10 @@ interface ReplayOptions {
     generatorVersions?: Record<string, string>;
     /** Commit generation + update lockfile, skip detection/application */
     skipApplication?: boolean;
-    /** SHA of the base branch HEAD before replay runs. Stored in lockfile for squash merge recovery. */
-    baseBranchHead?: string;
 }
 /**
  * Options honored by `applyPreparedReplay()`. `cliVersion`, `generatorVersions`,
- * `baseBranchHead`, `dryRun`, and `skipApplication` were all captured in phase 1
+ * `dryRun`, and `skipApplication` were all captured in phase 1
  * and re-supplying them here is meaningless.
  */
 interface ApplyOptions {
@@ -612,8 +616,8 @@ interface ApplyOptions {
  *   respected. `rebasePatches` uses `currentGenerationSha` (the pure `[fern-generated]`
  *   SHA), NOT HEAD — mid-phase commits do not retarget patches' `base_generation`.
  * - The service instance is single-use across the phase boundary: do not call
- *   other service methods (`syncFromDivergentMerge`, another `prepareReplay`, etc.)
- *   between phases. In-memory lockfile and warning state would be corrupted.
+ *   another `prepareReplay()` between phases. In-memory lockfile and warning
+ *   state would be corrupted.
  * - If the caller's mid-phase work throws or `applyPreparedReplay` is never called,
  *   the repo is left with the new `[fern-generated]` commit but a stale lockfile.
  *   Consumers MUST either (a) still call `applyPreparedReplay` so the lockfile
@@ -628,8 +632,6 @@ interface ReplayPreparation {
     previousGenerationSha: string | null;
     /** SHA of the new [fern-generated] commit created by prepareReplay (or HEAD for dry-run terminals) */
     currentGenerationSha: string;
-    /** options.baseBranchHead passed through */
-    baseBranchHead: string | null;
     /** @internal Opaque state consumed by applyPreparedReplay */
     readonly _prepared: InternalPreparationState;
 }
@@ -749,21 +751,6 @@ declare class ReplayService {
      * Behavior is byte-identical to the pre-split implementation for all existing callers.
      */
     runReplay(options?: ReplayOptions): Promise<ReplayReport>;
-    /**
-     * Sync the lockfile after a divergent PR was squash-merged.
-     * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
-     *
-     * After updating the generation record, re-detects customer patches via
-     * tree diff between the generation tag (pure generation tree) and HEAD
-     * (which includes customer customizations after squash merge). This ensures
-     * patches survive the squash merge → regenerate cycle even when the lockfile
-     * was restored from the base branch during conflict PR creation.
-     */
-    syncFromDivergentMerge(generationCommitSha: string, options?: {
-        cliVersion?: string;
-        generatorVersions?: Record<string, string>;
-        baseBranchHead?: string;
-    }): Promise<void>;
     private determineFlow;
     /**
      * Rebase cleanly applied patches so they are relative to the current generation.

package/dist/index.js

@@ -499,9 +499,22 @@ function isGenerationCommit(commit) {
   const hasGenerationMarker = commit.message.startsWith("[fern-generated]") || commit.message.startsWith("[fern-replay]") || commit.message.startsWith("[fern-autoversion]") || commit.message.includes("Generated by Fern") || commit.message.includes("\u{1F916} Generated with Fern") || // Squash merge of a Fern-generated PR uses the PR title as commit message.
   // The default PR title is "SDK Generation" (from GithubStep's commitMessage default).
   // GitHub appends "(#N)" for the PR number, e.g. "SDK Generation (#70)".
-  commit.message.startsWith("SDK Generation");
+  commit.message.startsWith("SDK Generation") || // Merge commit (GitHub's "Create a merge commit" option) of a fern-bot
+  // regen PR. First-parent walking lands on this commit, not on the
+  // generation commit on the side branch, so the classifier must treat
+  // it as a generation boundary. GitHub's default subject is
+  // "Merge pull request #N from <owner>/<branch>"; fern-bot branches are
+  // named "<owner>/fern-bot/<...>".
+  /^Merge pull request #\d+ from [^/]+\/fern-bot\//.test(commit.message);
   return isBotAuthor || hasGenerationMarker;
 }
+function isGenerationBoundary(commit) {
+  const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
+  const isBotAuthor = !isFernSupport && (commit.authorLogin === FERN_BOT_LOGIN || commit.authorEmail === FERN_BOT_EMAIL || commit.authorName === FERN_BOT_NAME);
+  const isAutoversion = commit.message.startsWith("[fern-autoversion]");
+  const hasBoundaryMarker = commit.message.startsWith("[fern-generated]") || commit.message.startsWith("[fern-replay]") || commit.message.includes("Generated by Fern") || commit.message.includes("\u{1F916} Generated with Fern") || commit.message.startsWith("SDK Generation");
+  return isBotAuthor && !isAutoversion || hasBoundaryMarker;
+}
 function isReplayCommit(commit) {
   return commit.message.startsWith("[fern-replay]");
 }
@@ -829,8 +842,48 @@ var ReplayDetector = class {
     this.lockManager = lockManager;
     this.sdkOutputDir = sdkOutputDir;
   }
+  /**
+   * Derive the previous-generation SHA from git history instead of trusting
+   * `lock.current_generation`.
+   *
+   * Walks `git log HEAD --first-parent` and returns the SHA of the most recent
+   * commit that `isGenerationBoundary` classifies as a customization-baseline
+   * boundary, or null if no such commit is reachable from HEAD on the mainline.
+   *
+   * `isGenerationBoundary` is intentionally narrower than `isGenerationCommit`:
+   * it excludes `[fern-autoversion]` (lightweight bumps that don't reset the
+   * baseline) and the GitHub merge-commit subject for fern-bot regen PRs
+   * (which sits on first-parent but where the customer fix-up commits live
+   * on second-parent — stopping at the merge would hide them).
+   *
+   * See docs/adr/0001-derived-scan-boundary.md.
+   */
+  async findPreviousGenerationFromHistory() {
+    let log;
+    try {
+      log = await this.git.exec([
+        "log",
+        "--first-parent",
+        "--format=%H%x00%an%x00%ae%x00%s",
+        "HEAD"
+      ]);
+    } catch {
+      return null;
+    }
+    for (const commit of this.parseGitLog(log)) {
+      if (isGenerationBoundary(commit)) {
+        return commit.sha;
+      }
+    }
+    return null;
+  }
   async detectNewPatches() {
     const lock = this.lockManager.read();
+    const derivedSha = await this.findPreviousGenerationFromHistory();
+    if (derivedSha !== null) {
+      const derivedRecord = await this.synthesizeGenerationRecord(derivedSha);
+      return this.detectPatchesInRange(derivedSha, derivedRecord, lock);
+    }
     const lastGen = this.getLastGeneration(lock);
     if (!lastGen) {
       return { patches: [], revertedPatchIds: [] };
@@ -838,7 +891,7 @@ var ReplayDetector = class {
     const exists = await this.git.commitExists(lastGen.commit_sha);
     if (!exists) {
       this.warnings.push(
-        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to alternate detection.`
+        `Generation commit ${lastGen.commit_sha.slice(0, 7)} not found in git history. Falling back to tree-diff detection (likely a shallow clone).`
       );
       return this.detectPatchesViaTreeDiff(
         lastGen,
@@ -846,44 +899,8 @@ var ReplayDetector = class {
         true
       );
     }
-    const isAncestor = await this.git.isAncestor(lastGen.commit_sha, "HEAD");
-    if (!isAncestor) {
-      return this.detectPatchesViaMergeBase(lastGen, lock);
-    }
     return this.detectPatchesInRange(lastGen.commit_sha, lastGen, lock);
   }
-  /**
-   * Non-linear-history detection via `merge-base(prevGen, HEAD)`.
-   *
-   * After a squash-merge of a Fern-bot PR, `lastGen.commit_sha` (the previous
-   * `[fern-generated]`) is orphaned but still in git's object database. The
-   * merge-base is the commit on main from which the bot's branch was created —
-   * a reachable ancestor of HEAD. Walking that range and classifying each
-   * commit via `isGenerationCommit` mirrors the linear path and eliminates
-   * the bug class where pipeline-driven changes (autoversion, replay,
-   * generation) get bundled as customer customizations.
-   *
-   * Falls through to the legacy composite path when no common ancestor exists
-   * (truly disjoint history — orphan branches with no shared root).
-   */
-  async detectPatchesViaMergeBase(lastGen, lock) {
-    let mergeBase = "";
-    try {
-      mergeBase = (await this.git.exec(["merge-base", lastGen.commit_sha, "HEAD"])).trim();
-    } catch {
-    }
-    if (!mergeBase) {
-      this.warnings.push(
-        `No common ancestor between previous generation ${lastGen.commit_sha.slice(0, 7)} and HEAD. Falling back to composite tree-diff detection.`
-      );
-      return this.detectPatchesViaTreeDiff(
-        lastGen,
-        /* commitKnownMissing */
-        false
-      );
-    }
-    return this.detectPatchesInRange(mergeBase, lastGen, lock);
-  }
   /**
    * Walk `${rangeStart}..HEAD`, classify each commit, emit one
    * `StoredPatch` per customer commit. Body shared by the linear path
@@ -1319,6 +1336,26 @@ var ReplayDetector = class {
   getLastGeneration(lock) {
     return lock.generations.find((g) => g.commit_sha === lock.current_generation);
   }
+  /**
+   * Build a transient `GenerationRecord` from a SHA derived by walking git
+   * history. Only `commit_sha` (and `tree_hash` when needed downstream) is
+   * load-bearing here; the rest are filled with defensible placeholders.
+   * This record is consumed by `detectPatchesInRange` and is never persisted.
+   */
+  async synthesizeGenerationRecord(sha) {
+    let tree_hash = "";
+    try {
+      tree_hash = await this.git.getTreeHash(sha);
+    } catch {
+    }
+    return {
+      commit_sha: sha,
+      tree_hash,
+      timestamp: (/* @__PURE__ */ new Date(0)).toISOString(),
+      cli_version: "",
+      generator_versions: {}
+    };
+  }
 };
 
 // src/ThreeWayMerge.ts
@@ -2458,8 +2495,7 @@ Patches absorbed by generator (${buckets.absorbed.length}):`;
       tree_hash: treeHash,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       cli_version: options?.cliVersion ?? "unknown",
-      generator_versions: options?.generatorVersions ?? {},
-      base_branch_head: options?.baseBranchHead
+      generator_versions: options?.generatorVersions ?? {}
     };
   }
   async stageAll() {
@@ -2846,7 +2882,6 @@ var FirstGenerationFlow = class {
         flow: "first-generation",
         previousGenerationSha: null,
         currentGenerationSha: headSha,
-        baseBranchHead: options.baseBranchHead ?? null,
         _prepared: {
           kind: "terminal",
           flow: "first-generation",
@@ -2856,8 +2891,7 @@ var FirstGenerationFlow = class {
     }
     const commitOpts = options ? {
       cliVersion: options.cliVersion ?? "unknown",
-      generatorVersions: options.generatorVersions ?? {},
-      baseBranchHead: options.baseBranchHead
+      generatorVersions: options.generatorVersions ?? {}
     } : void 0;
     await this.service.committer.commitGeneration("Initial SDK generation", commitOpts);
     const genRecord = await this.service.committer.createGenerationRecord(commitOpts);
@@ -2866,7 +2900,6 @@ var FirstGenerationFlow = class {
       flow: "first-generation",
       previousGenerationSha: null,
       currentGenerationSha: genRecord.commit_sha,
-      baseBranchHead: options?.baseBranchHead ?? null,
       _prepared: {
         kind: "active",
         flow: "first-generation",
@@ -2903,8 +2936,7 @@ var SkipApplicationFlow = class {
   async prepare(options) {
     const commitOpts = options ? {
       cliVersion: options.cliVersion ?? "unknown",
-      generatorVersions: options.generatorVersions ?? {},
-      baseBranchHead: options.baseBranchHead
+      generatorVersions: options.generatorVersions ?? {}
     } : void 0;
     await this.service.committer.commitGeneration("Update SDK (replay skipped)", commitOpts);
     await this.service.cleanupStaleConflictMarkers();
@@ -2926,7 +2958,6 @@ var SkipApplicationFlow = class {
       flow: "skip-application",
       previousGenerationSha,
       currentGenerationSha: genRecord.commit_sha,
-      baseBranchHead: options?.baseBranchHead ?? null,
       _prepared: {
         kind: "active",
         flow: "skip-application",
@@ -2987,7 +3018,6 @@ var NoPatchesFlow = class {
         flow: "no-patches",
         previousGenerationSha,
         currentGenerationSha: headSha,
-        baseBranchHead: options.baseBranchHead ?? null,
         _prepared: {
           kind: "terminal",
           flow: "no-patches",
@@ -3019,8 +3049,7 @@ var NoPatchesFlow = class {
     }
     const commitOpts = options ? {
       cliVersion: options.cliVersion ?? "unknown",
-      generatorVersions: options.generatorVersions ?? {},
-      baseBranchHead: options.baseBranchHead
+      generatorVersions: options.generatorVersions ?? {}
     } : void 0;
     await this.service.committer.commitGeneration("Update SDK", commitOpts);
     await this.service.cleanupStaleConflictMarkers();
@@ -3030,7 +3059,6 @@ var NoPatchesFlow = class {
       flow: "no-patches",
       previousGenerationSha,
       currentGenerationSha: genRecord.commit_sha,
-      baseBranchHead: options?.baseBranchHead ?? null,
       _prepared: {
         kind: "active",
         flow: "no-patches",
@@ -3120,7 +3148,6 @@ var NormalRegenerationFlow = class {
         flow: "normal-regeneration",
         previousGenerationSha,
         currentGenerationSha: headSha,
-        baseBranchHead: options.baseBranchHead ?? null,
         _prepared: {
           kind: "terminal",
           flow: "normal-regeneration",
@@ -3138,14 +3165,16 @@ var NormalRegenerationFlow = class {
     existingPatches = this.service.lockManager.getPatches();
     const seenHashes = /* @__PURE__ */ new Map();
     for (const p of existingPatches) {
-      const priorPatchId = seenHashes.get(p.content_hash);
-      if (priorPatchId !== void 0) {
-        this.service.lockManager.removePatch(p.id);
-        this.service.warnings.push(
-          `Consolidated patch ${p.id} (commit ${(p.original_commit || "<missing>").slice(0, 7)}) into prior patch ${priorPatchId}: byte-identical patch_content. Per-commit attribution preserved in git log; lockfile collapsed to avoid duplicate-apply corruption on next regen.`
-        );
-      } else {
-        seenHashes.set(p.content_hash, p.id);
+      if (!p.original_commit || p.original_commit === "") {
+        const priorPatchId = seenHashes.get(p.content_hash);
+        if (priorPatchId !== void 0) {
+          this.service.lockManager.removePatch(p.id);
+          this.service.warnings.push(
+            `Consolidated patch ${p.id} into prior patch ${priorPatchId}: byte-identical patch_content. Lockfile collapsed to avoid duplicate-apply corruption on next regen.`
+          );
+        } else {
+          seenHashes.set(p.content_hash, p.id);
+        }
       }
     }
     existingPatches = this.service.lockManager.getPatches();
@@ -3174,8 +3203,7 @@ var NormalRegenerationFlow = class {
     const allPatches = [...existingPatches, ...newPatches];
     const commitOpts = options ? {
       cliVersion: options.cliVersion ?? "unknown",
-      generatorVersions: options.generatorVersions ?? {},
-      baseBranchHead: options.baseBranchHead
+      generatorVersions: options.generatorVersions ?? {}
     } : void 0;
     await this.service.committer.commitGeneration("Update SDK", commitOpts);
     await this.service.cleanupStaleConflictMarkers();
@@ -3185,7 +3213,6 @@ var NormalRegenerationFlow = class {
       flow: "normal-regeneration",
       previousGenerationSha,
       currentGenerationSha: genRecord.commit_sha,
-      baseBranchHead: options?.baseBranchHead ?? null,
       _prepared: {
         kind: "active",
         flow: "normal-regeneration",
@@ -3378,68 +3405,6 @@ var ReplayService = class {
     const prep = await this.prepareReplay(options);
     return this.applyPreparedReplay(prep, options);
   }
-  /**
-   * Sync the lockfile after a divergent PR was squash-merged.
-   * Call this BEFORE runReplay() when the CLI detects a merged divergent PR.
-   *
-   * After updating the generation record, re-detects customer patches via
-   * tree diff between the generation tag (pure generation tree) and HEAD
-   * (which includes customer customizations after squash merge). This ensures
-   * patches survive the squash merge → regenerate cycle even when the lockfile
-   * was restored from the base branch during conflict PR creation.
-   */
-  async syncFromDivergentMerge(generationCommitSha, options) {
-    const treeHash = await this.git.getTreeHash(generationCommitSha);
-    const timestamp = (await this.git.exec(["log", "-1", "--format=%aI", generationCommitSha])).trim();
-    const record = {
-      commit_sha: generationCommitSha,
-      tree_hash: treeHash,
-      timestamp,
-      cli_version: options?.cliVersion ?? "unknown",
-      generator_versions: options?.generatorVersions ?? {},
-      base_branch_head: options?.baseBranchHead
-    };
-    let resolvedPatches;
-    if (!this.lockManager.exists()) {
-      this.lockManager.initializeInMemory(record);
-    } else {
-      this.lockManager.read();
-      const unresolvedPatches = [
-        ...this.lockManager.getUnresolvedPatches(),
-        ...this.lockManager.getResolvingPatches()
-      ];
-      resolvedPatches = this.lockManager.getPatches().filter((p) => p.status == null);
-      this.lockManager.addGeneration(record);
-      this.lockManager.clearPatches();
-      for (const patch of unresolvedPatches) {
-        this.lockManager.addPatch(patch);
-      }
-    }
-    try {
-      const { patches: redetectedPatches } = await this.detector.detectNewPatches();
-      if (redetectedPatches.length > 0) {
-        const redetectedFiles = new Set(redetectedPatches.flatMap((p) => p.files));
-        const currentPatches = this.lockManager.getPatches();
-        for (const patch of currentPatches) {
-          if (patch.status != null && patch.files.some((f) => redetectedFiles.has(f))) {
-            this.lockManager.removePatch(patch.id);
-          }
-        }
-        for (const patch of redetectedPatches) {
-          this.lockManager.addPatch(patch);
-        }
-      }
-    } catch (error) {
-      for (const patch of resolvedPatches ?? []) {
-        this.lockManager.addPatch(patch);
-      }
-      this.detector.warnings.push(
-        `Patch re-detection failed after divergent merge sync. ${(resolvedPatches ?? []).length} previously resolved patch(es) preserved. Error: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    this.lockManager.save();
-    this.detector.warnings.push(...this.lockManager.warnings);
-  }
   determineFlow() {
     try {
       const lock = this.lockManager.read();