Fix list and fix returning no results from git worktrees (#249)

Closes #248

## Summary

- **Worktree path mismatch**: CLI commands (`list`, `fix`) used
`GetRepoRoot` (`--show-toplevel`) which returns the worktree path, but
the daemon stores jobs under `GetMainRepoRoot`. The `repo=` API filter
never matched. Now all API query paths resolve through
`GetMainRepoRoot`, while local git operations (branch detection, agent
working directory) still use the worktree-local path.
- **Null branch fallback**: `handleEnqueue` detected `currentBranch` for
exclusion checks but never used it as a fallback when `req.Branch` was
empty. Jobs from older clients or edge cases were stored with NULL
branch, making them invisible to branch-filtered queries. Now the daemon
sets `req.Branch = currentBranch` when the client omits it.
- **Explicit `--repo` normalization**: `list --repo <worktree-path>` now
normalizes the path to the main repo root, so it matches regardless of
which checkout the user points to.

## Test plan

- [x] `TestListCommand/worktree_sends_main_repo_path_as_repo_param` —
list from worktree sends main repo path
- [x]
`TestListCommand/explicit_--repo_with_worktree_path_normalizes_to_main_repo`
— explicit --repo with worktree path
- [x] `TestFixWorktreeRepoResolution/runFixList_sends_main_repo_path` —
fix --list from worktree
- [x]
`TestFixWorktreeRepoResolution/runFixUnaddressed_sends_main_repo_path` —
fix --unaddressed from worktree
- [x] `TestFixWorktreeRepoResolution/runFixBatch_sends_main_repo_path` —
fix --batch from worktree
- [x] `TestHandleEnqueueBranchFallback` — daemon fills in branch when
client omits it
- [x] Full test suite passes (`go test ./...`)

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

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: wesm

cmd/roborev/fix.go

@@ -386,7 +386,7 @@ func runFixUnaddressed(cmd *cobra.Command, branch string, newestFirst bool, opts
 	}
 
 	repoRoot := workDir
-	if root, err := git.GetRepoRoot(workDir); err == nil {
+	if root, err := git.GetMainRepoRoot(workDir); err == nil {
 		repoRoot = root
 	}
 
@@ -477,7 +477,7 @@ func runFixList(cmd *cobra.Command, branch string, newestFirst bool) error {
 		return fmt.Errorf("get working directory: %w", err)
 	}
 	repoRoot := workDir
-	if root, err := git.GetRepoRoot(workDir); err == nil {
+	if root, err := git.GetMainRepoRoot(workDir); err == nil {
 		repoRoot = root
 	}
 
@@ -707,10 +707,15 @@ func runFixBatch(cmd *cobra.Command, jobIDs []int64, branch string, newestFirst
 	if root, err := git.GetRepoRoot(workDir); err == nil {
 		repoRoot = root
 	}
+	// Use main repo root for API queries (daemon stores jobs under main repo path)
+	apiRepoRoot := repoRoot
+	if root, err := git.GetMainRepoRoot(workDir); err == nil {
+		apiRepoRoot = root
+	}
 
 	// Discover jobs if none provided
 	if len(jobIDs) == 0 {
-		jobIDs, err = queryUnaddressedJobs(repoRoot, branch)
+		jobIDs, err = queryUnaddressedJobs(apiRepoRoot, branch)
 		if err != nil {
 			return err
 		}

cmd/roborev/fix_test.go

@@ -1323,3 +1323,100 @@ func TestFixListFlagValidation(t *testing.T) {
 		})
 	}
 }
+
+// setupWorktree creates a main repo with a commit and a worktree, returning
+// the main repo and the worktree directory path.
+func setupWorktree(t *testing.T) (mainRepo *TestGitRepo, worktreeDir string) {
+	t.Helper()
+	repo := newTestGitRepo(t)
+	repo.CommitFile("file.txt", "content", "initial")
+
+	wtDir := t.TempDir()
+	os.Remove(wtDir)
+	repo.Run("worktree", "add", "-b", "wt-branch", wtDir)
+	return repo, wtDir
+}
+
+// setupWorktreeMockDaemon sets up a mock daemon that captures the repo query
+// param from /api/jobs requests, returning empty results.
+func setupWorktreeMockDaemon(t *testing.T) (receivedRepo *string) {
+	t.Helper()
+	var repo string
+	_, cleanup := setupMockDaemon(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/api/jobs" {
+			repo = r.URL.Query().Get("repo")
+			json.NewEncoder(w).Encode(map[string]interface{}{
+				"jobs":     []storage.ReviewJob{},
+				"has_more": false,
+			})
+			return
+		}
+	}))
+	t.Cleanup(cleanup)
+	return &repo
+}
+
+func TestFixWorktreeRepoResolution(t *testing.T) {
+	t.Run("runFixList sends main repo path", func(t *testing.T) {
+		receivedRepo := setupWorktreeMockDaemon(t)
+		repo, worktreeDir := setupWorktree(t)
+		chdir(t, worktreeDir)
+
+		cmd := &cobra.Command{}
+		var buf bytes.Buffer
+		cmd.SetOut(&buf)
+		if err := runFixList(cmd, "", false); err != nil {
+			t.Fatalf("runFixList: %v", err)
+		}
+
+		if *receivedRepo == "" {
+			t.Fatal("expected repo param to be sent")
+		}
+		if *receivedRepo != repo.Dir {
+			t.Errorf("expected main repo path %q, got %q", repo.Dir, *receivedRepo)
+		}
+	})
+
+	t.Run("runFixUnaddressed sends main repo path", func(t *testing.T) {
+		receivedRepo := setupWorktreeMockDaemon(t)
+		repo, worktreeDir := setupWorktree(t)
+		chdir(t, worktreeDir)
+
+		cmd := &cobra.Command{}
+		var buf bytes.Buffer
+		cmd.SetOut(&buf)
+		opts := fixOptions{quiet: true}
+		if err := runFixUnaddressed(cmd, "", false, opts); err != nil {
+			t.Fatalf("runFixUnaddressed: %v", err)
+		}
+
+		if *receivedRepo == "" {
+			t.Fatal("expected repo param to be sent")
+		}
+		if *receivedRepo != repo.Dir {
+			t.Errorf("expected main repo path %q, got %q", repo.Dir, *receivedRepo)
+		}
+	})
+
+	t.Run("runFixBatch sends main repo path", func(t *testing.T) {
+		receivedRepo := setupWorktreeMockDaemon(t)
+		repo, worktreeDir := setupWorktree(t)
+		chdir(t, worktreeDir)
+
+		cmd := &cobra.Command{}
+		var buf bytes.Buffer
+		cmd.SetOut(&buf)
+		opts := fixOptions{quiet: true}
+		// nil jobIDs triggers discovery via queryUnaddressedJobs
+		if err := runFixBatch(cmd, nil, "", false, opts); err != nil {
+			t.Fatalf("runFixBatch: %v", err)
+		}
+
+		if *receivedRepo == "" {
+			t.Fatal("expected repo param to be sent")
+		}
+		if *receivedRepo != repo.Dir {
+			t.Errorf("expected main repo path %q, got %q", repo.Dir, *receivedRepo)
+		}
+	})
+}

