[feat] merge auto-cleanup deletes the merged remote branch (#277) (#305)

* [feat] merge auto-cleanup deletes the merged remote branch (#277)

After a successful merge-to-main, rimba merge now deletes the remote
branch (origin/<branch>) in the same best-effort step that clean --merged
already performs, reaching behavioural parity with #231.

Remote deletion is skipped when no origin is configured, suppressed by
--keep/--delete, previewed in --dry-run, and never fails the merge itself
(captured in RemoteError, surfaced in CLI output and MCP remote_deleted).

* [fix] address PR #305 review feedback

- Surface RemoteError in failure output (%v) so users see the deletion reason
- Document wtRemoved-only gate: defers remote cleanup on partial failure to rimba clean
- Replace gitSubcmdStashPush with gitCmdPush in cmd/merge_test.go; add explicit remote arm
- Assert --delete flag in TestMergeWorktreeRemoteDeleteSuccess push args
- Remove dead wtDir / resolver.WorktreePath lines from both new e2e tests

Author: lugassawan

cmd/merge.go

@@ -107,6 +107,13 @@ var mergeCmd = &cobra.Command{
 			fmt.Fprintf(cmd.OutOrStdout(), "Merged successfully but failed to remove worktree: %v\nTo remove manually: rimba remove %s\n", result.RemoveError, sourceTask)
 		}
 
+		if result.RemoteDeleted {
+			fmt.Fprintf(cmd.OutOrStdout(), "Deleted remote branch: %s/%s\n", git.DefaultRemote, result.SourceBranch)
+		} else if result.RemoteError != nil {
+			fmt.Fprintf(cmd.OutOrStdout(), "Failed to delete remote branch %s/%s: %v\nTo delete remote: git push %s --delete %s\n",
+				git.DefaultRemote, result.SourceBranch, result.RemoteError, git.DefaultRemote, result.SourceBranch)
+		}
+
 		return nil
 	},
 }

cmd/merge_test.go

@@ -10,7 +10,10 @@ import (
 	"github.com/lugassawan/rimba/internal/config"
 )
 
-const mergeWorktreeOut = "worktree /repo\nHEAD abc123\nbranch refs/heads/main\n\nworktree /wt/feature-login\nHEAD def456\nbranch refs/heads/feature/login\n\nworktree /wt/feature-dashboard\nHEAD ghi789\nbranch refs/heads/feature/dashboard\n"
+const (
+	mergeWorktreeOut = "worktree /repo\nHEAD abc123\nbranch refs/heads/main\n\nworktree /wt/feature-login\nHEAD def456\nbranch refs/heads/feature/login\n\nworktree /wt/feature-dashboard\nHEAD ghi789\nbranch refs/heads/feature/dashboard\n"
+	gitCmdPush       = "push" // first arg of "git push <remote> ..." — distinct from gitSubcmdStashPush which is args[1] of "git stash push"
+)
 
 func mergeTestRunner(mergeErr error) *mockRunner {
 	return &mockRunner{
@@ -479,3 +482,76 @@ func TestMergeWithNoFF(t *testing.T) {
 		t.Errorf("merge args = %v, want --no-ff to be present", mergeArgs)
 	}
 }
+
+func TestMergeRemoteDeletedOutput(t *testing.T) {
+	cfg := &config.Config{DefaultSource: branchMain, WorktreeDir: defaultRelativeWtDir}
+	// mergeTestRunner returns ("", nil) for unmatched run calls → origin present, push succeeds.
+	r := mergeTestRunner(nil)
+	restore := overrideNewRunner(r)
+	defer restore()
+
+	cmd, buf := newTestCmd()
+	cmd.Flags().String(flagInto, "", "")
+	cmd.Flags().Bool(flagNoFF, false, "")
+	cmd.Flags().Bool(flagKeep, false, "")
+	cmd.Flags().Bool(flagDelete, false, "")
+	cmd.SetContext(config.WithConfig(context.Background(), cfg))
+
+	if err := mergeCmd.RunE(cmd, []string{"login"}); err != nil {
+		t.Fatalf(fatalMergeRunE, err)
+	}
+	out := buf.String()
+	if !strings.Contains(out, "Deleted remote branch: origin/feature/login") {
+		t.Errorf("output = %q, want 'Deleted remote branch: origin/feature/login'", out)
+	}
+}
+
+func TestMergeRemoteDeleteFailedOutput(t *testing.T) {
+	cfg := &config.Config{DefaultSource: branchMain, WorktreeDir: defaultRelativeWtDir}
+	r := &mockRunner{
+		run: func(args ...string) (string, error) {
+			if len(args) >= 2 && args[1] == cmdShowToplevel {
+				return repoPath, nil
+			}
+			if len(args) >= 1 && args[0] == "remote" {
+				return "https://github.com/lugassawan/rimba.git", nil
+			}
+			if len(args) >= 1 && args[0] == gitCmdPush {
+				return "", errors.New("connection refused")
+			}
+			return mergeWorktreeOut, nil
+		},
+		runInDir: func(_ string, args ...string) (string, error) {
+			if len(args) >= 1 && args[0] == cmdStatus {
+				return "", nil
+			}
+			if len(args) >= 1 && args[0] == flagSyncMerge {
+				return "", nil
+			}
+			return "", nil
+		},
+	}
+	restore := overrideNewRunner(r)
+	defer restore()
+
+	cmd, buf := newTestCmd()
+	cmd.Flags().String(flagInto, "", "")
+	cmd.Flags().Bool(flagNoFF, false, "")
+	cmd.Flags().Bool(flagKeep, false, "")
+	cmd.Flags().Bool(flagDelete, false, "")
+	cmd.SetContext(config.WithConfig(context.Background(), cfg))
+
+	if err := mergeCmd.RunE(cmd, []string{"login"}); err != nil {
+		t.Fatalf(fatalMergeRunE, err)
+	}
+	out := buf.String()
+	if !strings.Contains(out, "Failed to delete remote branch") {
+		t.Errorf("output = %q, want 'Failed to delete remote branch'", out)
+	}
+	if !strings.Contains(out, "connection refused") {
+		t.Errorf("output = %q, want remote error reason 'connection refused'", out)
+	}
+	if !strings.Contains(out, "git push origin --delete") {
+		t.Errorf("output = %q, want manual hint with 'git push origin --delete'", out)
+	}
+}

internal/mcp/tool_merge.go

@@ -70,6 +70,7 @@ func handleMerge(hctx *HandlerContext) server.ToolHandlerFunc {
 			Source:        result.SourceBranch,
 			Into:          result.TargetLabel,
 			SourceRemoved: result.SourceRemoved,
+			RemoteDeleted: result.RemoteDeleted,
 		})
 	}
 }

