Pre-release fixes: agent fallback, prompts with diffs, race conditions

- Add actual diffs to review prompts (agents can now see code changes)
- Add 250KB size limit for prompts, falls back to git hashes for large diffs
- Fix job claiming race condition with atomic UPDATE+subquery
- Fix codex temp file collision using os.CreateTemp
- Fix roborevd -config flag being ignored
- Fix CLI commands to use runtime file for daemon port detection
- Add automatic agent fallback (codex <-> claude-code)
- Display short refs (7 chars) in CLI and TUI
- Simplify database schema (remove migration machinery)
- Update README with agent fallback documentation

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: wesm

README.md

@@ -86,14 +86,39 @@ The daemon starts automatically when needed and handles port conflicts by findin
 
 ## Agents
 
+roborev supports multiple AI review agents:
+
 - `codex` - OpenAI Codex CLI
 - `claude-code` - Anthropic Claude Code CLI
 
-Agent selection priority:
-1. `--agent` flag on enqueue
+### Automatic Fallback
+
+roborev automatically detects which agents are installed and falls back gracefully:
+
+- If `codex` is requested but not installed, roborev uses `claude` instead
+- If `claude-code` is requested but not installed, roborev uses `codex` instead
+- If neither is installed, the job fails with a helpful error message
+
+### Explicit Agent Selection
+
+To use a specific agent for a repository, create `.roborev.toml` in the repo root:
+
+```toml
+agent = "claude-code"
+```
+
+Or set a global default in `~/.roborev/config.toml`:
+
+```toml
+default_agent = "claude-code"
+```
+
+### Selection Priority
+
+1. `--agent` flag on enqueue command
 2. Per-repo `.roborev.toml`
-3. Global config
-4. Default: `codex`
+3. Global `~/.roborev/config.toml`
+4. Automatic detection (uses first available: codex, claude-code)
 
 ## Commands
 

cmd/roborev/main.go