cmd/roborev/list_test.go

@@ -3,6 +3,8 @@ package main
 import (
 	"encoding/json"
 	"net/http"
+	"net/url"
+	"os"
 	"strings"
 	"testing"
 	"time"
@@ -311,6 +313,96 @@ func TestListCommand(t *testing.T) {
 			t.Errorf("expected branch param when --repo is a valid git repo, got: %s", receivedQuery)
 		}
 	})
+
+	t.Run("worktree sends main repo path as repo param", func(t *testing.T) {
+		var receivedQuery string
+		_, cleanup := setupMockDaemon(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/api/jobs" {
+				receivedQuery = r.URL.RawQuery
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"jobs":     []storage.ReviewJob{},
+					"has_more": false,
+				})
+				return
+			}
+		}))
+		t.Cleanup(cleanup)
+
+		// Create main repo with initial commit
+		repo := newTestGitRepo(t)
+		repo.CommitFile("file.txt", "content", "initial")
+
+		// Create a worktree
+		worktreeDir := t.TempDir()
+		// Remove the dir so git worktree add can create it
+		os.Remove(worktreeDir)
+		repo.Run("worktree", "add", "-b", "wt-branch", worktreeDir)
+
+		chdir(t, worktreeDir)
+
+		captureStdout(t, func() {
+			cmd := listCmd()
+			cmd.SetArgs([]string{})
+			if err := cmd.Execute(); err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+		})
+
+		// The repo= param should be the main repo path, not the worktree path
+		if strings.Contains(receivedQuery, url.QueryEscape(worktreeDir)) {
+			t.Errorf("expected main repo path in query, but got worktree path: %s", receivedQuery)
+		}
+		if !strings.Contains(receivedQuery, url.QueryEscape(repo.Dir)) {
+			t.Errorf("expected main repo path %q in query, got: %s", repo.Dir, receivedQuery)
+		}
+		// Branch should be the worktree's branch, not the main repo's
+		if !strings.Contains(receivedQuery, "branch=wt-branch") {
+			t.Errorf("expected branch=wt-branch in query, got: %s", receivedQuery)
+		}
+	})
+
+	t.Run("explicit --repo with worktree path normalizes to main repo", func(t *testing.T) {
+		var receivedQuery string
+		_, cleanup := setupMockDaemon(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/api/jobs" {
+				receivedQuery = r.URL.RawQuery
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"jobs":     []storage.ReviewJob{},
+					"has_more": false,
+				})
+				return
+			}
+		}))
+		t.Cleanup(cleanup)
+
+		// Create main repo with initial commit
+		repo := newTestGitRepo(t)
+		repo.CommitFile("file.txt", "content", "initial")
+
+		// Create a worktree
+		worktreeDir := t.TempDir()
+		os.Remove(worktreeDir)
+		repo.Run("worktree", "add", "-b", "wt-branch", worktreeDir)
+
+		// Don't chdir — pass the worktree path via --repo explicitly
+		chdir(t, repo.Dir)
+
+		captureStdout(t, func() {
+			cmd := listCmd()
+			cmd.SetArgs([]string{"--repo", worktreeDir})
+			if err := cmd.Execute(); err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+		})
+
+		// Even with --repo pointing to the worktree, repo= should be the main repo
+		if strings.Contains(receivedQuery, url.QueryEscape(worktreeDir)) {
+			t.Errorf("expected main repo path in query, but got worktree path: %s", receivedQuery)
+		}
+		if !strings.Contains(receivedQuery, url.QueryEscape(repo.Dir)) {
+			t.Errorf("expected main repo path %q in query, got: %s", repo.Dir, receivedQuery)
+		}
+	})
 }
 
 func TestShowJSONOutput(t *testing.T) {

cmd/roborev/main.go

@@ -1457,14 +1457,28 @@ Examples:
 			addr := getDaemonAddr()
 
 			// Auto-resolve repo from cwd when not specified.
-			if repoPath == "" {
+			// Use worktree root for branch detection, main repo root for API queries
+			// (daemon stores jobs under the main repo path).
+			localRepoPath := repoPath
+			if localRepoPath == "" {
 				if root, err := git.GetRepoRoot("."); err == nil {
+					localRepoPath = root
+				}
+			}
+			if repoPath == "" {
+				if root, err := git.GetMainRepoRoot("."); err == nil {
+					repoPath = root
+				}
+			} else {
+				// Normalize explicit --repo to main repo root so worktree
+				// paths match the daemon's stored repo path.
+				if root, err := git.GetMainRepoRoot(repoPath); err == nil {
 					repoPath = root
 				}
 			}
 			// Auto-resolve branch from the target repo when not specified.
-			if branch == "" && repoPath != "" {
-				branch = git.GetCurrentBranch(repoPath)
+			if branch == "" && localRepoPath != "" {
+				branch = git.GetCurrentBranch(localRepoPath)
 			}
 
 			// Build query URL

internal/daemon/server.go

@@ -468,6 +468,11 @@ func (s *Server) handleEnqueue(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Fall back to detected branch when client didn't send one
+	if req.Branch == "" {
+		req.Branch = currentBranch
+	}
+
 	// Resolve repo identity for sync
 	repoIdentity := config.ResolveRepoIdentity(repoRoot, nil)
 

internal/daemon/server_test.go

@@ -1903,6 +1903,47 @@ func TestHandleEnqueueExcludedBranch(t *testing.T) {
 	})
 }
 
+func TestHandleEnqueueBranchFallback(t *testing.T) {
+	server, db, tmpDir := newTestServer(t)
+
+	repoDir := filepath.Join(tmpDir, "testrepo")
+	testutil.InitTestGitRepo(t, repoDir)
+
+	// Switch to a named branch
+	branchCmd := exec.Command("git", "-C", repoDir, "checkout", "-b", "my-feature")
+	if out, err := branchCmd.CombinedOutput(); err != nil {
+		t.Fatalf("git checkout failed: %v\n%s", err, out)
+	}
+
+	// Enqueue with empty branch field
+	reqData := map[string]string{
+		"repo_path": repoDir,
+		"git_ref":   "HEAD",
+		"agent":     "test",
+	}
+	req := testutil.MakeJSONRequest(t, http.MethodPost, "/api/enqueue", reqData)
+	w := httptest.NewRecorder()
+	server.handleEnqueue(w, req)
+
+	if w.Code != http.StatusCreated {
+		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var respJob storage.ReviewJob
+	if err := json.NewDecoder(w.Body).Decode(&respJob); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+
+	// Verify the job has the detected branch, not empty
+	job, err := db.GetJobByID(respJob.ID)
+	if err != nil {
+		t.Fatalf("GetJob: %v", err)
+	}
+	if job.Branch != "my-feature" {
+		t.Errorf("expected branch %q, got %q", "my-feature", job.Branch)
+	}
+}
+
 func TestHandleEnqueueBodySizeLimit(t *testing.T) {
 	server, _, tmpDir := newTestServer(t)