feat(tui): add TUI improvements and crash recovery

- Max iterations: display current/max in header, adjust with +/- keys,
  dynamic default based on remaining stories
- Log viewer: compact tool display with icons and arguments,
  use full width for tool results
- Branch warning: warn when starting on main/master, offer to create
  feature branch
- Crash recovery: auto-retry on failures with configurable limits
  (3 retries with delays 0s, 5s, 15s), --no-retry flag to disable
- Remove duplicate conversion message from new/edit commands

Author: MiniCodeMonkey

cmd/chief/main.go

@@ -26,6 +26,7 @@ type TUIOptions struct {
 	Verbose       bool
 	Merge         bool
 	Force         bool
+	NoRetry       bool
 }
 
 func main() {
@@ -113,11 +114,12 @@ func listAvailablePRDs() []string {
 func parseTUIFlags() *TUIOptions {
 	opts := &TUIOptions{
 		PRDPath:       "", // Will be resolved later
-		MaxIterations: 10,
+		MaxIterations: 0,  // 0 signals dynamic calculation (remaining stories + 5)
 		NoSound:       false,
 		Verbose:       false,
 		Merge:         false,
 		Force:         false,
+		NoRetry:       false,
 	}
 
 	for i := 1; i < len(os.Args); i++ {
@@ -138,6 +140,8 @@ func parseTUIFlags() *TUIOptions {
 			opts.Merge = true
 		case arg == "--force":
 			opts.Force = true
+		case arg == "--no-retry":
+			opts.NoRetry = true
 		case arg == "--max-iterations" || arg == "-n":
 			// Next argument should be the number
 			if i+1 < len(os.Args) {
@@ -345,6 +349,11 @@ func runTUIWithOptions(opts *TUIOptions) {
 		app.SetVerbose(true)
 	}
 
+	// Disable retry if requested
+	if opts.NoRetry {
+		app.DisableRetry()
+	}
+
 	// Initialize sound notifier (unless disabled)
 	if !opts.NoSound {
 		notifier, err := notify.GetNotifier()
@@ -415,8 +424,9 @@ Commands:
   help                      Show this help message
 
 Global Options:
-  --max-iterations N, -n N  Set maximum iterations (default: 10)
+  --max-iterations N, -n N  Set maximum iterations (default: dynamic)
   --no-sound                Disable completion sound notifications
+  --no-retry                Disable auto-retry on Claude crashes
   --verbose                 Show raw Claude output in log
   --merge                   Auto-merge progress on conversion conflicts
   --force                   Auto-overwrite on conversion conflicts

internal/cmd/edit.go

@@ -59,7 +59,6 @@ func RunEdit(opts EditOptions) error {
 	fmt.Println("\nPRD editing complete!")
 
 	// Run conversion from prd.md to prd.json with progress protection
-	fmt.Println("Converting prd.md to prd.json...")
 	convertOpts := ConvertOptions{
 		PRDDir: prdDir,
 		Merge:  opts.Merge,

internal/cmd/new.go

@@ -72,7 +72,6 @@ func RunNew(opts NewOptions) error {
 	fmt.Println("\nPRD created successfully!")
 
 	// Run conversion from prd.md to prd.json
-	fmt.Println("Converting prd.md to prd.json...")
 	if err := RunConvert(prdDir); err != nil {
 		return fmt.Errorf("conversion failed: %w", err)
 	}

internal/git/git.go

@@ -0,0 +1,49 @@
+// Package git provides Git utility functions for Chief.
+package git
+
+import (
+	"os/exec"
+	"strings"
+)
+
+// GetCurrentBranch returns the current git branch name for a directory.
+func GetCurrentBranch(dir string) (string, error) {
+	cmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
+	cmd.Dir = dir
+	output, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(output)), nil
+}
+
+// IsProtectedBranch returns true if the branch name is main or master.
+func IsProtectedBranch(branch string) bool {
+	return branch == "main" || branch == "master"
+}
+
+// CreateBranch creates a new branch and switches to it.
+func CreateBranch(dir, branchName string) error {
+	cmd := exec.Command("git", "checkout", "-b", branchName)
+	cmd.Dir = dir
+	return cmd.Run()
+}
+
+// BranchExists returns true if a branch with the given name exists.
+func BranchExists(dir, branchName string) (bool, error) {
+	cmd := exec.Command("git", "rev-parse", "--verify", branchName)
+	cmd.Dir = dir
+	err := cmd.Run()
+	if err != nil {
+		// Branch doesn't exist
+		return false, nil
+	}
+	return true, nil
+}
+
+// IsGitRepo returns true if the directory is inside a git repository.
+func IsGitRepo(dir string) bool {
+	cmd := exec.Command("git", "rev-parse", "--git-dir")
+	cmd.Dir = dir
+	return cmd.Run() == nil
+}

internal/git/git_test.go

@@ -0,0 +1,25 @@
+package git
+
+import "testing"
+
+func TestIsProtectedBranch(t *testing.T) {
+	tests := []struct {
+		branch   string
+		expected bool
+	}{
+		{"main", true},
+		{"master", true},
+		{"develop", false},
+		{"feature/foo", false},
+		{"chief/my-prd", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.branch, func(t *testing.T) {
+			result := IsProtectedBranch(tt.branch)
+			if result != tt.expected {
+				t.Errorf("IsProtectedBranch(%q) = %v, want %v", tt.branch, result, tt.expected)
+			}
+		})
+	}
+}

internal/loop/loop.go

@@ -13,32 +13,51 @@ import (
 	"os/exec"
 	"path/filepath"
 	"sync"
+	"time"
 
 	"github.com/minicodemonkey/chief/embed"
 	"github.com/minicodemonkey/chief/internal/prd"
 )
 
+// RetryConfig configures automatic retry behavior on Claude crashes.
+type RetryConfig struct {
+	MaxRetries  int           // Maximum number of retry attempts (default: 3)
+	RetryDelays []time.Duration // Delays between retries (default: 0s, 5s, 15s)
+	Enabled     bool          // Whether retry is enabled (default: true)
+}
+
+// DefaultRetryConfig returns the default retry configuration.
+func DefaultRetryConfig() RetryConfig {
+	return RetryConfig{
+		MaxRetries:  3,
+		RetryDelays: []time.Duration{0, 5 * time.Second, 15 * time.Second},
+		Enabled:     true,
+	}
+}
+
 // Loop manages the core agent loop that invokes Claude repeatedly until all stories are complete.
 type Loop struct {
-	prdPath   string
-	prompt    string
-	maxIter   int
-	iteration int
-	events    chan Event
-	claudeCmd *exec.Cmd
-	logFile   *os.File
-	mu        sync.Mutex
-	stopped   bool
-	paused    bool
+	prdPath     string
+	prompt      string
+	maxIter     int
+	iteration   int
+	events      chan Event
+	claudeCmd   *exec.Cmd
+	logFile     *os.File
+	mu          sync.Mutex
+	stopped     bool
+	paused      bool
+	retryConfig RetryConfig
 }
 
 // NewLoop creates a new Loop instance.
 func NewLoop(prdPath, prompt string, maxIter int) *Loop {
 	return &Loop{
-		prdPath: prdPath,
-		prompt:  prompt,
-		maxIter: maxIter,
-		events:  make(chan Event, 100),
+		prdPath:     prdPath,
+		prompt:      prompt,
+		maxIter:     maxIter,
+		events:      make(chan Event, 100),
+		retryConfig: DefaultRetryConfig(),
 	}
 }
 
@@ -102,8 +121,8 @@ func (l *Loop) Run(ctx context.Context) error {
 			Iteration: currentIter,
 		}
 
-		// Run a single iteration
-		if err := l.runIteration(ctx); err != nil {
+		// Run a single iteration with retry logic
+		if err := l.runIterationWithRetry(ctx); err != nil {
 			l.events <- Event{
 				Type: EventError,
 				Err:  err,
@@ -146,6 +165,82 @@ func (l *Loop) Run(ctx context.Context) error {
 	}
 }
 
+// runIterationWithRetry wraps runIteration with retry logic for crash recovery.
+func (l *Loop) runIterationWithRetry(ctx context.Context) error {
+	l.mu.Lock()
+	config := l.retryConfig
+	l.mu.Unlock()
+
+	var lastErr error
+	for attempt := 0; attempt <= config.MaxRetries; attempt++ {
+		// Check if retry is enabled (except for first attempt)
+		if attempt > 0 {
+			if !config.Enabled {
+				return lastErr
+			}
+
+			// Get delay for this retry
+			delayIdx := attempt - 1
+			if delayIdx >= len(config.RetryDelays) {
+				delayIdx = len(config.RetryDelays) - 1
+			}
+			delay := config.RetryDelays[delayIdx]
+
+			// Emit retry event
+			l.mu.Lock()
+			iter := l.iteration
+			l.mu.Unlock()
+			l.events <- Event{
+				Type:       EventRetrying,
+				Iteration:  iter,
+				RetryCount: attempt,
+				RetryMax:   config.MaxRetries,
+				Text:       fmt.Sprintf("Claude crashed, retrying (%d/%d)...", attempt, config.MaxRetries),
+			}
+
+			// Wait before retry
+			if delay > 0 {
+				select {
+				case <-time.After(delay):
+				case <-ctx.Done():
+					return ctx.Err()
+				}
+			}
+		}
+
+		// Check if stopped during delay
+		l.mu.Lock()
+		if l.stopped {
+			l.mu.Unlock()
+			return nil
+		}
+		l.mu.Unlock()
+
+		// Run the iteration
+		err := l.runIteration(ctx)
+		if err == nil {
+			return nil // Success
+		}
+
+		// Check if this is a context cancellation (don't retry)
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+
+		// Check if stopped intentionally
+		l.mu.Lock()
+		stopped := l.stopped
+		l.mu.Unlock()
+		if stopped {
+			return nil
+		}
+
+		lastErr = err
+	}
+
+	return fmt.Errorf("max retries (%d) exceeded: %w", config.MaxRetries, lastErr)
+}
+
 // runIteration spawns Claude and processes its output.
 func (l *Loop) runIteration(ctx context.Context) error {
 	// Build Claude command with required flags
@@ -302,3 +397,31 @@ func (l *Loop) IsRunning() bool {
 	defer l.mu.Unlock()
 	return l.claudeCmd != nil && l.claudeCmd.Process != nil
 }
+
+// SetMaxIterations updates the maximum iterations limit.
+func (l *Loop) SetMaxIterations(maxIter int) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.maxIter = maxIter
+}
+
+// MaxIterations returns the current max iterations limit.
+func (l *Loop) MaxIterations() int {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.maxIter
+}
+
+// SetRetryConfig updates the retry configuration.
+func (l *Loop) SetRetryConfig(config RetryConfig) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.retryConfig = config
+}
+
+// DisableRetry disables automatic retry on crash.
+func (l *Loop) DisableRetry() {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.retryConfig.Enabled = false
+}

internal/loop/loop_test.go

@@ -316,3 +316,61 @@ func TestLoop_ChiefCompleteEvent(t *testing.T) {
 		t.Error("Expected Complete event for <chief-complete/>")
 	}
 }
+
+// TestLoop_SetMaxIterations tests setting max iterations at runtime.
+func TestLoop_SetMaxIterations(t *testing.T) {
+	l := NewLoop("/test/prd.json", "test", 5)
+
+	if l.MaxIterations() != 5 {
+		t.Errorf("Expected initial maxIter 5, got %d", l.MaxIterations())
+	}
+
+	l.SetMaxIterations(10)
+
+	if l.MaxIterations() != 10 {
+		t.Errorf("Expected maxIter 10 after set, got %d", l.MaxIterations())
+	}
+}
+
+// TestDefaultRetryConfig tests the default retry configuration.
+func TestDefaultRetryConfig(t *testing.T) {
+	config := DefaultRetryConfig()
+
+	if config.MaxRetries != 3 {
+		t.Errorf("Expected MaxRetries 3, got %d", config.MaxRetries)
+	}
+	if !config.Enabled {
+		t.Error("Expected Enabled to be true")
+	}
+	if len(config.RetryDelays) != 3 {
+		t.Errorf("Expected 3 retry delays, got %d", len(config.RetryDelays))
+	}
+}
+
+// TestLoop_SetRetryConfig tests setting retry config.
+func TestLoop_SetRetryConfig(t *testing.T) {
+	l := NewLoop("/test/prd.json", "test", 5)
+
+	// Check default
+	if !l.retryConfig.Enabled {
+		t.Error("Expected default retry to be enabled")
+	}
+
+	// Disable retry
+	l.DisableRetry()
+	if l.retryConfig.Enabled {
+		t.Error("Expected retry to be disabled after DisableRetry()")
+	}
+
+	// Set custom config
+	customConfig := RetryConfig{
+		MaxRetries:  5,
+		RetryDelays: []time.Duration{time.Second},
+		Enabled:     true,
+	}
+	l.SetRetryConfig(customConfig)
+
+	if l.retryConfig.MaxRetries != 5 {
+		t.Errorf("Expected MaxRetries 5, got %d", l.retryConfig.MaxRetries)
+	}
+}