add insert branch operation to modify TUI

Add `i` (insert below) and `I` (insert above) key bindings to the
interactive modify view, allowing users to insert new empty branches
into an existing stack. This follows Vim-inspired semantics where
lowercase `i` inserts below the cursor and uppercase `I` inserts above.

## TUI behavior

When the user presses `i` or `I`, the TUI enters an insert input mode
(similar to rename mode) where they type a new branch name. The input
is validated against git ref naming rules, local branch uniqueness, and
in-stack name collisions. On confirm, a placeholder node is inserted at
the correct position in the branch list with a green "✚ insert"
annotation badge and green connector styling.

Insert is a structure operation — it works alongside fold, rename, and
drop, but is mutually exclusive with reorder (consistent with existing
mode exclusivity rules). Undo (`z`) removes the inserted node cleanly.

## Apply engine

At apply time (Step 2 in the pipeline, between renames and folds), the
engine creates the new git branch at the parent branch's tip via
`git.CreateBranch` and inserts a `BranchRef` into the stack metadata at
the correct position. If the insertion changes the base of a branch
that has an open PR, `affectsPRs` is set to trigger a required
`gh stack submit` afterward.

## Header shortcut updates

- Combined the fold shortcuts into a single line: `d/u - fold down/up`
- Added insert shortcuts on their own line: `i/I - insert below/above`
- Reordered fold references throughout to list "down" before "up" for
  consistency with the insert shortcut ordering

## Files changed

- types.go: ActionInsertBelow/ActionInsertAbove types, IsInserted field,
  InsertedBranches in ApplyResult
- model.go: key bindings, insert input mode, undo, mode exclusivity,
  annotation, styling, header shortcuts, effective-index tracking to
  prevent false reorder detection when inserts shift node positions
- styles.go: green insert badge/branch/connector styles
- status.go: insert counting in pending change summary
- help.go: new "Insert below / above" section, reordered fold heading
- apply.go: BuildPlan and ApplyPlan handle insert actions
- modify.go: updated command description and success summary
- README.md: updated keybindings table

## Test coverage

- 16 new TUI tests: insert below/above, top/bottom edges, undo, mode
  exclusivity, merged branch guard, cancel/empty input, duplicate name
  validation, pending summary counting, annotation rendering, mixed
  operations with drop/fold, apply acceptance
- 4 new apply tests: BuildPlan produces correct insert actions,
  ApplyPlan creates branches and updates stack metadata, insert at
  stack start uses trunk as parent, affectsPRs triggered when inserting
  before a branch with an open PR

Author: skarim

cmd/modify.go

