Add TUI mutation actions with SDK-first lifecycle management

Wire action keys (c/u/x/X/D) in TUI detail view to execute lifecycle
mutations with spinner feedback and confirmation prompts. Push lifecycle
domain logic (permissions, labels, transitions) down to commons SDK so
TUI is a thin presentation layer.

SDK additions (commons/lifecycle.go):
- CanPerformTransition: actor permission checking for all transitions
- TransitionLabel/TransitionName: human-readable labels
- TransitionRequiresInput: identifies done/accept as CLI-only actions
- AvailableTransitions: combined status + permission filtering

SDK additions (commons/queries.go):
- ValidStatuses/ValidTypes: browse filter cycles
- StatusLabel/TypeLabel: display helpers
- BrowseWantedBranchAware: PR-mode branch overlay in one call
- QueryFullDetail: item + completion + stamp in one call

TUI changes:
- Detail view: confirming → executing → result state machine
- Wild-west mode: y/n confirmation before push to upstream
- PR mode: skip confirmation, use per-item branches
- Branch-aware detail/browse: read from mutation branches in PR mode
- Action hints filtered by permission and status validity

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

Author: julianknutsen

cmd/wl/cmd_tui.go

@@ -6,6 +6,7 @@ import (
 
 	bubbletea "github.com/charmbracelet/bubbletea"
 	"github.com/julianknutsen/wasteland/internal/commons"
+	"github.com/julianknutsen/wasteland/internal/federation"
 	"github.com/julianknutsen/wasteland/internal/style"
 	"github.com/julianknutsen/wasteland/internal/tui"
 	"github.com/spf13/cobra"
@@ -41,12 +42,22 @@ func runTUI(cmd *cobra.Command, _, stderr io.Writer) error {
 		return fmt.Errorf("pulling upstream: %w", err)
 	}
 
+	// PR mode: force-push main to origin so it matches upstream.
+	// Only the per-item mutation branches should differ.
+	if cfg.ResolveMode() == federation.ModePR {
+		if err := commons.PushOriginMain(cfg.LocalDir, io.Discard); err != nil {
+			fmt.Fprintf(stderr, "  warning: could not sync origin/main: %v\n", err)
+		}
+	}
+
 	upstream := cfg.Upstream
 
 	m := tui.New(tui.Config{
 		DBDir:     cfg.LocalDir,
 		RigHandle: cfg.RigHandle,
 		Upstream:  upstream,
+		Mode:      cfg.ResolveMode(),
+		Signing:   cfg.Signing,
 	})
 
 	p := bubbletea.NewProgram(m, bubbletea.WithAltScreen())

internal/commons/lifecycle.go

@@ -126,3 +126,92 @@ func ResolvePushTarget(mode string, loc *ItemLocation) PushTarget {
 func PushOriginMain(dbDir string, stdout io.Writer) error {
 	return PushBranchToRemoteForce(dbDir, "origin", "main", true, stdout)
 }
+
+// CanPerformTransition checks whether actor can perform transition t on item.
+func CanPerformTransition(item *WantedItem, t Transition, actor string) bool {
+	if item == nil {
+		return false
+	}
+	switch t {
+	case TransitionClaim:
+		return true // any rig can claim
+	case TransitionUnclaim:
+		return item.ClaimedBy == actor || item.PostedBy == actor
+	case TransitionDone:
+		return item.ClaimedBy == actor
+	case TransitionAccept:
+		return item.PostedBy == actor && item.ClaimedBy != actor
+	case TransitionReject:
+		return item.PostedBy == actor
+	case TransitionClose:
+		return item.PostedBy == actor
+	case TransitionDelete:
+		return true // any rig can delete
+	default:
+		return false
+	}
+}
+
+// TransitionLabel returns a human-readable in-progress label for a transition.
+func TransitionLabel(t Transition) string {
+	switch t {
+	case TransitionClaim:
+		return "Claiming..."
+	case TransitionUnclaim:
+		return "Unclaiming..."
+	case TransitionReject:
+		return "Rejecting..."
+	case TransitionClose:
+		return "Closing..."
+	case TransitionDelete:
+		return "Deleting..."
+	default:
+		return "Working..."
+	}
+}
+
+// TransitionName returns the short name for a transition (e.g. "claim").
+func TransitionName(t Transition) string {
+	if rule, ok := transitionRules[t]; ok {
+		return rule.name
+	}
+	return "unknown"
+}
+
+// TransitionRequiresInput returns a non-empty hint if a transition requires
+// additional input that can't be gathered in the TUI (must use CLI).
+func TransitionRequiresInput(t Transition) string {
+	switch t {
+	case TransitionDone:
+		return "requires evidence URL"
+	case TransitionAccept:
+		return "requires quality rating"
+	default:
+		return ""
+	}
+}
+
+// AvailableTransitions returns transitions valid for item that actor can perform.
+func AvailableTransitions(item *WantedItem, actor string) []Transition {
+	if item == nil {
+		return nil
+	}
+	all := []Transition{
+		TransitionClaim,
+		TransitionUnclaim,
+		TransitionDone,
+		TransitionAccept,
+		TransitionReject,
+		TransitionClose,
+		TransitionDelete,
+	}
+	var result []Transition
+	for _, t := range all {
+		if _, err := ValidateTransition(item.Status, t); err == nil {
+			if CanPerformTransition(item, t, actor) {
+				result = append(result, t)
+			}
+		}
+	}
+	return result
+}

internal/commons/lifecycle_test.go

@@ -65,6 +65,139 @@ func TestValidateTransition(t *testing.T) {
 	}
 }
 
+func TestCanPerformTransition(t *testing.T) {
+	item := &WantedItem{
+		ID:        "w-test",
+		Status:    "claimed",
+		PostedBy:  "poster",
+		ClaimedBy: "claimer",
+	}
+
+	tests := []struct {
+		name  string
+		t     Transition
+		actor string
+		want  bool
+	}{
+		{"claim anyone", TransitionClaim, "random", true},
+		{"unclaim by claimer", TransitionUnclaim, "claimer", true},
+		{"unclaim by poster", TransitionUnclaim, "poster", true},
+		{"unclaim by other", TransitionUnclaim, "other", false},
+		{"done by claimer", TransitionDone, "claimer", true},
+		{"done by other", TransitionDone, "other", false},
+		{"delete anyone", TransitionDelete, "random", true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := CanPerformTransition(item, tc.t, tc.actor)
+			if got != tc.want {
+				t.Errorf("got %v, want %v", got, tc.want)
+			}
+		})
+	}
+
+	// nil item always returns false.
+	if CanPerformTransition(nil, TransitionClaim, "x") {
+		t.Error("nil item should return false")
+	}
+}
+
+func TestCanPerformTransition_Accept(t *testing.T) {
+	item := &WantedItem{
+		ID:        "w-test",
+		Status:    "in_review",
+		PostedBy:  "poster",
+		ClaimedBy: "claimer",
+	}
+
+	// Poster (non-claimer) can accept.
+	if !CanPerformTransition(item, TransitionAccept, "poster") {
+		t.Error("poster should be able to accept")
+	}
+	// Claimer cannot accept own work.
+	if CanPerformTransition(item, TransitionAccept, "claimer") {
+		t.Error("claimer should not be able to accept own work")
+	}
+	// Random cannot accept.
+	if CanPerformTransition(item, TransitionAccept, "random") {
+		t.Error("random should not be able to accept")
+	}
+}
+
+func TestTransitionLabel(t *testing.T) {
+	tests := []struct {
+		t    Transition
+		want string
+	}{
+		{TransitionClaim, "Claiming..."},
+		{TransitionUnclaim, "Unclaiming..."},
+		{TransitionReject, "Rejecting..."},
+		{TransitionClose, "Closing..."},
+		{TransitionDelete, "Deleting..."},
+	}
+	for _, tc := range tests {
+		if got := TransitionLabel(tc.t); got != tc.want {
+			t.Errorf("TransitionLabel(%v) = %q, want %q", tc.t, got, tc.want)
+		}
+	}
+	// Unknown transition returns "Working..."
+	if got := TransitionLabel(Transition(99)); got != "Working..." {
+		t.Errorf("unknown transition label = %q, want %q", got, "Working...")
+	}
+}
+
+func TestTransitionName(t *testing.T) {
+	if got := TransitionName(TransitionClaim); got != "claim" {
+		t.Errorf("got %q, want %q", got, "claim")
+	}
+	if got := TransitionName(Transition(99)); got != "unknown" {
+		t.Errorf("got %q, want %q", got, "unknown")
+	}
+}
+
+func TestTransitionRequiresInput(t *testing.T) {
+	if got := TransitionRequiresInput(TransitionDone); got == "" {
+		t.Error("done should require input")
+	}
+	if got := TransitionRequiresInput(TransitionAccept); got == "" {
+		t.Error("accept should require input")
+	}
+	if got := TransitionRequiresInput(TransitionClaim); got != "" {
+		t.Errorf("claim should not require input, got %q", got)
+	}
+}
+
+func TestAvailableTransitions(t *testing.T) {
+	// Open item, poster is "poster", actor is "random".
+	item := &WantedItem{
+		ID:       "w-test",
+		Status:   "open",
+		PostedBy: "poster",
+	}
+
+	// Random can claim and delete.
+	got := AvailableTransitions(item, "random")
+	if len(got) != 2 {
+		t.Fatalf("expected 2 transitions, got %d: %v", len(got), got)
+	}
+	if got[0] != TransitionClaim || got[1] != TransitionDelete {
+		t.Errorf("expected [claim, delete], got %v", got)
+	}
+
+	// Poster can also close/delete open items — but close is only from in_review.
+	// So poster still only gets claim + delete from open.
+	got = AvailableTransitions(item, "poster")
+	if len(got) != 2 {
+		t.Fatalf("expected 2 transitions for poster on open, got %d: %v", len(got), got)
+	}
+
+	// nil item returns nil.
+	if AvailableTransitions(nil, "x") != nil {
+		t.Error("nil item should return nil")
+	}
+}
+
 func TestResolvePushTarget_WildWest(t *testing.T) {
 	loc := &ItemLocation{
 		LocalStatus:    "claimed",