Handle fully merged stacks gracefully in the view and modify TUIs

Merged branches (and their PRs) are not selectable, so once an entire stack
has landed there is nothing to act on -- yet the TUIs did not reflect that:

- `gh stack view` still drew a highlighted cursor on the top branch even
  though it could not be selected. Navigation, checkout, and the per-branch
  toggles all silently did nothing, with no indication of why.
- `gh stack modify` opened its full editor on a stack with nothing left to
  restructure, instead of short-circuiting like `gh stack submit` does when
  there is nothing to submit.

Reflect the "nothing actionable" state in both TUIs.

View (internal/tui/stackview/model.go):

- Hide the cursor when every branch is merged. `New` now starts the cursor
  at -1 and only lands it on the current or first non-merged branch; when
  none exists the cursor stays hidden, so no row is rendered as focused. The
  existing `m.cursor >= 0` guards and merged-skipping `moveCursor` already
  make every cursor action a no-op in that state, and mouse-wheel scrolling
  still works for tall merged stacks.
- Dim the shortcuts that depend on the cursor. `buildHeaderConfig` marks
  navigate, commits, files, open PR, and checkout as `Disabled` (rendered
  gray via the existing ShortcutEntry.Disabled styling) when all branches
  are merged, leaving only `q quit` active.

Modify (cmd/modify.go):

- Short-circuit before opening the TUI. After preconditions pass and PR
  state is synced, `runModify` now returns early when the stack is fully
  merged, printing "All branches in this stack have been merged" and
  pointing at `gh stack init`, exiting cleanly (exit 0) like submit's
  "nothing to submit" path. The linearity and merge-queue precondition
  checks already skip merged branches, so they do not fire spuriously.

Tests:
- internal/tui/stackview/model_test.go: the cursor is hidden (-1) when all
  branches are merged; up/down/enter do not move it or trigger a checkout;
  View renders without panicking on a hidden cursor; buildHeaderConfig
  disables every cursor-dependent shortcut (and only those) when all merged,
  and leaves them all enabled when active branches remain.
- cmd/modify_test.go: runModify short-circuits on a fully merged stack,
  printing the message and returning no error without launching the TUI.

Author: skarim

cmd/modify.go

