Add TUI Phase 2C: pending state deltas with branch-as-transition model

Make pending state deltas a first-class TUI concept. The browse view
shows * suffix on items with active branches, and the detail view
displays a Pending line (e.g. "open → claimed") showing the delta
between main and branch status. Users can discard branches to abandon
pending changes. Apply (merge to local main) is available in wild-west
mode but suppressed in PR mode where deltas resolve via upstream PR.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: julianknutsen

internal/commons/dolt.go

@@ -234,6 +234,19 @@ func DeleteBranch(dbDir, branch string) error {
 	return doltSQLScript(dbDir, fmt.Sprintf("CALL DOLT_BRANCH('-D', '%s');", escaped))
 }
 
+// DeleteRemoteBranch deletes a branch on a named remote using refspec syntax.
+func DeleteRemoteBranch(dbDir, remote, branch string) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "dolt", "push", remote, ":"+branch)
+	cmd.Dir = dbDir
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("dolt push %s :%s: %w (%s)", remote, branch, err, strings.TrimSpace(string(output)))
+	}
+	return nil
+}
+
 // EnsureGitHubRemote adds a "github" Dolt remote pointing to the rig's
 // GitHub fork (e.g. https://github.com/alice-dev/wl-commons.git).
 // Idempotent: if "github" remote already exists, no-op.

internal/commons/lifecycle.go

@@ -191,6 +191,18 @@ func TransitionRequiresInput(t Transition) string {
 	}
 }
 