internal/mcp/types.go

@@ -61,6 +61,7 @@ type mergeResult struct {
 	Source        string `json:"source"`
 	Into          string `json:"into"`
 	SourceRemoved bool   `json:"source_removed"`
+	RemoteDeleted bool   `json:"remote_deleted,omitempty"`
 }
 
 // syncResult holds the outcome of a sync operation.

internal/operations/merge.go

@@ -34,6 +34,8 @@ type MergeResult struct {
 	SourceRemoved   bool  // true only if both worktree removed and branch deleted
 	WorktreeRemoved bool  // true if worktree was removed (branch may still exist)
 	RemoveError     error // non-nil if cleanup failed
+	RemoteDeleted   bool  // true if the remote branch was deleted (parity with clean --merged, #231)
+	RemoteError     error // non-nil if remote-branch deletion was attempted and failed
 	Plan            *Plan // always non-nil on a successful return; records steps that were (or would be) executed
 }
 
@@ -121,11 +123,36 @@ func MergeWorktree(ctx context.Context, r git.Runner, params MergeParams, onProg
 		if rmErr != nil {
 			result.RemoveError = rmErr
 		}
+
+		// Delete the merged remote branch (best-effort, parity with clean --merged, #231).
+		// Gated on wtRemoved (not brDeleted) so that a partial failure — branch deleted but
+		// worktree still on disk — defers remote cleanup to a later `rimba clean --merged` run.
+		deleteMergedRemote(ctx, r, plan, source.Branch, &result, params.DryRun, wtRemoved)
 	}
 
 	return result, nil
 }
 
+// deleteMergedRemote deletes the remote tracking branch after a merge cleanup.
+// It is a no-op when the remote is absent or when the worktree was not actually
+// removed. Failures are captured in result.RemoteError and never abort the merge.
+func deleteMergedRemote(ctx context.Context, r git.Runner, plan *Plan, branch string, result *MergeResult, dryRun, wtRemoved bool) {
+	if !dryRun && !wtRemoved {
+		return
+	}
+	if !git.RemoteExists(ctx, r, git.DefaultRemote) {
+		return
+	}
+	_ = plan.Do("delete remote branch: "+git.DefaultRemote+"/"+branch, func() error {
+		var remoteErr error
+		if remoteErr = git.DeleteRemoteBranch(ctx, r, git.DefaultRemote, branch); remoteErr == nil {
+			result.RemoteDeleted = true
+		}
+		result.RemoteError = remoteErr
+		return nil // best-effort: never abort the merge
+	})
+}
+
 // abortFailedMerge attempts to roll back a failed merge in targetDir.
 // It checks MERGE_HEAD first so we only abort when a merge is actually in progress.
 // If the abort also fails, both errors are surfaced with a manual-cleanup hint.