@@ -74,6 +74,14 @@ func runModify(cfg *config.Config) error {
 	s := result.Stack
 	currentBranch := result.CurrentBranch
 
+	// A fully merged stack has nothing left to restructure. Short-circuit
+	// before opening the TUI, mirroring submit's "nothing to submit" behavior.
+	if s.IsFullyMerged() {
+		cfg.Warningf("All branches in this stack have been merged")
+		cfg.Printf("There's nothing to modify — start a new stack with `%s`", cfg.ColorCyan("gh stack init"))
+		return nil
+	}
+
 	// Load branch data for the TUI
 	viewNodes := stackview.LoadBranchNodes(cfg, s, currentBranch, result.PRDetails)
 

cmd/modify_test.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"encoding/json"
+	"io"
 	"os"
 	"path/filepath"
 	"testing"
@@ -636,6 +637,50 @@ func TestCheckModifyPreconditions_AllPass(t *testing.T) {
 	assert.Equal(t, "b1", result.CurrentBranch)
 }
 
+func TestRunModify_FullyMergedStack_ShortCircuits(t *testing.T) {
+	s := stack.Stack{
+		Trunk: stack.BranchRef{Branch: "main"},
+		Branches: []stack.BranchRef{
+			{Branch: "b1", PullRequest: &stack.PullRequestRef{Number: 1, Merged: true}},
+			{Branch: "b2", PullRequest: &stack.PullRequestRef{Number: 2, Merged: true}},
+		},
+	}
+
+	tmpDir := t.TempDir()
+	writeStackFile(t, tmpDir, s)
+
+	mock := &git.MockOps{
+		GitDirFn:                func() (string, error) { return tmpDir, nil },
+		CurrentBranchFn:         func() (string, error) { return "b1", nil },
+		IsRebaseInProgressFn:    func() bool { return false },
+		HasUncommittedChangesFn: func() (bool, error) { return false, nil },
+		BranchExistsFn:          func(string) bool { return true },
+		IsAncestorFn:            func(a, d string) (bool, error) { return true, nil },
+		LogMergesFn:             func(base, head string) ([]git.CommitInfo, error) { return nil, nil },
+	}
+	restore := git.SetOps(mock)
+	defer restore()
+
+	cfg, _, errR := config.NewTestConfig()
+	cfg.ForceInteractive = true
+	cfg.GitHubClientOverride = &github.MockClient{
+		FindPRForBranchFn: func(string) (*github.PullRequest, error) { return nil, nil },
+	}
+
+	// runModify must short-circuit (and never launch the TUI) on a fully
+	// merged stack, returning cleanly like submit's "nothing to submit" path.
+	err := runModify(cfg)
+
+	cfg.Out.Close()
+	cfg.Err.Close()
+	out, _ := io.ReadAll(errR)
+	output := string(out)
+
+	assert.NoError(t, err)
+	assert.Contains(t, output, "All branches in this stack have been merged")
+	assert.Contains(t, output, "gh stack init")
+}
+
 // ---------------------------------------------------------------------------
 // 5. State file path / exists edge cases
 // ---------------------------------------------------------------------------

internal/tui/stackview/model.go

@@ -83,17 +83,17 @@ func New(nodes []BranchNode, trunk stack.BranchRef, version string) Model {
 	h := help.New()
 	h.ShowAll = true
 
-	// Cursor starts at the current branch, or first non-merged branch
-	cursor := 0
-	found := false
+	// Cursor starts at the current branch, or the first non-merged branch.
+	// When every branch is merged there is nothing selectable, so the cursor
+	// is hidden (-1) and the cursor-dependent shortcuts are disabled.
+	cursor := -1
 	for i, n := range nodes {
 		if n.IsCurrent && !n.Ref.IsMerged() {
 			cursor = i
-			found = true
 			break
 		}
 	}
-	if !found {
+	if cursor < 0 {
 		for i, n := range nodes {
 			if !n.Ref.IsMerged() {
 				cursor = i
@@ -439,6 +439,10 @@ func (m Model) buildHeaderConfig() shared.HeaderConfig {
 		branchIcon = "●"
 	}
 
+	// When every branch is merged there is no selectable branch, so the cursor
+	// is hidden and the actions that depend on it are dimmed; only quit works.
+	allMerged := branchCount > 0 && mergedCount == branchCount
+
 	return shared.HeaderConfig{
 		ShowArt:  true,
 		Title:    "View Stack",
@@ -450,11 +454,11 @@ func (m Model) buildHeaderConfig() shared.HeaderConfig {
 		},
 		ShortcutColumns: 1,
 		Shortcuts: []shared.ShortcutEntry{
-			{Key: "↑↓", Desc: "navigate"},
-			{Key: "c", Desc: "commits"},
-			{Key: "f", Desc: "files"},
-			{Key: "o", Desc: "open PR"},
-			{Key: "↵", Desc: "checkout"},
+			{Key: "↑↓", Desc: "navigate", Disabled: allMerged},
+			{Key: "c", Desc: "commits", Disabled: allMerged},
+			{Key: "f", Desc: "files", Disabled: allMerged},
+			{Key: "o", Desc: "open PR", Disabled: allMerged},
+			{Key: "↵", Desc: "checkout", Disabled: allMerged},
 			{Key: "q", Desc: "quit"},
 		},
 	}

internal/tui/stackview/model_test.go

@@ -9,6 +9,7 @@ import (
 	ghapi "github.com/github/gh-stack/internal/github"
 	"github.com/github/gh-stack/internal/stack"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func makeNodes(branches ...string) []BranchNode {
@@ -388,3 +389,67 @@ func TestUpdate_EnterOnMergedDoesNothing(t *testing.T) {
 	assert.Equal(t, "", m.CheckoutBranch(), "enter on merged branch should not set checkout")
 	assert.Nil(t, cmd, "enter on merged branch should not quit")
 }
+
+// makeAllMergedNodes returns nodes whose branches are all merged.
+func makeAllMergedNodes(branches ...string) []BranchNode {
+	nodes := makeNodes(branches...)
+	for i := range nodes {
+		nodes[i].Ref.PullRequest = &stack.PullRequestRef{Number: i + 1, Merged: true}
+	}
+	return nodes
+}
+
+func TestNew_CursorHiddenWhenAllMerged(t *testing.T) {
+	m := New(makeAllMergedNodes("b1", "b2"), testTrunk, "0.0.1")
+	assert.Equal(t, -1, m.cursor, "cursor should be hidden when every branch is merged")
+}
+
+func TestUpdate_AllMergedCursorStaysHidden(t *testing.T) {
+	m := New(makeAllMergedNodes("b1", "b2", "b3"), testTrunk, "0.0.1")
+
+	updated, _ := m.Update(keyMsg("down"))
+	m = updated.(Model)
+	assert.Equal(t, -1, m.cursor, "down should not move the hidden cursor")
+
+	updated, _ = m.Update(keyMsg("up"))
+	m = updated.(Model)
+	assert.Equal(t, -1, m.cursor, "up should not move the hidden cursor")
+
+	updated, cmd := m.Update(keyMsg("enter"))
+	m = updated.(Model)
+	assert.Equal(t, "", m.CheckoutBranch(), "enter should not check out when all merged")
+	assert.Nil(t, cmd, "enter should not quit when all merged")
+}
+
+func TestView_AllMergedRendersWithoutPanic(t *testing.T) {
+	m := New(makeAllMergedNodes("b1", "b2"), testTrunk, "0.0.1")
+	updated, _ := m.Update(tea.WindowSizeMsg{Width: 100, Height: 40})
+	m = updated.(Model)
+	// Should not panic with a hidden (-1) cursor.
+	view := m.View()
+	assert.Contains(t, view, "b1")
+}
+
+func TestBuildHeaderConfig_DisablesShortcutsWhenAllMerged(t *testing.T) {
+	m := New(makeAllMergedNodes("b1", "b2"), testTrunk, "0.0.1")
+	cfg := m.buildHeaderConfig()
+
+	require.NotEmpty(t, cfg.Shortcuts)
+	for _, sc := range cfg.Shortcuts {
+		if sc.Desc == "quit" {
+			assert.False(t, sc.Disabled, "quit should stay enabled")
+		} else {
+			assert.True(t, sc.Disabled, "%q should be disabled when all branches merged", sc.Desc)
+		}
+	}
+}
+
+func TestBuildHeaderConfig_ShortcutsEnabledWithActiveBranches(t *testing.T) {
+	m := New(makeNodes("b1", "b2"), testTrunk, "0.0.1")
+	cfg := m.buildHeaderConfig()
+
+	require.NotEmpty(t, cfg.Shortcuts)
+	for _, sc := range cfg.Shortcuts {
+		assert.False(t, sc.Disabled, "%q should be enabled when there are active branches", sc.Desc)
+	}
+}