+// DeltaLabel returns a human-readable label for a state delta.
+// Single-hop deltas map to transition names: "claim", "done", "reject".
+// Multi-hop or unrecognized deltas return "changes".
+func DeltaLabel(mainStatus, branchStatus string) string {
+	for _, rule := range transitionRules {
+		if rule.from == mainStatus && rule.to == branchStatus {
+			return rule.name
+		}
+	}
+	return "changes"
+}
+
 // AvailableTransitions returns transitions valid for item that actor can perform.
 func AvailableTransitions(item *WantedItem, actor string) []Transition {
 	if item == nil {

internal/commons/lifecycle_test.go

@@ -198,6 +198,34 @@ func TestAvailableTransitions(t *testing.T) {
 	}
 }
 
+func TestDeltaLabel(t *testing.T) {
+	tests := []struct {
+		name         string
+		mainStatus   string
+		branchStatus string
+		want         string
+	}{
+		{"claim", "open", "claimed", "claim"},
+		{"unclaim", "claimed", "open", "unclaim"},
+		{"done", "claimed", "in_review", "done"},
+		{"accept", "in_review", "completed", "accept"},
+		{"reject", "in_review", "claimed", "reject"},
+		{"delete", "open", "withdrawn", "delete"},
+		{"multi-hop open to in_review", "open", "in_review", "changes"},
+		{"multi-hop open to completed", "open", "completed", "changes"},
+		{"same status", "open", "open", "update"},
+		{"unrecognized", "completed", "open", "changes"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := DeltaLabel(tc.mainStatus, tc.branchStatus)
+			if got != tc.want {
+				t.Errorf("DeltaLabel(%q, %q) = %q, want %q", tc.mainStatus, tc.branchStatus, got, tc.want)
+			}
+		})
+	}
+}
+
 func TestResolvePushTarget_WildWest(t *testing.T) {
 	loc := &ItemLocation{
 		LocalStatus:    "claimed",

internal/commons/queries.go

@@ -309,16 +309,21 @@ func QueryMyDashboard(dbDir, handle string) (*DashboardData, error) {
 }
 
 // BrowseWantedBranchAware wraps BrowseWanted with branch overlay in PR mode.
-func BrowseWantedBranchAware(dbDir, mode, rigHandle string, f BrowseFilter) ([]WantedSummary, error) {
+// Returns the items and a map of wanted IDs that have active branches.
+func BrowseWantedBranchAware(dbDir, mode, rigHandle string, f BrowseFilter) ([]WantedSummary, map[string]bool, error) {
 	items, err := BrowseWanted(dbDir, f)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
+	branchIDs := make(map[string]bool)
 	if mode == "pr" {
 		overrides := DetectBranchOverrides(dbDir, rigHandle)
+		for _, o := range overrides {
+			branchIDs[o.WantedID] = true
+		}
 		items = ApplyBranchOverrides(dbDir, items, overrides, f.Status)
 	}
-	return items, nil
+	return items, branchIDs, nil
 }
 
 // QueryFullDetail fetches a wanted item with all related records (completion, stamp).

internal/tui/browse.go

@@ -14,6 +14,7 @@ import (
 
 type browseModel struct {
 	items         []commons.WantedSummary
+	branchIDs     map[string]bool // wanted IDs with pending branch deltas
 	cursor        int
 	statusIdx     int // index into statusCycle
 	typeIdx       int // index into typeCycle
@@ -75,6 +76,7 @@ func (m *browseModel) setData(msg browseDataMsg) {
 	m.loading = false
 	m.err = msg.err
 	m.items = msg.items
+	m.branchIDs = msg.branchIDs
 	if m.cursor >= len(m.items) {
 		m.cursor = max(0, len(m.items)-1)
 	}
@@ -324,6 +326,9 @@ func (m browseModel) view() string {
 		}
 		pri := colorizePriority(item.Priority)
 		status := colorizeStatus(item.Status)
+		if m.branchIDs[item.ID] {
+			status += "*"
+		}
 		var line string
 		if wide {
 			line = fmt.Sprintf("  %-12s %-30s %-10s %-8s %-4s %-10s %-12s",

internal/tui/browse_test.go

@@ -344,3 +344,38 @@ func TestBrowseFilter_ProjectFilter_EmptyWhenUnset(t *testing.T) {
 		t.Errorf("filter Project should be empty, got %q", f.Project)
 	}
 }
+
+func TestBrowseView_BranchIndicator(t *testing.T) {
+	m := newBrowseModel()
+	m.loading = false
+	m.width = 80
+	m.height = 24
+	m.items = []commons.WantedSummary{
+		{ID: "w-abc123", Title: "Has branch", Status: "claimed", Priority: 1, Project: "proj", Type: "bug"},
+		{ID: "w-def456", Title: "No branch", Status: "open", Priority: 2, Project: "proj", Type: "bug"},
+	}
+	m.branchIDs = map[string]bool{"w-abc123": true}
+
+	v := m.view()
+	// The item with a branch should have * after its status.
+	if !strings.Contains(v, "claimed*") {
+		t.Errorf("view should contain 'claimed*' for branched item, got:\n%s", v)
+	}
+	// The item without a branch should not have *.
+	// "open" should appear without * (we check it doesn't have "open*").
+	if strings.Contains(v, "open*") {
+		t.Errorf("view should NOT contain 'open*' for non-branched item, got:\n%s", v)
+	}
+}
+
+func TestBrowseSetData_StoresBranchIDs(t *testing.T) {
+	m := newBrowseModel()
+	branchIDs := map[string]bool{"w-abc123": true}
+	m.setData(browseDataMsg{
+		items:     []commons.WantedSummary{{ID: "w-abc123", Status: "claimed"}},
+		branchIDs: branchIDs,
+	})
+	if !m.branchIDs["w-abc123"] {
+		t.Error("branchIDs should contain w-abc123")
+	}
+}

internal/tui/detail.go

@@ -17,6 +17,12 @@ type confirmAction struct {
 	label      string
 }
 
+// deltaConfirmAction holds state while waiting for the user to confirm a delta action.
+type deltaConfirmAction struct {
+	action branchDeltaAction
+	label  string
+}
+
 type detailModel struct {
 	item       *commons.WantedItem
 	completion *commons.CompletionRecord
@@ -31,10 +37,12 @@ type detailModel struct {
 	dbDir          string
 	rigHandle      string
 	mode           string
-	branch         string         // non-empty when showing branch state
-	confirming     *confirmAction // non-nil → showing confirmation prompt
-	executing      bool           // true → showing spinner
-	executingLabel string         // e.g. "Claiming..."
+	branch         string              // non-empty when showing branch state
+	mainStatus     string              // status on main when showing branch state
+	confirming     *confirmAction      // non-nil → showing confirmation prompt
+	deltaConfirm   *deltaConfirmAction // non-nil → showing delta confirmation prompt
+	executing      bool                // true → showing spinner
+	executingLabel string              // e.g. "Claiming..."
 	spinner        spinner.Model
 	result         string // brief success/error message
 }
@@ -70,8 +78,10 @@ func (m *detailModel) setData(msg detailDataMsg) {
 	m.completion = msg.completion
 	m.stamp = msg.stamp
 	m.branch = msg.branch
+	m.mainStatus = msg.mainStatus
 	// Clear mutation state so stale results don't mask action hints.
 	m.confirming = nil
+	m.deltaConfirm = nil
 	m.executing = false
 	m.executingLabel = ""
 	m.result = ""
@@ -113,6 +123,22 @@ func (m detailModel) update(msg bubbletea.Msg) (detailModel, bubbletea.Cmd) {
 			return m, nil
 		}
 
+		// Delta confirmation prompt active: handle y/n/esc only.
+		if m.deltaConfirm != nil {
+			switch {
+			case key.Matches(msg, keys.Confirm):
+				a := m.deltaConfirm.action
+				m.deltaConfirm = nil
+				return m, func() bubbletea.Msg {
+					return deltaConfirmedMsg{action: a}
+				}
+			case key.Matches(msg, keys.Cancel), key.Matches(msg, keys.Back):
+				m.deltaConfirm = nil
+				return m, nil
+			}
+			return m, nil
+		}
+
 		// Normal key handling.
 		switch {
 		case key.Matches(msg, keys.Back):
@@ -139,6 +165,12 @@ func (m detailModel) update(msg bubbletea.Msg) (detailModel, bubbletea.Cmd) {
 			return m.tryAction(commons.TransitionClose)
 		case key.Matches(msg, keys.Delete):
 			return m.tryAction(commons.TransitionDelete)
+
+		// Delta resolution keys.
+		case key.Matches(msg, keys.Apply):
+			return m.tryDelta(deltaApply)
+		case key.Matches(msg, keys.Discard):
+			return m.tryDelta(deltaDiscard)
 		}
 	}
 
@@ -187,6 +219,28 @@ func (m detailModel) tryTextAction(t commons.Transition) (detailModel, bubbletea
 	return m, nil
 }
 
+// tryDelta validates that a branch exists, computes a label, and returns a deltaRequestMsg.
+func (m detailModel) tryDelta(action branchDeltaAction) (detailModel, bubbletea.Cmd) {
+	if m.branch == "" || m.item == nil {
+		return m, nil
+	}
+	// Apply is not available in PR mode — deltas resolve via upstream PR merge.
+	if action == deltaApply && m.mode == "pr" {
+		return m, nil
+	}
+	delta := commons.DeltaLabel(m.mainStatus, m.item.Status)
+	var label string
+	switch action {
+	case deltaApply:
+		label = fmt.Sprintf("Apply %s to main? Pushes to origin. [y/n]", delta)
+	case deltaDiscard:
+		label = fmt.Sprintf("Discard %s? Reverts to %s. Deletes local + remote branch. [y/n]", delta, m.mainStatus)
+	}
+	return m, func() bubbletea.Msg {
+		return deltaRequestMsg{action: action, label: label}
+	}
+}
+
 func (m detailModel) view() string {
 	if m.loading {
 		return styleDim.Render("  Loading...")
@@ -207,6 +261,9 @@ func (m detailModel) renderContent() string {
 	var b strings.Builder
 
 	b.WriteString(fmt.Sprintf("\n  Status:      %s\n", colorizeStatus(item.Status)))
+	if m.branch != "" && m.mainStatus != "" && m.mainStatus != item.Status {
+		b.WriteString(fmt.Sprintf("  Pending:     %s → %s\n", m.mainStatus, item.Status))
+	}
 	if m.branch != "" {
 		b.WriteString(styleDim.Render(fmt.Sprintf("  Branch:      %s\n", m.branch)))
 	}
@@ -278,6 +335,8 @@ func (m detailModel) renderContent() string {
 	case m.confirming != nil:
 		b.WriteString(styleConfirm.Render(fmt.Sprintf(
 			"  %s Pushes to upstream. [y/n]", m.confirming.label)))
+	case m.deltaConfirm != nil:
+		b.WriteString(styleConfirm.Render(fmt.Sprintf("  %s", m.deltaConfirm.label)))
 	case m.executing:
 		b.WriteString(fmt.Sprintf("  %s %s", m.spinner.View(), m.executingLabel))
 	case m.result != "":
@@ -308,9 +367,6 @@ func (m detailModel) actionHints() string {
 		return ""
 	}
 	available := commons.AvailableTransitions(m.item, m.rigHandle)
-	if len(available) == 0 {
-		return "  (no actions available)"
-	}
 	var hints []string
 	for _, t := range available {
 		k := transitionKeyHint[t]
@@ -321,5 +377,24 @@ func (m detailModel) actionHints() string {
 		}
 		hints = append(hints, hint)
 	}
+
+	// Delta actions: only when a branch exists with a pending delta.
+	if m.branch != "" && m.mainStatus != "" && m.mainStatus != m.item.Status {
+		delta := commons.DeltaLabel(m.mainStatus, m.item.Status)
+		var deltaHints []string
+		if m.mode != "pr" {
+			// Apply only in wild-west mode — PR mode resolves via upstream PR.
+			deltaHints = append(deltaHints, fmt.Sprintf("M:apply %s", delta))
+		}
+		deltaHints = append(deltaHints, fmt.Sprintf("b:discard (→ %s)", m.mainStatus))
+		if len(hints) > 0 {
+			hints = append(hints, "|")
+		}
+		hints = append(hints, deltaHints...)
+	}
+
+	if len(hints) == 0 {
+		return "  (no actions available)"
+	}
 	return "  Actions: " + strings.Join(hints, "  ")
 }