Make cherry-pick conflicts recoverable via --continue

Previously, cherry-pick conflicts during fold-down operations could only
be resolved with --abort. Now they save full conflict state (phase,
conflict type, fold branch/target, remaining branches) to the state file,
enabling recovery via 'gh stack modify --continue'.

Changes:
- Add ConflictType field to StateFile (rebase or cherry_pick)
- Add FoldBranch/FoldTarget fields for cherry-pick context
- Add CherryPickContinue to git package (cherry-pick --continue)
- Save cherry-pick conflict state in ApplyPlan with remaining branches
- ContinueApply handles both rebase and cherry-pick conflicts
- Unified conflict messaging in cmd/modify.go (both types show --continue)
- Updated test to verify cherry-pick conflict state is saved correctly

Author: skarim

cmd/modify.go

@@ -123,26 +123,15 @@ func runModify(cfg *config.Config) error {
 		isCherryPick := applyErr != nil && strings.Contains(applyErr.Error(), "cherry-pick")
 		if isCherryPick {
 			cfg.Warningf("Cherry-pick conflict folding %s", conflict.Branch)
-			if len(conflict.ConflictedFiles) > 0 {
-				cfg.Printf("")
-				cfg.Printf("%s", cfg.ColorBold("Conflicted files:"))
-				for _, f := range conflict.ConflictedFiles {
-					cfg.Printf("  %s %s", cfg.ColorWarning("C"), f)
-				}
-			}
-			cfg.Printf("")
-			cfg.Printf("Cherry-pick conflicts cannot be continued with `--continue`.")
-			cfg.Printf("Restore the stack to its pre-modify state with `%s`",
-				cfg.ColorCyan("gh stack modify --abort"))
 		} else {
 			cfg.Warningf("Rebasing %s — conflict", conflict.Branch)
+		}
 
-			printConflictDetailsWithContinue(cfg, conflict.Branch, "gh stack modify --continue")
-			cfg.Printf("")
+		printConflictDetailsWithContinue(cfg, conflict.Branch, "gh stack modify --continue")
+		cfg.Printf("")
 
-			cfg.Printf("Or restore the stack to its pre-modify state with `%s`",
-				cfg.ColorCyan("gh stack modify --abort"))
-		}
+		cfg.Printf("Or restore the stack to its pre-modify state with `%s`",
+			cfg.ColorCyan("gh stack modify --abort"))
 		return ErrConflict
 	}
 

internal/git/git.go

@@ -368,6 +368,11 @@ func CherryPickAbort() {
 	_ = ops.CherryPickAbort()
 }
 
+// CherryPickContinue continues an in-progress cherry-pick after conflicts are resolved.
+func CherryPickContinue() error {
+	return ops.CherryPickContinue()
+}
+
 // HasUncommittedChanges returns true if the working tree has uncommitted changes.
 func HasUncommittedChanges() (bool, error) {
 	return ops.HasUncommittedChanges()

internal/git/gitops.go

@@ -59,6 +59,7 @@ type Ops interface {
 	RenameBranch(oldName, newName string) error
 	CherryPick(commits []string) error
 	CherryPickAbort() error
+	CherryPickContinue() error
 	HasUncommittedChanges() (bool, error)
 	LogMerges(base, head string) ([]CommitInfo, error)
 }
@@ -513,6 +514,12 @@ func (d *defaultOps) CherryPickAbort() error {
 	return runSilent("cherry-pick", "--quit")
 }
 
+func (d *defaultOps) CherryPickContinue() error {
+	cmd := exec.Command("git", "cherry-pick", "--continue")
+	cmd.Env = append(os.Environ(), "GIT_EDITOR=true")
+	return cmd.Run()
+}
+
 func (d *defaultOps) HasUncommittedChanges() (bool, error) {
 	out, err := run("status", "--porcelain")
 	if err != nil {

internal/git/mock_ops.go

@@ -359,6 +359,10 @@ func (m *MockOps) CherryPickAbort() error {
 	return nil
 }
 
+func (m *MockOps) CherryPickContinue() error {
+	return nil
+}
+
 func (m *MockOps) HasUncommittedChanges() (bool, error) {
 	if m.HasUncommittedChangesFn != nil {
 		return m.HasUncommittedChangesFn()

internal/modify/apply.go

@@ -281,6 +281,35 @@ func ApplyPlan(
 					if files, ferr := git.ConflictedFiles(); ferr == nil {
 						conflict.ConflictedFiles = files
 					}
+
+					// Compute remaining branches for cascading rebase after cherry-pick resumes.
+					// Since folds happen before cascading rebase (Step 5), all non-merged, non-folded
+					// branches need rebasing.
+					remaining := make([]string, 0)
+					for _, br := range s.Branches {
+						if !br.IsMerged() && br.Branch != foldBranch {
+							remaining = append(remaining, br.Branch)
+						}
+					}
+
+					// Save conflict state so --continue can resume the cherry-pick
+					stateFile.Phase = PhaseConflict
+					stateFile.ConflictBranch = foldBranch
+					stateFile.ConflictType = "cherry_pick"
+					stateFile.FoldBranch = foldBranch
+					stateFile.FoldTarget = targetBranch
+					stateFile.RemainingBranches = remaining
+					stateFile.OriginalBranch = currentBranch
+					stateFile.OriginalRefs = originalParentTips
+					if saveErr := SaveState(gitDir, stateFile); saveErr != nil {
+						cfg.Warningf("failed to save conflict state: %v", saveErr)
+					}
+
+					// Save stack metadata so far
+					if saveErr := stack.SaveWithLock(gitDir, sf, lock); saveErr != nil {
+						cfg.Warningf("failed to save stack metadata: %v", saveErr)
+					}
+
 					return nil, conflict, fmt.Errorf("cherry-pick conflict folding %s into %s", foldBranch, targetBranch)
 				}
 
@@ -446,6 +475,7 @@ func ApplyPlan(
 			}
 			stateFile.Phase = PhaseConflict
 			stateFile.ConflictBranch = b.Branch
+			stateFile.ConflictType = "rebase"
 			stateFile.RemainingBranches = remaining
 			stateFile.OriginalBranch = currentBranch
 			stateFile.OriginalRefs = originalParentTips
@@ -454,7 +484,9 @@ func ApplyPlan(
 			}
 
 			// Save stack metadata so far (renames, folds, drops already applied)
-			_ = stack.SaveWithLock(gitDir, sf, lock)
+			if saveErr := stack.SaveWithLock(gitDir, sf, lock); saveErr != nil {
+				cfg.Warningf("failed to save stack metadata: %v", saveErr)
+			}
 
 			return nil, conflict, fmt.Errorf("rebase conflict on %s", b.Branch)
 		}
@@ -519,26 +551,36 @@ func ContinueApply(
 	}
 	defer lock.Unlock()
 
-	// Find the stack
+	// Find the stack using the saved index for reliable identification.
 	var s *stack.Stack
-	for i := range sf.Stacks {
-		if sf.Stacks[i].Trunk.Branch == state.StackName {
-			s = &sf.Stacks[i]
-			break
-		}
+	if state.StackIndex >= 0 && state.StackIndex < len(sf.Stacks) {
+		s = &sf.Stacks[state.StackIndex]
 	}
 	if s == nil {
-		return fmt.Errorf("stack %q not found", state.StackName)
+		return fmt.Errorf("stack at index %d not found (stack file may have changed)", state.StackIndex)
 	}
 
-	// Finish the in-progress git rebase
-	if git.IsRebaseInProgress() {
-		if err := git.RebaseContinue(); err != nil {
-			return fmt.Errorf("rebase continue failed — resolve remaining conflicts and try again: %w", err)
+	// Finish the in-progress git operation (rebase or cherry-pick)
+	if state.ConflictType == "cherry_pick" {
+		if err := git.CherryPickContinue(); err != nil {
+			return fmt.Errorf("cherry-pick continue failed — resolve remaining conflicts and try again: %w", err)
 		}
-	}
+		cfg.Successf("Folded %s into %s", state.FoldBranch, state.FoldTarget)
 
-	cfg.Successf("Rebased %s", state.ConflictBranch)
+		// Remove the folded branch from stack metadata
+		foldIdx := s.IndexOf(state.FoldBranch)
+		if foldIdx >= 0 && foldIdx < len(s.Branches) {
+			s.Branches = append(s.Branches[:foldIdx], s.Branches[foldIdx+1:]...)
+		}
+	} else {
+		// Rebase conflict
+		if git.IsRebaseInProgress() {
+			if err := git.RebaseContinue(); err != nil {
+				return fmt.Errorf("rebase continue failed — resolve remaining conflicts and try again: %w", err)
+			}
+		}
+		cfg.Successf("Rebased %s", state.ConflictBranch)
+	}
 
 	// Continue cascading rebase for remaining branches
 	for _, branchName := range state.RemainingBranches {

internal/modify/apply_test.go

@@ -751,15 +751,86 @@ func TestApplyPlan_ConflictDuringCherryPick(t *testing.T) {
 	require.NotNil(t, conflict)
 	assert.Equal(t, "B", conflict.Branch)
 
-	// Cherry-pick conflicts return a conflict immediately (no "conflict" state for continue)
+	// Cherry-pick conflicts now save state for --continue recovery
 	state, loadErr := LoadState(gitDir)
 	require.NoError(t, loadErr)
-	// The state file is created with "applying" phase before the conflict,
-	// but cherry-pick conflicts don't update it to "conflict"
-	if state != nil {
-		assert.NotEqual(t, "conflict", state.Phase,
-			"cherry-pick conflicts should not set phase to 'conflict'")
+	require.NotNil(t, state)
+	assert.Equal(t, PhaseConflict, state.Phase)
+	assert.Equal(t, "cherry_pick", state.ConflictType)
+	assert.Equal(t, "B", state.FoldBranch)
+	assert.Equal(t, "A", state.FoldTarget)
+	assert.Equal(t, "A", state.OriginalBranch)
+	assert.Contains(t, state.RemainingBranches, "A")
+}
+
+// ─── ContinueApply: Multi-Stack Finds Correct Stack ─────────────────────────
+
+func TestContinueApply_MultiStackFindsCorrectStack(t *testing.T) {
+	// When multiple stacks share the same trunk, ContinueApply should use
+	// StackIndex to find the right stack, not just trunk name matching.
+	gitDir := t.TempDir()
+
+	// Stack 0: main <- X (a different stack)
+	// Stack 1: main <- A <- B <- C (the one being modified)
+	sf := &stack.StackFile{
+		SchemaVersion: 1,
+		Stacks: []stack.Stack{
+			{
+				Trunk:    stack.BranchRef{Branch: "main"},
+				Branches: []stack.BranchRef{{Branch: "X"}},
+			},
+			{
+				Trunk: stack.BranchRef{Branch: "main"},
+				Branches: []stack.BranchRef{
+					{Branch: "A"},
+					{Branch: "B"},
+					{Branch: "C"},
+				},
+			},
+		},
+	}
+	data, err := json.MarshalIndent(sf, "", "  ")
+	require.NoError(t, err)
+	require.NoError(t, os.WriteFile(filepath.Join(gitDir, "gh-stack"), data, 0644))
+
+	// Create a state file pointing at Stack 1 (index 1)
+	state := &StateFile{
+		SchemaVersion:   1,
+		StackName:       "main",
+		StackIndex:      1, // The correct stack is at index 1
+		Phase:           PhaseConflict,
+		ConflictBranch:  "A",
+		ConflictType:    "rebase",
+		RemainingBranches: []string{"B", "C"},
+		OriginalRefs:    map[string]string{"B": "sha-A", "C": "sha-B"},
+	}
+	require.NoError(t, SaveState(gitDir, state))
+
+	mock := newApplyMock(gitDir, map[string]string{
+		"main": "sha-main", "A": "sha-A", "B": "sha-B", "C": "sha-C",
+	})
+	mock.IsRebaseInProgressFn = func() bool { return true }
+	mock.RebaseContinueFn = func() error { return nil }
+
+	var rebasedBranches []string
+	mock.RebaseOntoFn = func(newBase, oldBase, branch string) error {
+		rebasedBranches = append(rebasedBranches, branch)
+		return nil
 	}
+
+	restore := git.SetOps(mock)
+	defer restore()
+
+	cfg, _, _ := config.NewTestConfig()
+	defer cfg.Out.Close()
+	defer cfg.Err.Close()
+
+	err = ContinueApply(cfg, gitDir, noopUpdateBaseSHAs)
+	require.NoError(t, err)
+
+	// B and C should have been found and processed (not "no longer in stack")
+	assert.Contains(t, rebasedBranches, "B", "B should be rebased")
+	assert.Contains(t, rebasedBranches, "C", "C should be rebased")
 }
 
 // ─── Unwind ──────────────────────────────────────────────────────────────────

internal/modify/state.go

@@ -31,9 +31,14 @@ type StateFile struct {
 
 	// Conflict state — populated when phase is "conflict"
 	ConflictBranch    string            `json:"conflict_branch,omitempty"`
+	ConflictType      string            `json:"conflict_type,omitempty"` // "rebase" or "cherry_pick"
 	RemainingBranches []string          `json:"remaining_branches,omitempty"`
 	OriginalBranch    string            `json:"original_branch,omitempty"`
 	OriginalRefs      map[string]string `json:"original_refs,omitempty"`
+
+	// Cherry-pick conflict context — which fold was in progress
+	FoldBranch string `json:"fold_branch,omitempty"` // branch being folded
+	FoldTarget string `json:"fold_target,omitempty"` // branch receiving the cherry-pick
 }
 
 // Snapshot captures the pre-modify state for unwind/recovery.