@@ -355,9 +355,10 @@ func statusCmd() *cobra.Command {
 		Use:   "status",
 		Short: "Show daemon and queue status",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			// Check if daemon is running
+			// Check if daemon is running (use runtime file to find actual port)
+			addr := getDaemonAddr()
 			client := &http.Client{Timeout: 2 * time.Second}
-			resp, err := client.Get(serverAddr + "/api/status")
+			resp, err := client.Get(addr + "/api/status")
 			if err != nil {
 				fmt.Println("Daemon: not running")
 				fmt.Println()
@@ -378,7 +379,7 @@ func statusCmd() *cobra.Command {
 			fmt.Println()
 
 			// Get recent jobs
-			resp, err = client.Get(serverAddr + "/api/jobs?limit=10")
+			resp, err = client.Get(addr + "/api/jobs?limit=10")
 			if err != nil {
 				return nil
 			}
@@ -433,8 +434,9 @@ func showCmd() *cobra.Command {
 				}
 			}
 
+			addr := getDaemonAddr()
 			client := &http.Client{Timeout: 5 * time.Second}
-			resp, err := client.Get(serverAddr + "/api/review?sha=" + sha)
+			resp, err := client.Get(addr + "/api/review?sha=" + sha)
 			if err != nil {
 				return fmt.Errorf("failed to connect to daemon (is it running?)")
 			}
@@ -524,7 +526,8 @@ func respondCmd() *cobra.Command {
 				"response":  message,
 			})
 
-			resp, err := http.Post(serverAddr+"/api/respond", "application/json", bytes.NewReader(reqBody))
+			addr := getDaemonAddr()
+			resp, err := http.Post(addr+"/api/respond", "application/json", bytes.NewReader(reqBody))
 			if err != nil {
 				return fmt.Errorf("failed to connect to daemon: %w", err)
 			}

cmd/roborev/tui.go

@@ -316,10 +316,7 @@ func (m tuiModel) renderQueueView() string {
 }
 
 func (m tuiModel) renderJobLine(job storage.ReviewJob) string {
-	ref := job.GitRef
-	if len(ref) > 17 {
-		ref = ref[:17]
-	}
+	ref := shortRef(job.GitRef)
 
 	repo := job.RepoName
 	if len(repo) > 15 {
@@ -406,10 +403,7 @@ func (m tuiModel) renderReviewView() string {
 
 	review := m.currentReview
 	if review.Job != nil {
-		ref := review.Job.GitRef
-		if len(ref) > 17 {
-			ref = ref[:17]
-		}
+		ref := shortRef(review.Job.GitRef)
 		title := fmt.Sprintf("Review: %s (%s)", ref, review.Agent)
 		b.WriteString(tuiTitleStyle.Render(title))
 	} else {

cmd/roborevd/main.go

@@ -24,8 +24,8 @@ func main() {
 	log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
 	log.Println("Starting roborevd...")
 
-	// Load configuration
-	cfg, err := config.LoadGlobal()
+	// Load configuration from specified path
+	cfg, err := config.LoadGlobalFrom(*configPath)
 	if err != nil {
 		log.Printf("Warning: failed to load config from %s: %v", *configPath, err)
 		cfg = config.DefaultConfig()

internal/agent/agent.go

@@ -3,6 +3,7 @@ package agent
 import (
 	"context"
 	"fmt"
+	"os/exec"
 )
 
 // Agent defines the interface for code review agents
@@ -14,6 +15,13 @@ type Agent interface {
 	Review(ctx context.Context, repoPath, commitSHA, prompt string) (output string, err error)
 }
 
+// CommandAgent is an agent that uses an external command
+type CommandAgent interface {
+	Agent
+	// CommandName returns the executable command name
+	CommandName() string
+}
+
 // Registry holds available agents
 var registry = make(map[string]Agent)
 
@@ -39,3 +47,51 @@ func Available() []string {
 	}
 	return names
 }
+
+// IsAvailable checks if an agent's command is installed on the system
+func IsAvailable(name string) bool {
+	a, ok := registry[name]
+	if !ok {
+		return false
+	}
+
+	// Check if agent implements CommandAgent interface
+	if ca, ok := a.(CommandAgent); ok {
+		_, err := exec.LookPath(ca.CommandName())
+		return err == nil
+	}
+
+	// Non-command agents (like test) are always available
+	return true
+}
+
+// GetAvailable returns an available agent, trying the requested one first,
+// then falling back to alternatives. Returns error only if no agents available.
+func GetAvailable(preferred string) (Agent, error) {
+	// Try preferred agent first
+	if preferred != "" && IsAvailable(preferred) {
+		return Get(preferred)
+	}
+
+	// Fallback order: codex, claude-code
+	fallbacks := []string{"codex", "claude-code"}
+	for _, name := range fallbacks {
+		if name != preferred && IsAvailable(name) {
+			return Get(name)
+		}
+	}
+
+	// List what's actually available for error message
+	var available []string
+	for name := range registry {
+		if IsAvailable(name) {
+			available = append(available, name)
+		}
+	}
+
+	if len(available) == 0 {
+		return nil, fmt.Errorf("no agents available (install codex or claude)")
+	}
+
+	return Get(available[0])
+}

internal/agent/claude.go

@@ -24,6 +24,10 @@ func (a *ClaudeAgent) Name() string {
 	return "claude-code"
 }
 
+func (a *ClaudeAgent) CommandName() string {
+	return a.Command
+}
+
 func (a *ClaudeAgent) Review(ctx context.Context, repoPath, commitSHA, prompt string) (string, error) {
 	// Use claude CLI in print mode (non-interactive)
 	// --print outputs the response without the interactive TUI

internal/agent/codex.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
-	"path/filepath"
 )
 
 // CodexAgent runs code reviews using the Codex CLI
@@ -26,10 +25,18 @@ func (a *CodexAgent) Name() string {
 	return "codex"
 }
 
+func (a *CodexAgent) CommandName() string {
+	return a.Command
+}
+
 func (a *CodexAgent) Review(ctx context.Context, repoPath, commitSHA, prompt string) (string, error) {
-	// Create temp file for output
-	tmpDir := os.TempDir()
-	outputFile := filepath.Join(tmpDir, fmt.Sprintf("roborev-%s.txt", commitSHA[:8]))
+	// Create unique temp file for output
+	tmpFile, err := os.CreateTemp("", "roborev-*.txt")
+	if err != nil {
+		return "", fmt.Errorf("create temp file: %w", err)
+	}
+	outputFile := tmpFile.Name()
+	tmpFile.Close()
 	defer os.Remove(outputFile)
 
 	// Use codex exec with output capture

internal/config/config.go

@@ -43,11 +43,15 @@ func GlobalConfigPath() string {
 	return filepath.Join(home, ".roborev", "config.toml")
 }
 
-// LoadGlobal loads the global configuration, using defaults for missing values
+// LoadGlobal loads the global configuration from the default path
 func LoadGlobal() (*Config, error) {
+	return LoadGlobalFrom(GlobalConfigPath())
+}
+
+// LoadGlobalFrom loads the global configuration from a specific path
+func LoadGlobalFrom(path string) (*Config, error) {
 	cfg := DefaultConfig()
 
-	path := GlobalConfigPath()
 	if _, err := os.Stat(path); os.IsNotExist(err) {
 		return cfg, nil
 	}

internal/daemon/worker.go

@@ -109,25 +109,31 @@ func (wp *WorkerPool) processJob(workerID string, job *storage.ReviewJob) {
 		return
 	}
 
-	// Get the agent
-	a, err := agent.Get(job.Agent)
+	// Get the agent (falls back to available agent if preferred not installed)
+	a, err := agent.GetAvailable(job.Agent)
 	if err != nil {
-		log.Printf("[%s] Error getting agent %s: %v", workerID, job.Agent, err)
+		log.Printf("[%s] Error getting agent: %v", workerID, err)
 		wp.db.FailJob(job.ID, fmt.Sprintf("get agent: %v", err))
 		return
 	}
 
+	// Use the actual agent name (may differ from requested if fallback occurred)
+	agentName := a.Name()
+	if agentName != job.Agent {
+		log.Printf("[%s] Agent %s not available, using %s", workerID, job.Agent, agentName)
+	}
+
 	// Run the review
-	log.Printf("[%s] Running %s review...", workerID, job.Agent)
+	log.Printf("[%s] Running %s review...", workerID, agentName)
 	output, err := a.Review(ctx, job.RepoPath, job.GitRef, reviewPrompt)
 	if err != nil {
 		log.Printf("[%s] Agent error: %v", workerID, err)
 		wp.db.FailJob(job.ID, fmt.Sprintf("agent: %v", err))
 		return
 	}
 
-	// Store the result
-	if err := wp.db.CompleteJob(job.ID, job.Agent, reviewPrompt, output); err != nil {
+	// Store the result (use actual agent name, not requested)
+	if err := wp.db.CompleteJob(job.ID, agentName, reviewPrompt, output); err != nil {
 		log.Printf("[%s] Error storing review: %v", workerID, err)
 		return
 	}

internal/prompt/prompt.go

@@ -8,6 +8,10 @@ import (
 	"github.com/wesm/roborev/internal/storage"
 )
 
+// MaxPromptSize is the maximum size of a prompt in bytes (250KB)
+// If the prompt with diffs exceeds this, we fall back to just commit info
+const MaxPromptSize = 250 * 1024
+
 // SystemPromptSingle is the base instruction for single commit reviews
 const SystemPromptSingle = `You are a code reviewer. Review the git commit shown below for:
 
@@ -102,8 +106,43 @@ func (b *Builder) buildSinglePrompt(repoPath, sha string, repoID int64, contextC
 	if len(shortSHA) > 7 {
 		shortSHA = shortSHA[:7]
 	}
+
+	// Get commit info
+	info, err := git.GetCommitInfo(repoPath, sha)
+	if err != nil {
+		return "", fmt.Errorf("get commit info: %w", err)
+	}
+
 	sb.WriteString("## Current Commit\n\n")
-	sb.WriteString(fmt.Sprintf("Review the following commit: %s\n", shortSHA))
+	sb.WriteString(fmt.Sprintf("**Commit:** %s\n", shortSHA))
+	sb.WriteString(fmt.Sprintf("**Author:** %s\n", info.Author))
+	sb.WriteString(fmt.Sprintf("**Subject:** %s\n\n", info.Subject))
+
+	// Get and include the diff
+	diff, err := git.GetDiff(repoPath, sha)
+	if err != nil {
+		return "", fmt.Errorf("get diff: %w", err)
+	}
+
+	// Build diff section
+	var diffSection strings.Builder
+	diffSection.WriteString("### Diff\n\n")
+	diffSection.WriteString("```diff\n")
+	diffSection.WriteString(diff)
+	if !strings.HasSuffix(diff, "\n") {
+		diffSection.WriteString("\n")
+	}
+	diffSection.WriteString("```\n")
+
+	// Check if adding the diff would exceed max prompt size
+	if sb.Len()+diffSection.Len() > MaxPromptSize {
+		// Fall back to just commit info without diff
+		sb.WriteString("### Diff\n\n")
+		sb.WriteString("(Diff too large to include - please review the commit directly)\n")
+		sb.WriteString(fmt.Sprintf("View with: git show %s\n", sha))
+	} else {
+		sb.WriteString(diffSection.String())
+	}
 
 	return sb.String(), nil
 }
@@ -151,6 +190,32 @@ func (b *Builder) buildRangePrompt(repoPath, rangeRef string, repoID int64, cont
 	}
 	sb.WriteString("\n")
 
+	// Get and include the combined diff for the range
+	diff, err := git.GetRangeDiff(repoPath, rangeRef)
+	if err != nil {
+		return "", fmt.Errorf("get range diff: %w", err)
+	}
+
+	// Build diff section
+	var diffSection strings.Builder
+	diffSection.WriteString("### Combined Diff\n\n")
+	diffSection.WriteString("```diff\n")
+	diffSection.WriteString(diff)
+	if !strings.HasSuffix(diff, "\n") {
+		diffSection.WriteString("\n")
+	}
+	diffSection.WriteString("```\n")
+
+	// Check if adding the diff would exceed max prompt size
+	if sb.Len()+diffSection.Len() > MaxPromptSize {
+		// Fall back to just commit info without diff
+		sb.WriteString("### Combined Diff\n\n")
+		sb.WriteString("(Diff too large to include - please review the commits directly)\n")
+		sb.WriteString(fmt.Sprintf("View with: git diff %s\n", rangeRef))
+	} else {
+		sb.WriteString(diffSection.String())
+	}
+
 	return sb.String(), nil
 }