@cvr/stacked 0.4.4 → 0.6.0

package/src/commands/submit.ts

@@ -90,6 +90,17 @@ export const submit = Command.make("submit", {
       const trunk = yield* stacks.getTrunk();
       const currentBranch = yield* git.currentBranch();
       const { branches } = result.stack;
+      const data = yield* stacks.load();
+      const mergedSet = new Set(data.mergedBranches);
+
+      // Compute the effective base for a branch at index i, skipping merged branches
+      const effectiveBase = (i: number): string => {
+        for (let j = i - 1; j >= 0; j--) {
+          const candidate = branches[j];
+          if (candidate !== undefined && !mergedSet.has(candidate)) return candidate;
+        }
+        return trunk;
+      };
 
       const rawTitle = Option.isSome(titleOpt) ? titleOpt.value : undefined;
       const rawBody = Option.isSome(bodyOpt) ? bodyOpt.value : undefined;
@@ -106,11 +117,13 @@ export const submit = Command.make("submit", {
 
       if (titles !== undefined && titles.length !== branches.length) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: `--title has ${titles.length} values but stack has ${branches.length} branches`,
         });
       }
       if (bodies !== undefined && bodies.length !== branches.length) {
         return yield* new StackError({
+          code: ErrorCode.USAGE_ERROR,
           message: `--body has ${bodies.length} values but stack has ${branches.length} branches`,
         });
       }
@@ -132,19 +145,34 @@ export const submit = Command.make("submit", {
       const results: SubmitResult[] = [];
       const prMap = new Map<
         string,
-        { number: number; url: string; state: string; body?: string | null } | null
+        { number: number; url: string; state: string; base: string; body?: string | null } | null
       >();
 
+      // Pre-fetch all PR statuses in parallel
+      const activeBranches = only ? branches.filter((b) => b === currentBranch) : [...branches];
+      const prResults = yield* Effect.forEach(
+        activeBranches,
+        (branch) =>
+          gh.getPR(branch).pipe(
+            Effect.map((pr) => [branch, pr] as const),
+            Effect.catchTag("GitHubError", () => Effect.succeed([branch, null] as const)),
+          ),
+        { concurrency: 5 },
+      );
+      for (const [branch, pr] of prResults) {
+        prMap.set(branch, pr);
+      }
+
       for (let i = 0; i < branches.length; i++) {
         const branch = branches[i];
         if (branch === undefined) continue;
-        const base = i === 0 ? trunk : (branches[i - 1] ?? trunk);
+        const base = effectiveBase(i);
 
         // --only: skip branches that aren't current
         if (only && branch !== currentBranch) continue;
 
         if (dryRun) {
-          const existingPR = yield* gh.getPR(branch);
+          const existingPR = prMap.get(branch) ?? null;
           const action =
             existingPR === null
               ? "would-create"
@@ -166,8 +194,7 @@ export const submit = Command.make("submit", {
 
         yield* withSpinner(`Pushing ${branch}`, git.push(branch, { force: !noForce }));
 
-        const existingPR = yield* gh.getPR(branch);
-        prMap.set(branch, existingPR);
+        const existingPR = prMap.get(branch) ?? null;
 
         if (existingPR !== null) {
           if (existingPR.base !== base) {
@@ -205,7 +232,7 @@ export const submit = Command.make("submit", {
             body,
             draft,
           });
-          prMap.set(branch, { number: pr.number, url: pr.url, state: "OPEN" });
+          prMap.set(branch, { number: pr.number, url: pr.url, state: "OPEN", base });
           yield* success(`Created PR #${pr.number}: ${pr.url}`);
           results.push({
             branch,

package/src/commands/sync.ts

@@ -21,10 +21,13 @@ const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Output as JSON"
 const dryRunFlag = Flag.boolean("dry-run").pipe(
   Flag.withDescription("Show rebase plan without executing"),
 );
+const rebaseOnlyFlag = Flag.boolean("rebase-only").pipe(
+  Flag.withDescription("Force rebase path (skip tree-merge)"),
+);
 
 interface SyncResult {
   name: string;
-  action: "rebased" | "skipped" | "up-to-date";
+  action: "rebased" | "merged" | "skipped" | "up-to-date";
   base: string;
 }
 
@@ -33,6 +36,7 @@ export const sync = Command.make("sync", {
   from: fromFlag,
   json: jsonFlag,
   dryRun: dryRunFlag,
+  rebaseOnly: rebaseOnlyFlag,
 }).pipe(
   Command.withDescription(
     "Fetch, rebase, and force-push stack branches. Use --from to start from a branch.",
@@ -41,8 +45,9 @@ export const sync = Command.make("sync", {
     { command: "stacked sync", description: "Sync local trunk, then rebase entire stack on trunk" },
     { command: "stacked sync --from feat-auth", description: "Resume from a specific branch" },
     { command: "stacked sync --dry-run", description: "Preview rebase plan" },
+    { command: "stacked sync --rebase-only", description: "Force rebase (skip tree-merge)" },
   ]),
-  Command.withHandler(({ trunk: trunkOpt, from: fromOpt, json, dryRun }) =>
+  Command.withHandler(({ trunk: trunkOpt, from: fromOpt, json, dryRun, rebaseOnly }) =>
     Effect.gen(function* () {
       const git = yield* GitService;
       const gh = yield* GitHubService;
@@ -72,6 +77,18 @@ export const sync = Command.make("sync", {
       }
 
       const { branches } = result.stack;
+      const data = yield* stacks.load();
+      const mergedSet = new Set(data.mergedBranches);
+
+      // Compute the effective base for a branch at index i, skipping merged branches
+      const effectiveBase = (i: number, fallback: string): string => {
+        for (let j = i - 1; j >= 0; j--) {
+          const candidate = branches[j];
+          if (candidate !== undefined && !mergedSet.has(candidate)) return candidate;
+        }
+        return fallback;
+      };
+
       const fromBranch = Option.isSome(fromOpt) ? fromOpt.value : undefined;
 
       let startIdx = 0;
@@ -93,18 +110,43 @@ export const sync = Command.make("sync", {
       const results: SyncResult[] = [];
 
       if (dryRun) {
-        results.push({ name: trunk, action: "skipped", base: originTrunk });
+        results.push({ name: trunk, action: "rebased", base: originTrunk });
         if (!json) {
-          yield* Console.error(`Would fetch and rebase ${trunk} onto ${originTrunk}`);
+          yield* Console.error(`${trunk}: rebase onto ${originTrunk}`);
         }
 
         for (let i = startIdx; i < branches.length; i++) {
           const branch = branches[i];
           if (branch === undefined) continue;
-          const base = i === 0 ? originTrunk : (branches[i - 1] ?? originTrunk);
-          results.push({ name: branch, action: "skipped", base });
+          const base = effectiveBase(i, originTrunk);
+
+          const newBaseTip = yield* git.revParse(base);
+          const branchHead = yield* git.revParse(branch);
+          const syncedOnto = yield* stacks.getSyncedOnto(branch);
+
+          let action: SyncResult["action"];
+          if (syncedOnto !== null && syncedOnto === newBaseTip) {
+            action = "up-to-date";
+          } else {
+            const alreadyIncorporated = yield* git
+              .isAncestor(newBaseTip, branchHead)
+              .pipe(Effect.catchTag("GitError", () => Effect.succeed(false)));
+            if (alreadyIncorporated) {
+              action = "up-to-date";
+            } else {
+              action = !rebaseOnly && git.supportsTreeMerge() ? "merged" : "rebased";
+            }
+          }
+
+          results.push({ name: branch, action, base });
           if (!json) {
-            yield* Console.error(`Would rebase and force-push ${branch} onto ${base}`);
+            const verb =
+              action === "up-to-date"
+                ? "up-to-date"
+                : action === "merged"
+                  ? `tree-merge onto ${base}`
+                  : `rebase onto ${base}`;
+            yield* Console.error(`${branch}: ${verb}`);
           }
         }
 
@@ -112,9 +154,12 @@ export const sync = Command.make("sync", {
           // @effect-diagnostics-next-line effect/preferSchemaOverJson:off
           yield* Console.log(JSON.stringify({ branches: results }, null, 2));
         } else {
-          yield* Console.error(
-            `\n${results.length} branch${results.length === 1 ? "" : "es"} would be rebased`,
-          );
+          const changed = results.filter((r) => r.action !== "up-to-date").length;
+          const skipped = results.filter((r) => r.action === "up-to-date").length;
+          const parts: string[] = [];
+          if (changed > 0) parts.push(`${changed} to sync`);
+          if (skipped > 0) parts.push(`${skipped} up-to-date`);
+          yield* Console.error(`\n${parts.join(", ")}`);
         }
         return;
       }
@@ -137,31 +182,81 @@ export const sync = Command.make("sync", {
         for (let i = startIdx; i < branches.length; i++) {
           const branch = branches[i];
           if (branch === undefined) continue;
-          const newBase = i === 0 ? originTrunk : (branches[i - 1] ?? originTrunk);
-
-          // Compute old base (merge-base of this branch and its parent) before rebasing
-          const oldBase = yield* git
-            .mergeBase(branch, newBase)
-            .pipe(Effect.catchTag("GitError", () => Effect.succeed(newBase)));
-
-          yield* git.checkout(branch);
-          yield* withSpinner(
-            `Rebasing ${branch} onto ${newBase}`,
-            git.rebaseOnto(branch, newBase, oldBase),
-          ).pipe(
-            Effect.catchTag("GitError", (e) => {
-              const hint =
-                i === 0 ? "stacked sync" : `stacked sync --from ${branches[i - 1] ?? trunk}`;
-              return Effect.fail(
-                new StackError({
-                  code: ErrorCode.REBASE_CONFLICT,
-                  message: `Rebase conflict on ${branch}: ${e.message}\n\nResolve conflicts, then run:\n  git rebase --continue\n  ${hint}`,
-                }),
-              );
-            }),
-          );
-          yield* withSpinner(`Pushing ${branch}`, git.push(branch, { force: true }));
-          results.push({ name: branch, action: "rebased", base: newBase });
+          const newBase = effectiveBase(i, originTrunk);
+
+          const newBaseTip = yield* git.revParse(newBase);
+          const branchHead = yield* git.revParse(branch);
+          const syncedOnto = yield* stacks.getSyncedOnto(branch);
+
+          // Skip if parent hasn't moved since last sync
+          if (syncedOnto !== null && syncedOnto === newBaseTip) {
+            results.push({ name: branch, action: "up-to-date", base: newBase });
+            continue;
+          }
+
+          // Skip if parent is already an ancestor of branch (manually synced)
+          const alreadyIncorporated = yield* git
+            .isAncestor(newBaseTip, branchHead)
+            .pipe(Effect.catchTag("GitError", () => Effect.succeed(false)));
+          if (alreadyIncorporated) {
+            yield* stacks.updateSyncedOnto(branch, newBaseTip);
+            results.push({ name: branch, action: "up-to-date", base: newBase });
+            continue;
+          }
+
+          // Resolve old base: prefer recorded fork-point, fall back to merge-base
+          const oldBase =
+            syncedOnto ??
+            (yield* git
+              .mergeBase(branch, newBase)
+              .pipe(Effect.catchTag("GitError", () => Effect.succeed(newBase))));
+
+          // Try tree-merge fast path first (unless --rebase-only)
+          const mergeResult = rebaseOnly
+            ? ({ action: "conflict" } as const)
+            : yield* git
+                .treeMergeSync({
+                  branch,
+                  branchHead,
+                  oldBase,
+                  newBase: newBaseTip,
+                  message: `sync: incorporate changes from ${newBase}`,
+                })
+                .pipe(
+                  Effect.catchTag("GitError", () =>
+                    Effect.succeed({ action: "conflict" as const }),
+                  ),
+                );
+
+          if (mergeResult.action === "merged") {
+            yield* stacks.updateSyncedOnto(branch, newBaseTip);
+            yield* withSpinner(`Pushing ${branch}`, git.push(branch, { force: true }));
+            results.push({ name: branch, action: "merged", base: newBase });
+          } else if (mergeResult.action === "up-to-date") {
+            yield* stacks.updateSyncedOnto(branch, newBaseTip);
+            results.push({ name: branch, action: "up-to-date", base: newBase });
+          } else {
+            // Conflict or unsupported backend — fall back to rebase with corrected oldBase
+            yield* git.checkout(branch);
+            yield* withSpinner(
+              `Rebasing ${branch} onto ${newBase}`,
+              git.rebaseOnto(branch, newBase, oldBase),
+            ).pipe(
+              Effect.catchTag("GitError", (e) => {
+                const hint =
+                  i === 0 ? "stacked sync" : `stacked sync --from ${branches[i - 1] ?? trunk}`;
+                return Effect.fail(
+                  new StackError({
+                    code: ErrorCode.REBASE_CONFLICT,
+                    message: `Rebase conflict on ${branch}: ${e.message}\n\nResolve conflicts, then run:\n  git rebase --continue\n  ${hint}`,
+                  }),
+                );
+              }),
+            );
+            yield* stacks.updateSyncedOnto(branch, newBaseTip);
+            yield* withSpinner(`Pushing ${branch}`, git.push(branch, { force: true }));
+            results.push({ name: branch, action: "rebased", base: newBase });
+          }
         }
       }).pipe(
         Effect.ensuring(

package/src/errors/index.ts

@@ -19,6 +19,8 @@ export const ErrorCode = {
   STACK_EMPTY: "STACK_EMPTY",
   TRUNK_ERROR: "TRUNK_ERROR",
   STACK_EXISTS: "STACK_EXISTS",
+  USAGE_ERROR: "USAGE_ERROR",
+  HAS_CHILDREN: "HAS_CHILDREN",
 } as const;
 
 export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];

package/src/main.ts

@@ -15,11 +15,11 @@ const version = typeof __VERSION__ !== "undefined" ? __VERSION__ : "dev";
 // Global Flags (parsed before CLI framework, stripped from argv)
 // ============================================================================
 
-const globalFlags = new Set(["--verbose", "--quiet", "-q", "--no-color", "--yes", "-y"]);
+const globalFlags = new Set(["--verbose", "-v", "--quiet", "-q", "--no-color", "--yes", "-y"]);
 const flagArgs = new Set(process.argv.filter((a) => globalFlags.has(a)));
 process.argv = process.argv.filter((a) => !globalFlags.has(a));
 
-const isVerbose = flagArgs.has("--verbose");
+const isVerbose = flagArgs.has("--verbose") || flagArgs.has("-v");
 const isQuiet = flagArgs.has("--quiet") || flagArgs.has("-q");
 const isNoColor = flagArgs.has("--no-color");
 const isYes = flagArgs.has("--yes") || flagArgs.has("-y");
@@ -53,16 +53,26 @@ const usageCodes = new Set([
   "ALREADY_AT_BOTTOM",
   "TRUNK_ERROR",
   "STACK_EXISTS",
+  "USAGE_ERROR",
+  "HAS_CHILDREN",
 ]);
 
-const handleKnownError = (e: { message: string; code?: string | undefined }) =>
-  Console.error(e.code !== undefined ? `Error [${e.code}]: ${e.message}` : e.message).pipe(
+const isJson = process.argv.includes("--json");
+
+const handleKnownError = (e: { message: string; code?: string | undefined }) => {
+  const exitCode = e.code !== undefined && usageCodes.has(e.code) ? 2 : 1;
+  const errorOutput = isJson
+    ? Console.log(JSON.stringify({ error: { code: e.code ?? null, message: e.message } }))
+    : Console.error(e.code !== undefined ? `Error [${e.code}]: ${e.message}` : e.message);
+
+  return errorOutput.pipe(
     Effect.andThen(
       Effect.sync(() => {
-        process.exitCode = e.code !== undefined && usageCodes.has(e.code) ? 2 : 1;
+        process.exitCode = exitCode;
       }),
     ),
   );
+};
 
 // @effect-diagnostics-next-line effect/strictEffectProvide:off
 BunRuntime.runMain(

package/src/services/Git.ts

@@ -37,6 +37,14 @@ export class GitService extends ServiceMap.Service<
     readonly commitAmend: (options?: { edit?: boolean }) => Effect.Effect<void, GitError>;
     readonly fetch: (remote?: string) => Effect.Effect<void, GitError>;
     readonly deleteRemoteBranch: (branch: string) => Effect.Effect<void, GitError>;
+    readonly treeMergeSync: (opts: {
+      branch: string;
+      branchHead: string;
+      oldBase: string;
+      newBase: string;
+      message: string;
+    }) => Effect.Effect<{ action: "merged" | "up-to-date" | "conflict" }, GitError>;
+    readonly supportsTreeMerge: () => boolean;
   }
 >()("@cvr/stacked/services/Git/GitService") {
   static layer: Layer.Layer<GitService> = Layer.sync(GitService, () => {
@@ -121,7 +129,10 @@ export class GitService extends ServiceMap.Service<
 
       remoteDefaultBranch: (remote = "origin") =>
         run(["symbolic-ref", "--quiet", "--short", `refs/remotes/${remote}/HEAD`]).pipe(
-          Effect.map((ref) => Option.some(ref.replace(new RegExp(`^${remote}/`), ""))),
+          Effect.map((ref) => {
+            const prefix = `${remote}/`;
+            return Option.some(ref.startsWith(prefix) ? ref.slice(prefix.length) : ref);
+          }),
           Effect.catchTag("GitError", () => Effect.succeed(Option.none())),
         ),
 
@@ -192,15 +203,37 @@ export class GitService extends ServiceMap.Service<
         ),
 
       commitAmend: (options) => {
-        const args = ["commit", "--amend"];
-        if (options?.edit !== true) args.push("--no-edit");
-        return run(args).pipe(Effect.asVoid);
+        if (options?.edit === true) {
+          // Interactive editor needs inherited stdio, not piped
+          return Effect.tryPromise({
+            try: async () => {
+              const proc = Bun.spawn(["git", "commit", "--amend"], {
+                stdin: "inherit",
+                stdout: "inherit",
+                stderr: "inherit",
+              });
+              const exitCode = await proc.exited;
+              if (exitCode !== 0) {
+                throw new Error(`git commit --amend failed with exit code ${exitCode}`);
+              }
+            },
+            catch: (e) =>
+              new GitError({
+                message: `Process failed: ${e}`,
+                command: "git commit --amend",
+              }),
+          }).pipe(Effect.asVoid);
+        }
+        return run(["commit", "--amend", "--no-edit"]).pipe(Effect.asVoid);
       },
 
       fetch: (remote) => run(["fetch", remote ?? "origin"]).pipe(Effect.asVoid),
 
       deleteRemoteBranch: (branch) =>
         run(["push", "origin", "--delete", branch]).pipe(Effect.asVoid),
+
+      treeMergeSync: () => Effect.succeed({ action: "conflict" as const }),
+      supportsTreeMerge: () => false,
     };
   });
 
@@ -227,6 +260,8 @@ export class GitService extends ServiceMap.Service<
       commitAmend: () => Effect.void,
       fetch: () => Effect.void,
       deleteRemoteBranch: () => Effect.void,
+      treeMergeSync: () => Effect.succeed({ action: "conflict" as const }),
+      supportsTreeMerge: () => false,
       ...impl,
     });
 }

package/src/services/GitEs.ts

@@ -111,7 +111,8 @@ export const GitEsLayer = Layer.effect(
             const ref = repo.findReference(`refs/remotes/${remote}/HEAD`);
             if (ref === null) return Option.none();
             const target = ref.resolve().shorthand();
-            return Option.some(target.replace(new RegExp(`^${remote}/`), ""));
+            const prefix = `${remote}/`;
+            return Option.some(target.startsWith(prefix) ? target.slice(prefix.length) : target);
           },
           catch: (error) => makeGitError(`es-git.remoteDefaultBranch ${remote}`, error),
         }).pipe(Effect.catchTag("GitError", () => Effect.succeed(Option.none()))),
@@ -127,13 +128,32 @@ export const GitEsLayer = Layer.effect(
           catch: (error) => makeGitError(`es-git.createBranch ${name}`, error),
         }).pipe(Effect.asVoid),
 
-      deleteBranch: (name) =>
-        Effect.try({
+      deleteBranch: (name, force) => {
+        // When force is false/undefined, shell out to `git branch -d` so git
+        // enforces "must be fully merged" check. es-git has no equivalent.
+        if (force !== true) {
+          return Effect.tryPromise({
+            try: async () => {
+              const proc = Bun.spawn(["git", "branch", "-d", "--", name], {
+                stdout: "pipe",
+                stderr: "pipe",
+              });
+              const exitCode = await proc.exited;
+              if (exitCode !== 0) {
+                const stderr = await new Response(proc.stderr).text();
+                throw new Error(stderr.trim() || `git branch -d failed with exit code ${exitCode}`);
+              }
+            },
+            catch: (error) => makeGitError(`es-git.deleteBranch ${name}`, error),
+          }).pipe(Effect.asVoid);
+        }
+        return Effect.try({
           try: () => {
             repo.getBranch(name, "Local").delete();
           },
           catch: (error) => makeGitError(`es-git.deleteBranch ${name}`, error),
-        }).pipe(Effect.asVoid),
+        }).pipe(Effect.asVoid);
+      },
 
       checkout: (name) =>
         Effect.try({
@@ -177,17 +197,34 @@ export const GitEsLayer = Layer.effect(
           catch: (error) => makeGitError("es-git.rebaseAbort", error),
         }).pipe(Effect.asVoid),
 
-      push: (branch, options) =>
-        Effect.tryPromise({
+      push: (branch, options) => {
+        // es-git's protocol has no --force-with-lease equivalent; shell out to git CLI
+        if (options?.force === true) {
+          return Effect.tryPromise({
+            try: async () => {
+              const proc = Bun.spawn(
+                ["git", "push", "--force-with-lease", "-u", "origin", branch],
+                { stdout: "pipe", stderr: "pipe" },
+              );
+              const exitCode = await proc.exited;
+              if (exitCode !== 0) {
+                const stderr = await new Response(proc.stderr).text();
+                throw new Error(stderr.trim() || `git push failed with exit code ${exitCode}`);
+              }
+            },
+            catch: (error) => makeGitError(`es-git.push ${branch}`, error),
+          }).pipe(Effect.asVoid);
+        }
+        return Effect.tryPromise({
           try: async () => {
             const remote = repo.getRemote("origin");
-            const forcePrefix = options?.force === true ? "+" : "";
-            await remote.push([`${forcePrefix}refs/heads/${branch}:refs/heads/${branch}`]);
+            await remote.push([`refs/heads/${branch}:refs/heads/${branch}`]);
             const localBranch = repo.findBranch(branch, "Local");
             localBranch?.setUpstream(`origin/${branch}`);
           },
           catch: (error) => makeGitError(`es-git.push ${branch}`, error),
-        }).pipe(Effect.asVoid),
+        }).pipe(Effect.asVoid);
+      },
 
       log: (branch, options) =>
         Effect.try({
@@ -274,8 +311,25 @@ export const GitEsLayer = Layer.effect(
           catch: (error) => makeGitError("es-git.isRebaseInProgress", error),
         }).pipe(Effect.catchTag("GitError", () => Effect.succeed(false))),
 
-      commitAmend: () =>
-        Effect.try({
+      commitAmend: (options) => {
+        // --edit requires an interactive editor; shell out to git CLI
+        if (options?.edit === true) {
+          return Effect.tryPromise({
+            try: async () => {
+              const proc = Bun.spawn(["git", "commit", "--amend"], {
+                stdin: "inherit",
+                stdout: "inherit",
+                stderr: "inherit",
+              });
+              const exitCode = await proc.exited;
+              if (exitCode !== 0) {
+                throw new Error(`git commit --amend failed with exit code ${exitCode}`);
+              }
+            },
+            catch: (error) => makeGitError("es-git.commitAmend", error),
+          }).pipe(Effect.asVoid);
+        }
+        return Effect.try({
           try: () => {
             const headOid = repo.head().target();
             if (headOid === null) {
@@ -287,7 +341,8 @@ export const GitEsLayer = Layer.effect(
             });
           },
           catch: (error) => makeGitError("es-git.commitAmend", error),
-        }).pipe(Effect.asVoid),
+        }).pipe(Effect.asVoid);
+      },
 
       fetch: (remote = "origin") =>
         Effect.tryPromise({
@@ -304,6 +359,43 @@ export const GitEsLayer = Layer.effect(
           },
           catch: (error) => makeGitError(`es-git.deleteRemoteBranch ${branch}`, error),
         }).pipe(Effect.asVoid),
+
+      treeMergeSync: ({ branch, oldBase, newBase }) =>
+        Effect.try({
+          try: () => {
+            const oldBaseOid = resolveOid(repo, oldBase);
+            const newBaseOid = resolveOid(repo, newBase);
+            const branchRef = refName(branch);
+
+            // Pre-flight: check for conflicts via mergeTrees
+            const oldBaseTree = repo.getCommit(oldBaseOid).tree();
+            const newBaseTree = repo.getCommit(newBaseOid).tree();
+            const branchHeadOid = repo.getReference(branchRef).resolve().target();
+            if (branchHeadOid === null) {
+              return { action: "conflict" as const };
+            }
+            const branchTree = repo.getCommit(branchHeadOid).tree();
+
+            const index = repo.mergeTrees(oldBaseTree, newBaseTree, branchTree);
+            if (index.hasConflicts()) {
+              return { action: "conflict" as const };
+            }
+
+            // Check if anything actually changed
+            if (newBaseOid === oldBaseOid) {
+              return { action: "up-to-date" as const };
+            }
+
+            // Clean merge — execute via rebase (which handles tree writing properly)
+            performRebase(repo, branchRef, oldBaseOid, newBaseOid);
+
+            return { action: "merged" as const };
+          },
+          catch: (error) =>
+            makeGitError(`es-git.treeMergeSync ${branch} ${oldBase} ${newBase}`, error),
+        }),
+
+      supportsTreeMerge: () => true,
     };
   }),
 );