fix: handle empty git ref when fixing compact review jobs (#327)

I think this likely gets us to  a fix for #323 

## Summary

- Compact jobs are stored with an empty `git_ref` (only a display label
is stored). Attempting to fix a compact review would pass `""` to
`worktree.Create`, causing `create worktree: ref must not be empty`.
- The fix job handler now resolves the ref via: explicit request
override → parent job's `git_ref` → parent job's branch → `HEAD` (with a
log warning).
- When the TUI detects no git ref and no branch (the HEAD fallback
case), it shows a new confirmation modal (`tuiViewFixGitRef`) pre-filled
with `"HEAD"` so the user can verify or correct the target before
proceeding.

## Test plan

- [ ] Fix a compact review job from the TUI — should no longer fail with
`create worktree: ref must not be empty`
- [ ] When compact job has a branch set, fix proceeds normally using
that branch as the ref
- [ ] When compact job has neither git ref nor branch, the new git ref
modal appears pre-filled with `HEAD`, allowing the user to edit before
confirming
- [ ] `go test ./...` passes

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

---------

Co-authored-by: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Wes McKinney <wesmckinn+git@gmail.com>

Author: 3 people

cmd/roborev/tui.go

@@ -112,6 +112,7 @@ const (
 	tuiViewLog
 	tuiViewTasks     // Background fix tasks view
 	tuiViewFixPrompt // Fix prompt confirmation modal
+	tuiViewFixGitRef // Git ref confirmation modal (HEAD fallback for compact jobs)
 	tuiViewPatch     // Patch viewer for fix jobs
 )
 
@@ -271,6 +272,7 @@ type tuiModel struct {
 	fixPromptText     string              // Editable fix prompt text
 	fixPromptJobID    int64               // Parent job ID for fix prompt modal
 	fixPromptFromView tuiView             // View to return to after fix prompt closes
+	fixPromptGitRef   string              // Editable git ref for HEAD-fallback confirmation
 	fixShowHelp       bool                // Show help overlay in tasks view
 	patchText         string              // Current patch text for patch viewer
 	patchScroll       int                 // Scroll offset in patch viewer
@@ -2417,6 +2419,9 @@ func (m tuiModel) View() string {
 	if m.currentView == tuiViewFixPrompt {
 		return m.renderFixPromptView()
 	}
+	if m.currentView == tuiViewFixGitRef {
+		return m.renderFixGitRefView()
+	}
 	if m.currentView == tuiViewPatch {
 		return m.renderPatchView()
 	}
@@ -3925,6 +3930,30 @@ func (m tuiModel) renderFixPromptView() string {
 	return b.String()
 }
 
+// renderFixGitRefView renders the git ref confirmation modal shown when a fix job
+// cannot determine the target ref automatically (e.g. compact jobs with no branch).
+func (m tuiModel) renderFixGitRefView() string {
+	var b strings.Builder
+
+	b.WriteString(tuiTitleStyle.Render(fmt.Sprintf("Fix Review #%d", m.fixPromptJobID)))
+	b.WriteString("\x1b[K\n\n")
+
+	b.WriteString("  Could not determine the target branch for this review.\n")
+	b.WriteString("  Enter a branch name or commit SHA to apply the fix against:\n\n")
+
+	refDisplay := m.fixPromptGitRef
+	if refDisplay == "" {
+		refDisplay = "HEAD"
+	}
+	fmt.Fprintf(&b, "  > %s_\n", refDisplay)
+	b.WriteString("\n")
+
+	b.WriteString(tuiHelpStyle.Render("enter: confirm | esc: cancel"))
+	b.WriteString("\x1b[K\x1b[J")
+
+	return b.String()
+}
+
 // fetchJobByID fetches a single job by ID from the daemon API.
 func (m tuiModel) fetchJobByID(jobID int64) (*storage.ReviewJob, error) {
 	var result struct {
@@ -3966,14 +3995,17 @@ func (m tuiModel) fetchFixJobs() tea.Cmd {
 }
 
 // triggerFix triggers a background fix job for a parent review.
-func (m tuiModel) triggerFix(parentJobID int64, prompt string) tea.Cmd {
+func (m tuiModel) triggerFix(parentJobID int64, prompt, gitRef string) tea.Cmd {
 	return func() tea.Msg {
 		req := map[string]any{
 			"parent_job_id": parentJobID,
 		}
 		if prompt != "" {
 			req["prompt"] = prompt
 		}
+		if gitRef != "" {
+			req["git_ref"] = gitRef
+		}
 		var job storage.ReviewJob
 		err := m.postJSON("/api/job/fix", req, &job)
 		if err != nil {

cmd/roborev/tui_handlers.go

@@ -23,6 +23,8 @@ func (m tuiModel) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		return m.handleFilterKey(msg)
 	case tuiViewLog:
 		return m.handleLogKey(msg)
+	case tuiViewFixGitRef:
+		return m.handleFixGitRefKey(msg)
 	case tuiViewFixPrompt:
 		return m.handleFixPromptKey(msg)
 	case tuiViewTasks:
@@ -1478,11 +1480,20 @@ func (m tuiModel) handleFixKey() (tea.Model, tea.Cmd) {
 		return m, nil
 	}
 
-	// Open fix prompt modal
+	// Open fix prompt modal. For compact/task jobs with no git ref and no branch,
+	// show the git ref confirmation step first so the user can specify a target.
 	m.fixPromptJobID = job.ID
-	m.fixPromptText = "" // Empty means use default prompt from server
+	m.fixPromptText = ""
 	m.fixPromptFromView = m.currentView
-	m.currentView = tuiViewFixPrompt
+	m.fixPromptGitRef = ""
+	isRange := strings.Contains(job.GitRef, "..")
+	if (job.GitRef == "" || isRange) && job.Branch == "" {
+		// No usable single ref — ask the user to confirm or correct the target.
+		m.fixPromptGitRef = "HEAD"
+		m.currentView = tuiViewFixGitRef
+	} else {
+		m.currentView = tuiViewFixPrompt
+	}
 	return m, nil
 }
 
@@ -1499,6 +1510,46 @@ func (m tuiModel) handleToggleTasksKey() (tea.Model, tea.Cmd) {
 	return m, nil
 }
 
+// handleFixGitRefKey handles key input in the git ref confirmation modal.
+// This modal is shown when fixing a compact job that has no branch information,
+// so the user can specify (or confirm) the target ref before proceeding.
+func (m tuiModel) handleFixGitRefKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "ctrl+c":
+		return m, tea.Quit
+	case "esc":
+		m.currentView = m.fixPromptFromView
+		m.fixPromptGitRef = ""
+		m.fixPromptJobID = 0
+		return m, nil
+	case "enter":
+		if strings.TrimSpace(m.fixPromptGitRef) == "" {
+			m.flashMessage = "Git ref is required"
+			m.flashExpiresAt = time.Now().Add(2 * time.Second)
+			m.flashView = tuiViewFixGitRef
+			return m, nil
+		}
+		// Move on to the fix instructions prompt with the ref confirmed.
+		m.currentView = tuiViewFixPrompt
+		return m, nil
+	case "backspace":
+		if len(m.fixPromptGitRef) > 0 {
+			runes := []rune(m.fixPromptGitRef)
+			m.fixPromptGitRef = string(runes[:len(runes)-1])
+		}
+		return m, nil
+	default:
+		if len(msg.Runes) > 0 {
+			for _, r := range msg.Runes {
+				if unicode.IsPrint(r) {
+					m.fixPromptGitRef += string(r)
+				}
+			}
+		}
+		return m, nil
+	}
+}
+
 // handleFixPromptKey handles key input in the fix prompt confirmation modal.
 func (m tuiModel) handleFixPromptKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	switch msg.String() {
@@ -1507,15 +1558,18 @@ func (m tuiModel) handleFixPromptKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	case "esc":
 		m.currentView = m.fixPromptFromView
 		m.fixPromptText = ""
+		m.fixPromptGitRef = ""
 		m.fixPromptJobID = 0
 		return m, nil
 	case "enter":
 		jobID := m.fixPromptJobID
 		prompt := m.fixPromptText
+		gitRef := m.fixPromptGitRef
 		m.currentView = tuiViewTasks
 		m.fixPromptText = ""
+		m.fixPromptGitRef = ""
 		m.fixPromptJobID = 0
-		return m, m.triggerFix(jobID, prompt)
+		return m, m.triggerFix(jobID, prompt, gitRef)
 	case "backspace":
 		if len(m.fixPromptText) > 0 {
 			runes := []rune(m.fixPromptText)

cmd/roborev/tui_review_test.go

@@ -3151,4 +3151,63 @@ func TestTUILogNavFromTasks(t *testing.T) {
 	}
 }
 
+func TestTUIFixGitRefRejectsEmpty(t *testing.T) {
+	// Pressing Enter with an empty git ref should show a flash
+	// message and stay on the git ref modal.
+	m := newTuiModel("http://localhost")
+	m.currentView = tuiViewFixGitRef
+	m.fixPromptJobID = 1
+	m.fixPromptGitRef = ""
+	m.fixPromptFromView = tuiViewQueue
+
+	m2, _ := pressSpecial(m, tea.KeyEnter)
+
+	if m2.currentView != tuiViewFixGitRef {
+		t.Errorf(
+			"should stay on git ref view, got %d",
+			m2.currentView,
+		)
+	}
+	if m2.flashMessage == "" {
+		t.Error("expected flash message for empty ref")
+	}
+}
+
+func TestTUIFixGitRefRejectsWhitespaceOnly(t *testing.T) {
+	m := newTuiModel("http://localhost")
+	m.currentView = tuiViewFixGitRef
+	m.fixPromptJobID = 1
+	m.fixPromptGitRef = "   "
+	m.fixPromptFromView = tuiViewQueue
+
+	m2, _ := pressSpecial(m, tea.KeyEnter)
+
+	if m2.currentView != tuiViewFixGitRef {
+		t.Errorf(
+			"should stay on git ref view for whitespace-only, got %d",
+			m2.currentView,
+		)
+	}
+	if m2.flashMessage == "" {
+		t.Error("expected flash message for whitespace-only ref")
+	}
+}
+
+func TestTUIFixGitRefAcceptsNonEmpty(t *testing.T) {
+	m := newTuiModel("http://localhost")
+	m.currentView = tuiViewFixGitRef
+	m.fixPromptJobID = 1
+	m.fixPromptGitRef = "main"
+	m.fixPromptFromView = tuiViewQueue
+
+	m2, _ := pressSpecial(m, tea.KeyEnter)
+
+	if m2.currentView != tuiViewFixPrompt {
+		t.Errorf(
+			"should transition to fix prompt, got %d",
+			m2.currentView,
+		)
+	}
+}
+
 // Branch filter tests

internal/daemon/server.go

@@ -1871,6 +1871,7 @@ func (s *Server) handleFixJob(w http.ResponseWriter, r *http.Request) {
 	var req struct {
 		ParentJobID int64  `json:"parent_job_id"`
 		Prompt      string `json:"prompt,omitempty"`       // Optional custom prompt override
+		GitRef      string `json:"git_ref,omitempty"`      // Optional: explicit ref for worktree (user-confirmed for compact jobs)
 		StaleJobID  int64  `json:"stale_job_id,omitempty"` // Optional: server looks up patch from this job for rebase
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
@@ -1951,10 +1952,34 @@ func (s *Server) handleFixJob(w http.ResponseWriter, r *http.Request) {
 	}
 	model := config.ResolveModelForWorkflow("", parentJob.RepoPath, cfg, "fix", reasoning)
 
+	// Normalize and validate user-provided git ref to prevent option
+	// injection (e.g. " --something") when passed to git worktree add.
+	req.GitRef = strings.TrimSpace(req.GitRef)
+	if req.GitRef != "" && !isValidGitRef(req.GitRef) {
+		writeError(w, http.StatusBadRequest, "invalid git_ref")
+		return
+	}
+
+	// Resolve the git ref for the fix worktree.
+	// Range refs (sha..sha) and empty refs (compact jobs) are not valid for
+	// git worktree add, so fall back to branch then "HEAD".
+	// An explicit git_ref from the request (user-confirmed via TUI) takes precedence.
+	fixGitRef := req.GitRef
+	if fixGitRef == "" && !strings.Contains(parentJob.GitRef, "..") {
+		fixGitRef = parentJob.GitRef
+	}
+	if fixGitRef == "" {
+		fixGitRef = parentJob.Branch
+	}
+	if fixGitRef == "" {
+		fixGitRef = "HEAD"
+		log.Printf("fix job for parent %d: no git ref or branch available, falling back to HEAD", req.ParentJobID)
+	}
+
 	// Enqueue the fix job
 	job, err := s.db.EnqueueJob(storage.EnqueueOpts{
 		RepoID:      parentJob.RepoID,
-		GitRef:      parentJob.GitRef,
+		GitRef:      fixGitRef,
 		Branch:      parentJob.Branch,
 		Agent:       agentName,
 		Model:       model,
@@ -1973,6 +1998,21 @@ func (s *Server) handleFixJob(w http.ResponseWriter, r *http.Request) {
 	writeJSONWithStatus(w, http.StatusCreated, job)
 }
 
+// isValidGitRef checks that a user-provided git ref is safe to pass
+// to git commands. Rejects empty strings, leading dashes (option
+// injection), and control characters.
+func isValidGitRef(ref string) bool {
+	if ref == "" || ref[0] == '-' {
+		return false
+	}
+	for _, r := range ref {
+		if r < 0x20 || r == 0x7f {
+			return false
+		}
+	}
+	return true
+}
+
 // handleGetPatch returns the stored patch for a completed fix job.
 func (s *Server) handleGetPatch(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {