Heal stacks whose recorded base was already corrupted

The previous commit stops `gh stack push` from recording a base the branch does
not contain, but every stack that has already been through that path still
carries a bad value on disk. Those stacks would keep hitting the conflict on
their next rebase, because neither the parent's current tip nor the recorded
base is a boundary the branch actually has.

`resolveOntoOldBase` now also considers `git merge-base --fork-point`, which
reads the parent's reflog and so still finds where the branch diverged after
the parent was amended, rebased, or force-pushed — exactly the record the stack
file lost. It is only a candidate: the ancestry check still gates it, and a
fresh clone or an expired reflog simply falls through to the merge bases as
before.

Verified on a real stack whose metadata had been corrupted by the previous
build: the rebase now completes, replaying one commit instead of two, and the
recorded bases are genuine ancestors again afterwards.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5959297-80fd-4732-aeae-aa9a4b6a7755

Author: skarim

cmd/onto_base_test.go

@@ -92,6 +92,38 @@ func TestResolveOntoOldBase(t *testing.T) {
 		assert.Equal(t, "trunk", got)
 	})
 
+	// Stacks written by an older version recorded the parent's amended tip as
+	// the child's base, so the metadata is no more usable than the recorded
+	// tip. git's fork-point reads the parent's reflog and still finds the real
+	// boundary, which lets those stacks heal on their next rebase.
+	t.Run("uses the fork point when the metadata base is also stale", func(t *testing.T) {
+		restore := git.SetOps(&git.MockOps{
+			IsAncestorFn:         ancestryMock(history),
+			MergeBaseFn:          func(a, b string) (string, error) { return "trunk", nil },
+			MergeBaseForkPointFn: func(ref, branch string) (string, error) { return "a-old", nil },
+		})
+		defer restore()
+
+		// Both the recorded tip and the metadata base are the amended commit.
+		got := resolveOntoOldBase("a-new", "a-new", "b1", "b2")
+		assert.Equal(t, "a-old", got,
+			"the fork point is the only remaining record of where b2 diverged")
+	})
+
+	t.Run("ignores an unavailable fork point", func(t *testing.T) {
+		restore := git.SetOps(&git.MockOps{
+			IsAncestorFn: ancestryMock(history),
+			MergeBaseFn:  func(a, b string) (string, error) { return "trunk", nil },
+			MergeBaseForkPointFn: func(ref, branch string) (string, error) {
+				return "", errors.New("no fork point found")
+			},
+		})
+		defer restore()
+
+		got := resolveOntoOldBase("a-new", "", "b1", "b2")
+		assert.Equal(t, "trunk", got)
+	})
+
 	t.Run("returns the recorded value when nothing is usable", func(t *testing.T) {
 		restore := git.SetOps(&git.MockOps{
 			IsAncestorFn: func(string, string) (bool, error) { return false, nil },

cmd/utils.go

@@ -1240,7 +1240,10 @@ type cascadeRebaseResult struct {
 //  2. metadataBase — the parent tip this branch was last stacked on, from the
 //     stack file. Correct when the parent was amended, reordered, or
 //     squash-merged since.
-//  3. merge-base(recordedOldBase, branch) / merge-base(newBase, branch).
+//  3. merge-base --fork-point, which reads the parent's reflog and so still
+//     finds the right boundary when the stack file itself is stale — for
+//     example a stack whose metadata was written by an older version.
+//  4. merge-base(recordedOldBase, branch) / merge-base(newBase, branch).
 //
 // Returns recordedOldBase unchanged when nothing better can be determined.
 func resolveOntoOldBase(recordedOldBase, metadataBase, newBase, branch string) string {
@@ -1257,6 +1260,9 @@ func resolveOntoOldBase(recordedOldBase, metadataBase, newBase, branch string) s
 	}
 
 	candidates := []string{metadataBase}
+	if fp, err := git.MergeBaseForkPoint(newBase, branch); err == nil && fp != "" {
+		candidates = append(candidates, fp)
+	}
 	if mb, err := git.MergeBase(recordedOldBase, branch); err == nil {
 		candidates = append(candidates, mb)
 	}

internal/git/git.go

@@ -354,6 +354,14 @@ func MergeBase(a, b string) (string, error) {
 	return ops.MergeBase(a, b)
 }
 
+// MergeBaseForkPoint returns the commit at which branch forked off ref, using
+// ref's reflog to see through rewrites of ref itself (an amend, a rebase, a
+// force-push). Returns an error when no fork point can be determined, which is
+// normal in a fresh clone or once the reflog has expired.
+func MergeBaseForkPoint(ref, branch string) (string, error) {
+	return ops.MergeBaseForkPoint(ref, branch)
+}
+
 // Log returns recent commits for the given branch.
 func Log(ref string, maxCount int) ([]CommitInfo, error) {
 	return ops.Log(ref, maxCount)

internal/git/gitops.go

@@ -59,6 +59,7 @@ type Ops interface {
 	RevParse(ref string) (string, error)
 	RevParseMulti(refs []string) ([]string, error)
 	MergeBase(a, b string) (string, error)
+	MergeBaseForkPoint(ref, branch string) (string, error)
 	Log(ref string, maxCount int) ([]CommitInfo, error)
 	LogRange(base, head string) ([]CommitInfo, error)
 	DiffStatRange(base, head string) (additions, deletions int, err error)
@@ -442,6 +443,10 @@ func (d *defaultOps) MergeBase(a, b string) (string, error) {
 	return run("merge-base", a, b)
 }
 
+func (d *defaultOps) MergeBaseForkPoint(ref, branch string) (string, error) {
+	return run("merge-base", "--fork-point", ref, branch)
+}
+
 func (d *defaultOps) Log(ref string, maxCount int) ([]CommitInfo, error) {
 	format := "%H\t%s\t%at"
 	output, err := run("log", ref, "--format="+format, "-n", strconv.Itoa(maxCount))

internal/git/mock_ops.go

@@ -35,6 +35,7 @@ type MockOps struct {
 	RevParseFn                     func(string) (string, error)
 	RevParseMultiFn                func([]string) ([]string, error)
 	MergeBaseFn                    func(string, string) (string, error)
+	MergeBaseForkPointFn           func(string, string) (string, error)
 	LogFn                          func(string, int) ([]CommitInfo, error)
 	LogRangeFn                     func(string, string) ([]CommitInfo, error)
 	DiffStatRangeFn                func(string, string) (int, int, error)
@@ -280,6 +281,13 @@ func (m *MockOps) MergeBase(a, b string) (string, error) {
 	return "", nil
 }
 
+func (m *MockOps) MergeBaseForkPoint(ref, branch string) (string, error) {
+	if m.MergeBaseForkPointFn != nil {
+		return m.MergeBaseForkPointFn(ref, branch)
+	}
+	return "", nil
+}
+
 func (m *MockOps) Log(ref string, maxCount int) ([]CommitInfo, error) {
 	if m.LogFn != nil {
 		return m.LogFn(ref, maxCount)