@fern-api/replay 0.6.1 → 0.7.0

package/dist/index.d.cts

@@ -23,6 +23,10 @@ interface StoredPatch {
     base_generation: string;
     files: string[];
     patch_content: string;
+    /** When "unresolved", the patch conflicted during CI and needs local resolution.
+     *  When "resolving", the resolve command has applied patches to the working tree
+     *  and is waiting for the customer to resolve conflicts and run resolve again. */
+    status?: "unresolved" | "resolving";
 }
 interface CustomizationsConfig {
     exclude?: string[];
@@ -123,9 +127,13 @@ declare class LockfileManager {
     save(): void;
     addGeneration(record: GenerationRecord): void;
     addPatch(patch: StoredPatch): void;
-    updatePatch(patchId: string, updates: Partial<Pick<StoredPatch, "base_generation" | "patch_content" | "content_hash" | "files">>): void;
+    updatePatch(patchId: string, updates: Partial<Pick<StoredPatch, "base_generation" | "patch_content" | "content_hash" | "files" | "status">>): void;
     removePatch(patchId: string): void;
     clearPatches(): void;
+    getUnresolvedPatches(): StoredPatch[];
+    getResolvingPatches(): StoredPatch[];
+    markPatchUnresolved(patchId: string): void;
+    markPatchResolved(patchId: string, updates: Pick<StoredPatch, "patch_content" | "content_hash" | "base_generation" | "files">): void;
     getPatches(): StoredPatch[];
     setReplaySkippedAt(timestamp: string): void;
     clearReplaySkippedAt(): void;
@@ -201,7 +209,7 @@ declare class ReplayCommitter {
     private outputDir;
     constructor(git: GitClient, outputDir: string);
     commitGeneration(message: string, options?: CommitOptions): Promise<string>;
-    commitReplay(patchCount: number, patches?: StoredPatch[]): Promise<string>;
+    commitReplay(_patchCount: number, patches?: StoredPatch[], message?: string): Promise<string>;
     createGenerationRecord(options?: CommitOptions): Promise<GenerationRecord>;
     stageAll(): Promise<void>;
     hasStagedChanges(): Promise<boolean>;
@@ -216,6 +224,12 @@ interface ConflictDetail {
     /** Files that applied cleanly in a patch that also had conflicts. */
     cleanFiles?: string[];
 }
+interface UnresolvedPatchInfo {
+    patchId: string;
+    patchMessage: string;
+    files: string[];
+    conflictDetails: FileResult[];
+}
 interface ReplayReport {
     flow: "first-generation" | "no-patches" | "normal-regeneration" | "skip-application";
     patchesDetected: number;
@@ -231,6 +245,8 @@ interface ReplayReport {
     patchesRefreshed?: number;
     conflicts: FileResult[];
     conflictDetails?: ConflictDetail[];
+    /** Patches that conflicted and need local resolution via `fern-replay resolve` */
+    unresolvedPatches?: UnresolvedPatchInfo[];
     wouldApply?: StoredPatch[];
     warnings?: string[];
 }
@@ -303,6 +319,16 @@ declare class ReplayService {
      * Called BEFORE commitGeneration() while HEAD has customer code.
      */
     private preGenerationRebase;
+    /**
+     * Strip conflict markers from file content, keeping the OURS (Generated) side.
+     * Preserves clean patches' non-conflicting changes on shared files.
+     */
+    private stripConflictMarkers;
+    /**
+     * After applyPatches(), strip conflict markers from conflicting files
+     * so only clean content is committed. Keeps the Generated (OURS) side.
+     */
+    private revertConflictingFiles;
     private readFernignorePatterns;
     private buildReport;
 }
@@ -427,10 +453,16 @@ interface ResolveResult {
     success: boolean;
     /** Commit SHA of the [fern-replay] commit, if created */
     commitSha?: string;
-    /** Reason for failure */
+    /** Reason for failure or current state */
     reason?: string;
-    /** Files that still have conflict markers */
+    /** Files that have conflict markers */
     unresolvedFiles?: string[];
+    /** Phase the command executed */
+    phase?: "applied" | "committed" | "nothing-to-resolve";
+    /** Number of patches applied to working tree (phase 1) */
+    patchesApplied?: number;
+    /** Number of patches resolved and committed (phase 2) */
+    patchesResolved?: number;
 }
 declare function resolve(outputDir: string, options?: ResolveOptions): Promise<ResolveResult>;
 
@@ -460,4 +492,4 @@ interface StatusGeneration {
 }
 declare function status(outputDir: string): StatusResult;
 
-export { type BootstrapOptions, type BootstrapResult, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CustomizationsConfig, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, bootstrap, forget, isGenerationCommit, isReplayCommit, reset, resolve, status, threeWayMerge };
+export { type BootstrapOptions, type BootstrapResult, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CustomizationsConfig, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, type UnresolvedPatchInfo, bootstrap, forget, isGenerationCommit, isReplayCommit, reset, resolve, status, threeWayMerge };

package/dist/index.d.ts

@@ -23,6 +23,10 @@ interface StoredPatch {
     base_generation: string;
     files: string[];
     patch_content: string;
+    /** When "unresolved", the patch conflicted during CI and needs local resolution.
+     *  When "resolving", the resolve command has applied patches to the working tree
+     *  and is waiting for the customer to resolve conflicts and run resolve again. */
+    status?: "unresolved" | "resolving";
 }
 interface CustomizationsConfig {
     exclude?: string[];
@@ -123,9 +127,13 @@ declare class LockfileManager {
     save(): void;
     addGeneration(record: GenerationRecord): void;
     addPatch(patch: StoredPatch): void;
-    updatePatch(patchId: string, updates: Partial<Pick<StoredPatch, "base_generation" | "patch_content" | "content_hash" | "files">>): void;
+    updatePatch(patchId: string, updates: Partial<Pick<StoredPatch, "base_generation" | "patch_content" | "content_hash" | "files" | "status">>): void;
     removePatch(patchId: string): void;
     clearPatches(): void;
+    getUnresolvedPatches(): StoredPatch[];
+    getResolvingPatches(): StoredPatch[];
+    markPatchUnresolved(patchId: string): void;
+    markPatchResolved(patchId: string, updates: Pick<StoredPatch, "patch_content" | "content_hash" | "base_generation" | "files">): void;
     getPatches(): StoredPatch[];
     setReplaySkippedAt(timestamp: string): void;
     clearReplaySkippedAt(): void;
@@ -201,7 +209,7 @@ declare class ReplayCommitter {
     private outputDir;
     constructor(git: GitClient, outputDir: string);
     commitGeneration(message: string, options?: CommitOptions): Promise<string>;
-    commitReplay(patchCount: number, patches?: StoredPatch[]): Promise<string>;
+    commitReplay(_patchCount: number, patches?: StoredPatch[], message?: string): Promise<string>;
     createGenerationRecord(options?: CommitOptions): Promise<GenerationRecord>;
     stageAll(): Promise<void>;
     hasStagedChanges(): Promise<boolean>;
@@ -216,6 +224,12 @@ interface ConflictDetail {
     /** Files that applied cleanly in a patch that also had conflicts. */
     cleanFiles?: string[];
 }
+interface UnresolvedPatchInfo {
+    patchId: string;
+    patchMessage: string;
+    files: string[];
+    conflictDetails: FileResult[];
+}
 interface ReplayReport {
     flow: "first-generation" | "no-patches" | "normal-regeneration" | "skip-application";
     patchesDetected: number;
@@ -231,6 +245,8 @@ interface ReplayReport {
     patchesRefreshed?: number;
     conflicts: FileResult[];
     conflictDetails?: ConflictDetail[];
+    /** Patches that conflicted and need local resolution via `fern-replay resolve` */
+    unresolvedPatches?: UnresolvedPatchInfo[];
     wouldApply?: StoredPatch[];
     warnings?: string[];
 }
@@ -303,6 +319,16 @@ declare class ReplayService {
      * Called BEFORE commitGeneration() while HEAD has customer code.
      */
     private preGenerationRebase;
+    /**
+     * Strip conflict markers from file content, keeping the OURS (Generated) side.
+     * Preserves clean patches' non-conflicting changes on shared files.
+     */
+    private stripConflictMarkers;
+    /**
+     * After applyPatches(), strip conflict markers from conflicting files
+     * so only clean content is committed. Keeps the Generated (OURS) side.
+     */
+    private revertConflictingFiles;
     private readFernignorePatterns;
     private buildReport;
 }
@@ -427,10 +453,16 @@ interface ResolveResult {
     success: boolean;
     /** Commit SHA of the [fern-replay] commit, if created */
     commitSha?: string;
-    /** Reason for failure */
+    /** Reason for failure or current state */
     reason?: string;
-    /** Files that still have conflict markers */
+    /** Files that have conflict markers */
     unresolvedFiles?: string[];
+    /** Phase the command executed */
+    phase?: "applied" | "committed" | "nothing-to-resolve";
+    /** Number of patches applied to working tree (phase 1) */
+    patchesApplied?: number;
+    /** Number of patches resolved and committed (phase 2) */
+    patchesResolved?: number;
 }
 declare function resolve(outputDir: string, options?: ResolveOptions): Promise<ResolveResult>;
 
@@ -460,4 +492,4 @@ interface StatusGeneration {
 }
 declare function status(outputDir: string): StatusResult;
 
-export { type BootstrapOptions, type BootstrapResult, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CustomizationsConfig, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, bootstrap, forget, isGenerationCommit, isReplayCommit, reset, resolve, status, threeWayMerge };
+export { type BootstrapOptions, type BootstrapResult, type CommitInfo, type CommitOptions, type ConflictDetail, type ConflictMetadata, type ConflictReason, type ConflictRegion, type CustomizationsConfig, FERN_BOT_EMAIL, FERN_BOT_LOGIN, FERN_BOT_NAME, FernignoreMigrator, type FileResult, type ForgetOptions, type ForgetResult, type GenerationLock, type GenerationRecord, GitClient, LockfileManager, type MergeResult, type MigrationAnalysis, type MigrationResult, type MoveDeclaration, ReplayApplicator, ReplayCommitter, type ReplayConfig, ReplayDetector, type ReplayOptions, type ReplayReport, type ReplayResult, ReplayService, type ResetOptions, type ResetResult, type ResolveOptions, type ResolveResult, type StatusGeneration, type StatusPatch, type StatusResult, type StoredPatch, type UnresolvedPatchInfo, bootstrap, forget, isGenerationCommit, isReplayCommit, reset, resolve, status, threeWayMerge };

package/dist/index.js

@@ -229,6 +229,26 @@ var LockfileManager = class {
     this.ensureLoaded();
     this.lock.patches = [];
   }
+  getUnresolvedPatches() {
+    this.ensureLoaded();
+    return this.lock.patches.filter((p) => p.status === "unresolved");
+  }
+  getResolvingPatches() {
+    this.ensureLoaded();
+    return this.lock.patches.filter((p) => p.status === "resolving");
+  }
+  markPatchUnresolved(patchId) {
+    this.updatePatch(patchId, { status: "unresolved" });
+  }
+  markPatchResolved(patchId, updates) {
+    this.ensureLoaded();
+    const patch = this.lock.patches.find((p) => p.id === patchId);
+    if (!patch) {
+      throw new Error(`Patch not found: ${patchId}`);
+    }
+    delete patch.status;
+    Object.assign(patch, updates);
+  }
   getPatches() {
     this.ensureLoaded();
     return this.lock.patches;
@@ -929,12 +949,12 @@ CLI Version: ${options.cliVersion}`;
     await this.git.exec(["commit", "-m", fullMessage]);
     return (await this.git.exec(["rev-parse", "HEAD"])).trim();
   }
-  async commitReplay(patchCount, patches) {
+  async commitReplay(_patchCount, patches, message) {
     await this.stageAll();
     if (!await this.hasStagedChanges()) {
       return (await this.git.exec(["rev-parse", "HEAD"])).trim();
     }
-    let fullMessage = `[fern-replay] Applied ${patchCount} customization(s)`;
+    let fullMessage = message ?? `[fern-replay] Applied customizations`;
     if (patches && patches.length > 0) {
       fullMessage += "\n\nPatches replayed:";
       for (const patch of patches) {
@@ -971,7 +991,7 @@ CLI Version: ${options.cliVersion}`;
 
 // src/ReplayService.ts
 init_GitClient();
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join3 } from "path";
 import { minimatch as minimatch2 } from "minimatch";
 var ReplayService = class {
@@ -1029,13 +1049,27 @@ var ReplayService = class {
       this.lockManager.initializeInMemory(record);
     } else {
       this.lockManager.read();
+      const unresolvedPatches = [
+        ...this.lockManager.getUnresolvedPatches(),
+        ...this.lockManager.getResolvingPatches()
+      ];
       this.lockManager.addGeneration(record);
       this.lockManager.clearPatches();
+      for (const patch of unresolvedPatches) {
+        this.lockManager.addPatch(patch);
+      }
     }
     this.lockManager.save();
     try {
       const 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);
         }
@@ -1143,6 +1177,12 @@ var ReplayService = class {
     let results = [];
     if (newPatches.length > 0) {
       results = await this.applicator.applyPatches(newPatches);
+      this.revertConflictingFiles(results);
+      for (const result of results) {
+        if (result.status === "conflict") {
+          result.patch.status = "unresolved";
+        }
+      }
     }
     const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
     for (const patch of newPatches) {
@@ -1153,10 +1193,8 @@ var ReplayService = class {
     this.lockManager.save();
     if (newPatches.length > 0) {
       if (!options?.stageOnly) {
-        const appliedCount = results.filter((r) => r.status === "applied" || r.status === "conflict").length;
-        if (appliedCount > 0) {
-          await this.committer.commitReplay(appliedCount, newPatches);
-        }
+        const appliedCount = results.filter((r) => r.status === "applied").length;
+        await this.committer.commitReplay(appliedCount, newPatches);
       } else {
         await this.committer.stageAll();
       }
@@ -1204,20 +1242,32 @@ var ReplayService = class {
     const genRecord = await this.committer.createGenerationRecord(commitOpts);
     this.lockManager.addGeneration(genRecord);
     const results = await this.applicator.applyPatches(allPatches);
+    this.revertConflictingFiles(results);
+    for (const result of results) {
+      if (result.status === "conflict") {
+        result.patch.status = "unresolved";
+      }
+    }
     const rebaseCounts = await this.rebasePatches(results, genRecord.commit_sha);
     for (const patch of newPatches) {
       if (!rebaseCounts.absorbedPatchIds.has(patch.id)) {
         this.lockManager.addPatch(patch);
       }
     }
+    for (const result of results) {
+      if (result.status === "conflict") {
+        try {
+          this.lockManager.markPatchUnresolved(result.patch.id);
+        } catch {
+        }
+      }
+    }
     this.lockManager.save();
     if (options?.stageOnly) {
       await this.committer.stageAll();
     } else {
-      const appliedCount = results.filter((r) => r.status === "applied" || r.status === "conflict").length;
-      if (appliedCount > 0) {
-        await this.committer.commitReplay(appliedCount, allPatches);
-      }
+      const appliedCount = results.filter((r) => r.status === "applied").length;
+      await this.committer.commitReplay(appliedCount, allPatches);
     }
     return this.buildReport(
       "normal-regeneration",
@@ -1365,6 +1415,10 @@ var ReplayService = class {
     let conflictAbsorbed = 0;
     let contentRefreshed = 0;
     for (const patch of patches) {
+      if (patch.status != null) {
+        delete patch.status;
+        continue;
+      }
       if (patch.base_generation === currentGen) {
         try {
           const diff = await this.git.exec(["diff", currentGen, "HEAD", "--", ...patch.files]).catch(() => null);
@@ -1415,6 +1469,55 @@ var ReplayService = class {
     }
     return { conflictResolved, conflictAbsorbed, contentRefreshed };
   }
+  /**
+   * Strip conflict markers from file content, keeping the OURS (Generated) side.
+   * Preserves clean patches' non-conflicting changes on shared files.
+   */
+  stripConflictMarkers(content) {
+    const lines = content.split("\n");
+    const result = [];
+    let inConflict = false;
+    let inOurs = false;
+    for (const line of lines) {
+      if (line.startsWith("<<<<<<< ")) {
+        inConflict = true;
+        inOurs = true;
+        continue;
+      }
+      if (inConflict && line === "=======") {
+        inOurs = false;
+        continue;
+      }
+      if (inConflict && line.startsWith(">>>>>>> ")) {
+        inConflict = false;
+        inOurs = false;
+        continue;
+      }
+      if (!inConflict || inOurs) {
+        result.push(line);
+      }
+    }
+    return result.join("\n");
+  }
+  /**
+   * After applyPatches(), strip conflict markers from conflicting files
+   * so only clean content is committed. Keeps the Generated (OURS) side.
+   */
+  revertConflictingFiles(results) {
+    for (const result of results) {
+      if (result.status !== "conflict" || !result.fileResults) continue;
+      for (const fileResult of result.fileResults) {
+        if (fileResult.status !== "conflict") continue;
+        const filePath = join3(this.outputDir, fileResult.file);
+        try {
+          const content = readFileSync2(filePath, "utf-8");
+          const stripped = this.stripConflictMarkers(content);
+          writeFileSync2(filePath, stripped);
+        } catch {
+        }
+      }
+    }
+  }
   readFernignorePatterns() {
     const fernignorePath = join3(this.outputDir, ".fernignore");
     if (!existsSync2(fernignorePath)) return [];
@@ -1449,6 +1552,12 @@ var ReplayService = class {
       patchesRefreshed: preRebaseCounts && preRebaseCounts.contentRefreshed > 0 ? preRebaseCounts.contentRefreshed : void 0,
       conflicts: conflictResults.flatMap((r) => r.fileResults?.filter((f) => f.status === "conflict") ?? []),
       conflictDetails: conflictDetails.length > 0 ? conflictDetails : void 0,
+      unresolvedPatches: conflictResults.length > 0 ? conflictResults.map((r) => ({
+        patchId: r.patch.id,
+        patchMessage: r.patch.original_message,
+        files: r.patch.files,
+        conflictDetails: r.fileResults?.filter((f) => f.status === "conflict") ?? []
+      })) : void 0,
       wouldApply: options?.dryRun ? patches : void 0,
       warnings: warnings && warnings.length > 0 ? warnings : void 0
     };
@@ -1457,7 +1566,7 @@ var ReplayService = class {
 
 // src/FernignoreMigrator.ts
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname3, join as join4 } from "path";
 import { minimatch as minimatch3 } from "minimatch";
 import { parse as parse2, stringify as stringify2 } from "yaml";
@@ -1645,13 +1754,13 @@ var FernignoreMigrator = class {
     if (!existsSync3(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
-    writeFileSync2(replayYmlPath, stringify2(config, { lineWidth: 0 }), "utf-8");
+    writeFileSync3(replayYmlPath, stringify2(config, { lineWidth: 0 }), "utf-8");
   }
 };
 
 // src/commands/bootstrap.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { join as join5 } from "path";
 init_GitClient();
 async function bootstrap(outputDir, options) {
@@ -1837,7 +1946,7 @@ function ensureFernignoreEntries(outputDir) {
     content += "\n";
   }
   content += toAdd.join("\n") + "\n";
-  writeFileSync3(fernignorePath, content, "utf-8");
+  writeFileSync4(fernignorePath, content, "utf-8");
   return true;
 }
 function computeContentHash(patchContent) {
@@ -1910,17 +2019,82 @@ async function resolve(outputDir, options) {
     return { success: false, reason: "no-patches" };
   }
   const git = new GitClient(outputDir);
+  const unresolvedPatches = lockManager.getUnresolvedPatches();
+  const resolvingPatches = lockManager.getResolvingPatches();
+  if (unresolvedPatches.length > 0) {
+    const applicator = new ReplayApplicator(git, lockManager, outputDir);
+    await applicator.applyPatches(unresolvedPatches);
+    const markerFiles = await findConflictMarkerFiles(git);
+    if (markerFiles.length > 0) {
+      for (const patch of unresolvedPatches) {
+        lockManager.updatePatch(patch.id, { status: "resolving" });
+      }
+      lockManager.save();
+      return {
+        success: false,
+        reason: "conflicts-applied",
+        unresolvedFiles: markerFiles,
+        phase: "applied",
+        patchesApplied: unresolvedPatches.length
+      };
+    }
+  }
   if (options?.checkMarkers !== false) {
-    const markerFiles = await git.exec(["grep", "-l", "<<<<<<<", "--", "."]).catch(() => "");
-    if (markerFiles.trim()) {
-      const files = markerFiles.trim().split("\n").filter(Boolean);
-      return { success: false, reason: "unresolved-conflicts", unresolvedFiles: files };
+    const currentMarkerFiles = await findConflictMarkerFiles(git);
+    if (currentMarkerFiles.length > 0) {
+      return { success: false, reason: "unresolved-conflicts", unresolvedFiles: currentMarkerFiles };
+    }
+  }
+  const patchesToCommit = [...resolvingPatches, ...unresolvedPatches];
+  if (patchesToCommit.length > 0) {
+    const currentGen = lock.current_generation;
+    const detector = new ReplayDetector(git, lockManager, outputDir);
+    let patchesResolved = 0;
+    for (const patch of patchesToCommit) {
+      const diff = await git.exec(["diff", currentGen, "--", ...patch.files]).catch(() => null);
+      if (!diff || !diff.trim()) {
+        lockManager.removePatch(patch.id);
+        continue;
+      }
+      const newContentHash = detector.computeContentHash(diff);
+      const changedFiles = await getChangedFiles(git, currentGen, patch.files);
+      lockManager.markPatchResolved(patch.id, {
+        patch_content: diff,
+        content_hash: newContentHash,
+        base_generation: currentGen,
+        files: changedFiles
+      });
+      patchesResolved++;
     }
+    lockManager.save();
+    const committer2 = new ReplayCommitter(git, outputDir);
+    await committer2.stageAll();
+    const commitSha2 = await committer2.commitReplay(
+      lock.patches.length,
+      lock.patches,
+      "[fern-replay] Resolved conflicts"
+    );
+    return {
+      success: true,
+      commitSha: commitSha2,
+      phase: "committed",
+      patchesResolved
+    };
   }
   const committer = new ReplayCommitter(git, outputDir);
   await committer.stageAll();
   const commitSha = await committer.commitReplay(lock.patches.length, lock.patches);
-  return { success: true, commitSha };
+  return { success: true, commitSha, phase: "committed" };
+}
+async function findConflictMarkerFiles(git) {
+  const output = await git.exec(["grep", "-l", "<<<<<<<", "--", "."]).catch(() => "");
+  return output.trim() ? output.trim().split("\n").filter(Boolean) : [];
+}
+async function getChangedFiles(git, currentGen, files) {
+  const filesOutput = await git.exec(["diff", "--name-only", currentGen, "--", ...files]).catch(() => null);
+  if (!filesOutput || !filesOutput.trim()) return files;
+  const changed = filesOutput.trim().split("\n").filter(Boolean).filter((f) => !f.startsWith(".fern/"));
+  return changed.length > 0 ? changed : files;
 }
 
 // src/commands/status.ts