feat(rebase): reset fully-merged branches to base instead of skipping

When a branch is fully merged (rebase-merged or squash-merged) into
main with no new local work, rebase now resets the branch to origin/main
instead of skipping with "already merged." Merge mode fast-forwards.

https://claude.ai/code/session_01JwYwdYdscozHuZVPdrM9pq

Author: claude

src/lib/render/integrate-cells.ts

@@ -23,10 +23,18 @@ export function integrateActionCell(desc: IntegrateActionDesc): Cell {
   if (desc.kind === "retarget-merged") {
     const n = desc.replayCount ?? 0;
     const merged = desc.skipCount ?? 0;
-    const commitWord = n === 1 ? "commit" : "commits";
-    let text = `rebase onto ${desc.baseRef} (merged) \u2014 rebase ${n} new ${commitWord}`;
-    if (merged > 0) text += `, skip ${merged} already merged`;
-    result = cell(text);
+    if (n === 0) {
+      const text =
+        merged > 0
+          ? `reset to ${desc.baseRef} (all ${merged} commits merged)`
+          : `reset to ${desc.baseRef} (merged)`;
+      result = cell(text);
+    } else {
+      const commitWord = n === 1 ? "commit" : "commits";
+      let text = `rebase onto ${desc.baseRef} (merged) \u2014 rebase ${n} new ${commitWord}`;
+      if (merged > 0) text += `, skip ${merged} already merged`;
+      result = cell(text);
+    }
   } else if (desc.kind === "retarget-config") {
     let text = `rebase onto ${desc.baseRef} from ${desc.retargetFrom} (retarget)`;
     if (desc.skipCount != null && desc.skipCount > 0) {

src/lib/sync/classify-integrate.test.ts

@@ -548,4 +548,140 @@ describe("assessIntegrateRepo", () => {
     expect(a.retarget?.alreadyOnTarget).toBe(3);
     expect(a.retarget?.reason).toBe("branch-merged");
   });
+
+  // ── fully-merged (no new work) ──
+
+  test("fully-merged in rebase mode with behind > 0 returns will-operate with retarget (replayCount=0)", async () => {
+    const status = makeRepo({
+      base: {
+        remote: "origin",
+        ref: "main",
+        configuredRef: null,
+        resolvedVia: "remote",
+        ahead: 5,
+        behind: 3,
+        merge: { kind: "merge" },
+        baseMergedIntoDefault: null,
+      },
+    });
+    const a = await assessIntegrateRepo(status, DIR, "feature", [], defaultOptions({ mode: "rebase" }), mockDeps());
+    expect(a.outcome).toBe("will-operate");
+    expect(a.retarget?.replayCount).toBe(0);
+    expect(a.retarget?.alreadyOnTarget).toBe(5);
+    expect(a.retarget?.reason).toBe("branch-merged");
+    expect(a.behind).toBe(3);
+    expect(a.ahead).toBe(0);
+  });
+
+  test("fully-merged squash in rebase mode with behind > 0 returns will-operate with retarget", async () => {
+    const status = makeRepo({
+      base: {
+        remote: "origin",
+        ref: "main",
+        configuredRef: null,
+        resolvedVia: "remote",
+        ahead: 3,
+        behind: 2,
+        merge: { kind: "squash" },
+        baseMergedIntoDefault: null,
+      },
+    });
+    const a = await assessIntegrateRepo(status, DIR, "feature", [], defaultOptions({ mode: "rebase" }), mockDeps());
+    expect(a.outcome).toBe("will-operate");
+    expect(a.retarget?.replayCount).toBe(0);
+    expect(a.retarget?.alreadyOnTarget).toBe(3);
+    expect(a.retarget?.reason).toBe("branch-merged");
+  });
+
+  test("fully-merged in merge mode with behind > 0 returns will-operate (standard merge)", async () => {
+    const status = makeRepo({
+      base: {
+        remote: "origin",
+        ref: "main",
+        configuredRef: null,
+        resolvedVia: "remote",
+        ahead: 5,
+        behind: 3,
+        merge: { kind: "merge" },
+        baseMergedIntoDefault: null,
+      },
+    });
+    const a = await assessIntegrateRepo(status, DIR, "feature", [], defaultOptions({ mode: "merge" }), mockDeps());
+    expect(a.outcome).toBe("will-operate");
+    expect(a.behind).toBe(3);
+    expect(a.ahead).toBe(5);
+    expect(a.retarget).toBeUndefined();
+  });
+
+  test("fully-merged with behind=0 and ahead=0 returns up-to-date", async () => {
+    const status = makeRepo({
+      base: {
+        remote: "origin",
+        ref: "main",
+        configuredRef: null,
+        resolvedVia: "remote",
+        ahead: 0,
+        behind: 0,
+        merge: { kind: "merge" },
+        baseMergedIntoDefault: null,
+      },
+    });
+    const a = await assessIntegrateRepo(status, DIR, "feature", [], defaultOptions({ mode: "rebase" }), mockDeps());
+    expect(a.outcome).toBe("up-to-date");
+  });
+
+  test("fully-merged in merge mode with behind=0 returns up-to-date", async () => {
+    const status = makeRepo({
+      base: {
+        remote: "origin",
+        ref: "main",
+        configuredRef: null,
+        resolvedVia: "remote",
+        ahead: 3,
+        behind: 0,
+        merge: { kind: "squash" },
+        baseMergedIntoDefault: null,
+      },
+    });
+    const a = await assessIntegrateRepo(status, DIR, "feature", [], defaultOptions({ mode: "merge" }), mockDeps());
+    expect(a.outcome).toBe("up-to-date");
+  });
+
+  test("fully-merged with dirty worktree and no autostash returns skip (dirty)", async () => {
+    const status = makeRepo({
+      base: {
+        remote: "origin",
+        ref: "main",
+        configuredRef: null,
+        resolvedVia: "remote",
+        ahead: 3,
+        behind: 2,
+        merge: { kind: "merge" },
+        baseMergedIntoDefault: null,
+      },
+      local: { staged: 1, modified: 0, untracked: 0, conflicts: 0 },
+    });
+    const a = await assessIntegrateRepo(status, DIR, "feature", [], defaultOptions({ autostash: false }), mockDeps());
+    expect(a.outcome).toBe("skip");
+    expect(a.skipFlag).toBe("dirty");
+  });
+
+  test("fully-merged with dirty worktree and autostash returns will-operate with needsStash", async () => {
+    const status = makeRepo({
+      base: {
+        remote: "origin",
+        ref: "main",
+        configuredRef: null,
+        resolvedVia: "remote",
+        ahead: 3,
+        behind: 2,
+        merge: { kind: "merge" },
+        baseMergedIntoDefault: null,
+      },
+      local: { staged: 1, modified: 0, untracked: 0, conflicts: 0 },
+    });
+    const a = await assessIntegrateRepo(status, DIR, "feature", [], defaultOptions({ autostash: true }), mockDeps());
+    expect(a.outcome).toBe("will-operate");
+    expect(a.needsStash).toBe(true);
+  });
 });

src/lib/sync/classify-integrate.ts

@@ -164,8 +164,9 @@ export async function assessIntegrateRepo(
   const base = status.base;
   const isMergedNewWork =
     classified.skipFlag === "already-merged" && base?.merge?.newCommitsAfter != null && base.merge.newCommitsAfter > 0;
+  const isFullyMerged = classified.skipFlag === "already-merged" && !isMergedNewWork;
 
-  if (classified.outcome === "skip" && !isMergedNewWork) {
+  if (classified.outcome === "skip" && !isMergedNewWork && !isFullyMerged) {
     return classified;
   }
 
@@ -179,6 +180,64 @@ export async function assessIntegrateRepo(
   });
   if (mergedNewWorkAssessment) return mergedNewWorkAssessment;
 
+  // Fully-merged branches: reset to base instead of skipping.
+  // For rebase mode, use --onto to move the branch pointer to the base (0 commits replayed).
+  // For merge mode, fast-forward merge to the base.
+  if (isFullyMerged && base) {
+    const behind = base.behind;
+    const ahead = base.ahead;
+
+    if (behind === 0 && ahead === 0) {
+      return { ...withoutSkipFields(classified), outcome: "up-to-date", baseBranch: base.ref, behind: 0, ahead: 0 };
+    }
+
+    const flags = computeFlags(status, branch);
+    if (flags.isDirty && !options.autostash) {
+      return {
+        ...classified,
+        outcome: "skip" as const,
+        skipReason: "uncommitted changes (use --autostash)",
+        skipFlag: "dirty" as const,
+      };
+    }
+    const needsStash =
+      flags.isDirty && options.autostash && (status.local.staged > 0 || status.local.modified > 0)
+        ? true
+        : undefined;
+
+    if (options.mode === "rebase") {
+      return {
+        ...withoutSkipFields(classified),
+        outcome: "will-operate",
+        baseBranch: base.ref,
+        behind,
+        ahead: 0,
+        needsStash,
+        retarget: {
+          from: headSha,
+          to: base.ref,
+          replayCount: 0,
+          alreadyOnTarget: ahead,
+          reason: "branch-merged",
+        },
+      };
+    }
+
+    // Merge mode
+    if (behind > 0) {
+      return {
+        ...withoutSkipFields(classified),
+        outcome: "will-operate",
+        baseBranch: base.ref,
+        behind,
+        ahead,
+        needsStash,
+      };
+    }
+
+    return { ...withoutSkipFields(classified), outcome: "up-to-date", baseBranch: base.ref, behind: 0, ahead };
+  }
+
   // Auto-replay-plan optimization: when the base branch has squash-merged some of
   // the feature branch's commits, detect contiguous replay plans and use --onto
   // to skip already-merged commits during a normal rebase.

src/lib/sync/integrate.ts

@@ -240,8 +240,12 @@ export async function integrate(
       if (a.retarget?.from) {
         // Branch-merged replay: use --onto to skip already-merged commits
         const n = a.retarget.replayCount ?? a.ahead;
-        const progressMsg = `rebasing ${n} new ${n === 1 ? "commit" : "commits"} onto ${ref} (merged)`;
-        inlineStart(a.repo, progressMsg);
+        if (n === 0) {
+          inlineStart(a.repo, `resetting to ${ref} (merged)`);
+        } else {
+          const progressMsg = `rebasing ${n} new ${n === 1 ? "commit" : "commits"} onto ${ref} (merged)`;
+          inlineStart(a.repo, progressMsg);
+        }
         const rebaseArgs = ["rebase"];
         if (a.needsStash) rebaseArgs.push("--autostash");
         rebaseArgs.push("--onto", ref, a.retarget.from);
@@ -276,7 +280,10 @@ export async function integrate(
         let doneMsg: string;
         if (a.retarget?.from) {
           const n = a.retarget.replayCount ?? a.ahead;
-          doneMsg = `rebased ${n} new ${n === 1 ? "commit" : "commits"} onto ${ref} (merged)`;
+          doneMsg =
+            n === 0
+              ? `reset to ${ref} (merged)`
+              : `rebased ${n} new ${n === 1 ? "commit" : "commits"} onto ${ref} (merged)`;
         } else {
           doneMsg = mode === "rebase" ? `rebased ${a.branch} onto ${ref}` : `merged ${ref} into ${a.branch}`;
         }