Fix PR'd item retry + responsive TUI with selection and scrollable events

Fix 1: HandedOff eligibility check
- IsEligible() now checks state.HandedOff map — items with PRs are
  never re-dispatched, even if project status update fails
- HandedOff persisted to bbolt (survives restarts)
- Loaded on startup via RestoreHandoff()

Fix 2: Responsive TUI layout
- Column widths calculated dynamically from terminal width (35%/20%/fixed)
- Events panel uses remaining vertical space (adapts to terminal height)
- Agent table expands to fill available width
- Event messages use proportional widths

Fix 3: Scrollable events panel
- All events stored (up to 200 ring buffer), not just last 10
- Scroll with ↑/↓ when events panel is focused
- PgUp/PgDn for fast scrolling
- Auto-scroll to bottom on new events (unless user scrolled up)
- Shows "↑ more above" / "↓ more below" indicators

Fix 4: Agent selection + detail view
- Tab switches focus between Agents table and Events panel
- ↑/↓ navigates agent rows when agents panel focused
- Enter opens full-screen detail view for selected agent
- Detail view shows: issue, phase, session, runtime, tokens
- Detail view shows filtered events for that specific agent
- Esc returns to overview

Keyboard:
  Tab     Switch focus (agents ↔ events)
  ↑↓/jk  Navigate (context-dependent)
  Enter   Open agent detail view
  Esc     Back to overview
  PgUp/Dn Fast scroll
  q       Quit

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: shivamstaq

cmd/symphony/main.go

@@ -293,6 +293,19 @@ func main() {
 		}
 	}
 
+	// Restore handed-off items
+	handoffs, err := store.LoadHandoffs()
+	if err != nil {
+		logger.Warn("failed to load persisted handoffs", "error", err)
+	} else {
+		for _, id := range handoffs {
+			orch.RestoreHandoff(id)
+		}
+		if len(handoffs) > 0 {
+			logger.Info("restored persisted handoffs", "count", len(handoffs))
+		}
+	}
+
 	// Restore totals
 	totals, err := store.LoadTotals()
 	if err != nil {

internal/orchestrator/eligibility.go

@@ -86,13 +86,16 @@ func IsEligible(item WorkItem, cfg EligibilityConfig, state *State, maxConcurren
 		}
 	}
 
-	// Not already claimed or running
+	// Not already claimed, running, or handed off
 	if state.Claimed[item.WorkItemID] {
 		return false, "already claimed"
 	}
 	if _, running := state.Running[item.WorkItemID]; running {
 		return false, "already running"
 	}
+	if state.HandedOff != nil && state.HandedOff[item.WorkItemID] {
+		return false, "already handed off (PR created)"
+	}
 
 	// Global concurrency
 	if len(state.Running) >= maxConcurrent {

internal/orchestrator/orchestrator.go

@@ -149,6 +149,16 @@ func (o *Orchestrator) RestoreRetry(entry RetryEntry) {
 	o.state.Claimed[entry.WorkItemID] = true
 }
 
+// RestoreHandoff marks an item as handed off (from bbolt on startup).
+func (o *Orchestrator) RestoreHandoff(workItemID string) {
+	o.mu.Lock()
+	defer o.mu.Unlock()
+	if o.state.HandedOff == nil {
+		o.state.HandedOff = make(map[string]bool)
+	}
+	o.state.HandedOff[workItemID] = true
+}
+
 // RunOnce executes one poll-and-dispatch tick per spec Section 8.1:
 // 1. Reconcile running work items
 // 2. Fire due retries

internal/orchestrator/worker.go

@@ -250,6 +250,11 @@ func (r *Runner) Run(ctx context.Context, item WorkItem, attempt *int) WorkerRes
 		handoffReached = true
 		logger.Info("PR created/updated, marking as handed off")
 		r.emitEvent(item, EventHandoff, "PR created, handed off for review")
+
+		// Persist handoff to bbolt so it survives restarts
+		if r.deps.StateStore != nil {
+			_ = r.deps.StateStore.SaveHandoff(item.WorkItemID)
+		}
 	}
 
 	// 7. Run after_run hook (best-effort)

internal/state/store.go

@@ -9,10 +9,11 @@ import (
 )
 
 var (
-	bucketRetries  = []byte("retries")
-	bucketTotals   = []byte("totals")
-	bucketSessions = []byte("sessions")
-	keyTotals      = []byte("agent_totals")
+	bucketRetries   = []byte("retries")
+	bucketTotals    = []byte("totals")
+	bucketSessions  = []byte("sessions")
+	bucketHandedOff = []byte("handedoff")
+	keyTotals       = []byte("agent_totals")
 )
 
 // RetryRecord is a persistent retry entry.
@@ -58,6 +59,9 @@ func Open(path string) (*Store, error) {
 		if _, err := tx.CreateBucketIfNotExists(bucketSessions); err != nil {
 			return err
 		}
+		if _, err := tx.CreateBucketIfNotExists(bucketHandedOff); err != nil {
+			return err
+		}
 		return nil
 	})
 	if err != nil {
@@ -173,3 +177,22 @@ func (s *Store) LoadSessions() ([]SessionRecord, error) {
 	})
 	return records, err
 }
+
+// SaveHandoff persists a handed-off work item ID.
+func (s *Store) SaveHandoff(workItemID string) error {
+	return s.db.Update(func(tx *bolt.Tx) error {
+		return tx.Bucket(bucketHandedOff).Put([]byte(workItemID), []byte("1"))
+	})
+}
+
+// LoadHandoffs returns all persisted handed-off work item IDs.
+func (s *Store) LoadHandoffs() ([]string, error) {
+	var ids []string
+	err := s.db.View(func(tx *bolt.Tx) error {
+		return tx.Bucket(bucketHandedOff).ForEach(func(k, _ []byte) error {
+			ids = append(ids, string(k))
+			return nil
+		})
+	})
+	return ids, err
+}