@@ -29,6 +29,7 @@ func ModifyCmd(cfg *config.Config) *cobra.Command {
 Operations available:
   • Drop branches from the stack
   • Fold branches into adjacent branches
+  • Insert new branches into the stack
   • Reorder branches
   • Rename branches
 
@@ -167,6 +168,10 @@ func printModifySuccess(cfg *config.Config, result *modifyview.ApplyResult) {
 		cfg.Printf("  Renamed: %s → %s", r.OldName, r.NewName)
 	}
 
+	for _, name := range result.InsertedBranches {
+		cfg.Printf("  Inserted: %s", name)
+	}
+
 	for _, d := range result.DroppedPRs {
 		cfg.Printf("  Dropped: %s (PR #%d remains open — close with `%s`)",
 			d.Branch, d.PRNumber, cfg.ColorCyan(fmt.Sprintf("gh pr close %d", d.PRNumber)))

internal/modify/apply.go

@@ -52,9 +52,18 @@ func BuildSnapshot(s *stack.Stack) (Snapshot, error) {
 func BuildPlan(nodes []modifyview.ModifyBranchNode) []Action {
 	var plan []Action
 
+	// When computing move detection, skip inserted nodes since they
+	// shift the indices of existing nodes.
+	effectiveIdx := 0
 	for i, n := range nodes {
-		if n.PendingAction == nil && n.OriginalPosition == i && !n.Removed {
-			continue
+		if n.IsInserted {
+			// Inserted nodes always have a PendingAction — handle below
+		} else {
+			if n.PendingAction == nil && n.OriginalPosition == effectiveIdx && !n.Removed {
+				effectiveIdx++
+				continue
+			}
+			effectiveIdx++
 		}
 
 		if n.Removed {
@@ -69,10 +78,14 @@ func BuildPlan(nodes []modifyview.ModifyBranchNode) []Action {
 			if n.PendingAction.Type == modifyview.ActionRename {
 				action.NewName = n.PendingAction.NewName
 			}
+			if n.PendingAction.Type == modifyview.ActionInsertBelow || n.PendingAction.Type == modifyview.ActionInsertAbove {
+				action.NewName = n.PendingAction.NewName
+				action.NewPosition = i
+			}
 			plan = append(plan, action)
 		}
 
-		if n.OriginalPosition != i && n.PendingAction == nil {
+		if !n.IsInserted && n.OriginalPosition != i && n.PendingAction == nil {
 			plan = append(plan, Action{
 				Type:        "move",
 				Branch:      n.Ref.Branch,
@@ -216,7 +229,116 @@ func ApplyPlan(
 		}
 	}
 
-	// Step 2: Folds — absorb one branch's commits into an adjacent branch.
+	// Step 2: Inserts — create new branches and add to stack metadata.
+	// Process in order so positions are stable. The node's position in the
+	// non-removed list determines the parent branch.
+	for _, n := range nodes {
+		if n.PendingAction == nil {
+			continue
+		}
+		if n.PendingAction.Type != modifyview.ActionInsertBelow && n.PendingAction.Type != modifyview.ActionInsertAbove {
+			continue
+		}
+
+		newName := n.PendingAction.NewName
+
+		// Determine the parent branch: find the position of this node among
+		// the non-removed, non-merged nodes in the apply-order list, then
+		// look at the branch just before it (toward trunk).
+		var parentBranch string
+		insertPos := -1
+
+		// Build the active branch order from the stack (as of now, after renames)
+		activeIdx := 0
+		for _, b := range s.Branches {
+			if b.IsMerged() {
+				continue
+			}
+			if b.Branch == newName {
+				// already added in a previous iteration — skip
+				break
+			}
+			activeIdx++
+		}
+
+		// Determine where in s.Branches the new branch should go.
+		// Walk the non-removed nodes to find the relative position.
+		nonRemovedPos := 0
+		for _, other := range nodes {
+			if other.Removed || other.Ref.IsMerged() {
+				continue
+			}
+			if other.Ref.Branch == newName {
+				insertPos = nonRemovedPos
+				break
+			}
+			nonRemovedPos++
+		}
+
+		if insertPos <= 0 {
+			parentBranch = s.Trunk.Branch
+		} else {
+			// Find the branch at insertPos-1 among active branches
+			activeCount := 0
+			for _, b := range s.Branches {
+				if b.IsMerged() {
+					continue
+				}
+				if activeCount == insertPos-1 {
+					parentBranch = b.Branch
+					break
+				}
+				activeCount++
+			}
+			if parentBranch == "" {
+				parentBranch = s.Trunk.Branch
+			}
+		}
+
+		// Create the git branch at the parent's tip
+		if err := git.CreateBranch(newName, parentBranch); err != nil {
+			unwindErr := Unwind(cfg, gitDir, snapshot, stackIndex, sf, plan)
+			if unwindErr != nil {
+				return nil, nil, fmt.Errorf("creating branch %s failed (%v) and unwind failed (%v)", newName, err, unwindErr)
+			}
+			return nil, nil, fmt.Errorf("creating branch %s from %s: %w", newName, parentBranch, err)
+		}
+
+		// Insert BranchRef into s.Branches at the correct position
+		newRef := stack.BranchRef{Branch: newName}
+		targetIdx := len(s.Branches) // default: append at end
+		if insertPos >= 0 {
+			// Map the active position back to s.Branches index
+			activeCount := 0
+			for j, b := range s.Branches {
+				if b.IsMerged() {
+					continue
+				}
+				if activeCount == insertPos {
+					targetIdx = j
+					break
+				}
+				activeCount++
+			}
+		}
+		s.Branches = append(s.Branches, stack.BranchRef{})
+		copy(s.Branches[targetIdx+1:], s.Branches[targetIdx:])
+		s.Branches[targetIdx] = newRef
+
+		// Check if the branch above the insertion point has a PR —
+		// its base changes, so we need a submit
+		if targetIdx < len(s.Branches)-1 {
+			above := s.Branches[targetIdx+1]
+			if above.PullRequest != nil {
+				affectsPRs = true
+			}
+		}
+
+		result.InsertedBranches = append(result.InsertedBranches, newName)
+		cfg.Successf("Inserted %s after %s", newName, parentBranch)
+	}
+
+	// Step 3: Folds — absorb one branch's commits into an adjacent branch.
 	//
 	// Fold-down: cherry-pick the folded branch's commits onto the target below.
 	//   The target is below in the stack (closer to trunk), so it doesn't
@@ -347,7 +469,7 @@ func ApplyPlan(
 		}
 	}
 
-	// Step 3: Drops — remove from stack metadata
+	// Step 4: Drops — remove from stack metadata
 	// Process in reverse order to preserve indices
 	for i := len(nodes) - 1; i >= 0; i-- {
 		n := nodes[i]
@@ -373,7 +495,7 @@ func ApplyPlan(
 		cfg.Successf("Dropped %s from stack", dropBranch)
 	}
 
-	// Step 4: Reorder — build the desired branch order from the remaining nodes
+	// Step 5: Reorder — build the desired branch order from the remaining nodes
 	desiredOrder := make([]string, 0)
 	for _, n := range nodes {
 		if n.Removed {
@@ -439,7 +561,7 @@ func ApplyPlan(
 		s.Branches = newBranches
 	}
 
-	// Step 5: Cascading rebase — rebase each active branch onto its new parent.
+	// Step 6: Cascading rebase — rebase each active branch onto its new parent.
 	// Use the original parent tip SHA as the oldBase for --onto, so that only
 	// the branch's own commits are replayed onto the new parent.
 	for i, b := range s.Branches {