Honor global reasoning defaults

.gitignore

@@ -46,3 +46,4 @@ REPORT.md
 # Dolt database files (added by bd init)
 .dolt/
 *.db
+.codex

cmd/roborev/analyze.go

@@ -747,7 +747,7 @@ func runFixAgent(cmd *cobra.Command, repoPath, agentName, model, reasoning, prom
 	}
 
 	// Resolve reasoning level (defaults to "standard" for fix)
-	reasoning, reasonErr := config.ResolveFixReasoning(reasoning, repoPath)
+	reasoning, reasonErr := config.ResolveFixReasoning(reasoning, repoPath, cfg)
 	if reasonErr != nil {
 		return fmt.Errorf("resolve fix reasoning: %w", reasonErr)
 	}

cmd/roborev/compact.go

@@ -224,7 +224,7 @@ func enqueueConsolidation(ctx context.Context, cmd *cobra.Command, repoRoot stri
 	if err != nil {
 		return 0, fmt.Errorf("load config: %w", err)
 	}
-	reasoning, err := config.ResolveFixReasoning(opts.reasoning, repoRoot)
+	reasoning, err := config.ResolveFixReasoning(opts.reasoning, repoRoot, cfg)
 	if err != nil {
 		return 0, fmt.Errorf("resolve reasoning: %w", err)
 	}

cmd/roborev/fix.go

@@ -319,7 +319,7 @@ func resolveFixAgent(repoPath string, opts fixOptions) (agent.Agent, error) {
 		return nil, fmt.Errorf("load config: %w", err)
 	}
 
-	reasoning, err := config.ResolveFixReasoning(opts.reasoning, repoPath)
+	reasoning, err := config.ResolveFixReasoning(opts.reasoning, repoPath, cfg)
 	if err != nil {
 		return nil, fmt.Errorf("resolve fix reasoning: %w", err)
 	}

cmd/roborev/main_test.go

@@ -222,6 +222,32 @@ func TestRunRefineSurfacesResponseErrors(t *testing.T) {
 	require.Error(t, err, "expected error, got nil")
 }
 
+func TestRunRefineFailsOnInvalidGlobalConfigBeforeDaemonStartup(t *testing.T) {
+	repoDir, _ := setupRefineRepo(t)
+
+	dataDir := t.TempDir()
+	t.Setenv("ROBOREV_DATA_DIR", dataDir)
+	configPath := filepath.Join(dataDir, "config.toml")
+	err := os.WriteFile(configPath, []byte("invalid toml [[["),
+		0o644)
+	require.NoError(t, err, "write invalid config: %v", err)
+
+	origGetAnyRunningDaemon := getAnyRunningDaemon
+	getAnyRunningDaemon = func() (*daemon.RuntimeInfo, error) {
+		require.FailNow(t, "ensureDaemon should not run when global config is invalid")
+		return nil, ErrDaemonNotRunning
+	}
+	t.Cleanup(func() {
+		getAnyRunningDaemon = origGetAnyRunningDaemon
+	})
+
+	ctx := newFastRunContext(repoDir)
+
+	err = runRefine(ctx, refineOptions{agentName: "test", maxIterations: 1, quiet: true})
+	require.Error(t, err, "expected config load error")
+	assert.Contains(t, err.Error(), "load config:")
+}
+
 func TestRunRefineQuietNonTTYTimerOutput(t *testing.T) {
 	repoDir, headSHA := setupRefineRepo(t)
 

cmd/roborev/refine.go

@@ -321,6 +321,11 @@ func runRefine(ctx RunContext, opts refineOptions) error {
 		return err
 	}
 
+	cfg, err := config.LoadGlobal()
+	if err != nil {
+		return fmt.Errorf("load config: %w", err)
+	}
+
 	// 2. Connect to daemon (only after all validation passes)
 	if err := ensureDaemon(); err != nil {
 		return fmt.Errorf("daemon not running: %w", err)
@@ -348,8 +353,7 @@ func runRefine(ctx RunContext, opts refineOptions) error {
 	}
 
 	// Resolve reasoning level from CLI or config (default: standard for refine)
-	cfg, _ := config.LoadGlobal()
-	resolvedReasoning, err := config.ResolveRefineReasoning(opts.reasoning, repoPath)
+	resolvedReasoning, err := config.ResolveRefineReasoning(opts.reasoning, repoPath, cfg)
 	if err != nil {
 		return err
 	}

cmd/roborev/review.go

@@ -373,7 +373,7 @@ func runLocalReview(cmd *cobra.Command, repoPath, gitRef, diffContent, agentName
 	}
 
 	// Resolve and validate reasoning (matches daemon behavior)
-	reasoning, err = config.ResolveReviewReasoning(reasoning, repoPath)
+	reasoning, err = config.ResolveReviewReasoning(reasoning, repoPath, cfg)
 	if err != nil {
 		return fmt.Errorf("invalid reasoning: %w", err)
 	}

internal/config/config.go

@@ -60,6 +60,9 @@ type Config struct {
 	DefaultBackupAgent         string `toml:"default_backup_agent"`
 	DefaultBackupModel         string `toml:"default_backup_model"`
 	JobTimeoutMinutes          int    `toml:"job_timeout_minutes"`
+	ReviewReasoning            string `toml:"review_reasoning" comment:"Default reasoning level for reviews: fast, standard, medium, thorough, or maximum."`
+	RefineReasoning            string `toml:"refine_reasoning" comment:"Default reasoning level for refine: fast, standard, medium, thorough, or maximum."`
+	FixReasoning               string `toml:"fix_reasoning" comment:"Default reasoning level for fix: fast, standard, medium, thorough, or maximum."`
 
 	// Workflow-specific agent/model configuration
 	ReviewAgent           string `toml:"review_agent"`
@@ -1399,44 +1402,68 @@ func SeverityInstruction(minSeverity string) string {
 }
 
 // ResolveReviewReasoning determines reasoning level for reviews.
-// Priority: explicit > per-repo config > default (thorough)
-func ResolveReviewReasoning(explicit string, repoPath string) (string, error) {
+// Priority: explicit > per-repo config > global config > default (thorough)
+func ResolveReviewReasoning(explicit string, repoPath string, globalCfg *Config) (string, error) {
 	if strings.TrimSpace(explicit) != "" {
 		return NormalizeReasoning(explicit)
 	}
 
-	if repoCfg, err := LoadRepoConfig(repoPath); err == nil && repoCfg != nil && strings.TrimSpace(repoCfg.ReviewReasoning) != "" {
+	repoCfg, err := LoadRepoConfig(repoPath)
+	if err != nil {
+		return "", err
+	}
+	if repoCfg != nil && strings.TrimSpace(repoCfg.ReviewReasoning) != "" {
 		return NormalizeReasoning(repoCfg.ReviewReasoning)
 	}
 
+	if globalCfg != nil && strings.TrimSpace(globalCfg.ReviewReasoning) != "" {
+		return NormalizeReasoning(globalCfg.ReviewReasoning)
+	}
+
 	return "thorough", nil // Default for reviews: deep analysis
 }
 
 // ResolveRefineReasoning determines reasoning level for refine.
-// Priority: explicit > per-repo config > default (standard)
-func ResolveRefineReasoning(explicit string, repoPath string) (string, error) {
+// Priority: explicit > per-repo config > global config > default (standard)
+func ResolveRefineReasoning(explicit string, repoPath string, globalCfg *Config) (string, error) {
 	if strings.TrimSpace(explicit) != "" {
 		return NormalizeReasoning(explicit)
 	}
 
-	if repoCfg, err := LoadRepoConfig(repoPath); err == nil && repoCfg != nil && strings.TrimSpace(repoCfg.RefineReasoning) != "" {
+	repoCfg, err := LoadRepoConfig(repoPath)
+	if err != nil {
+		return "", err
+	}
+	if repoCfg != nil && strings.TrimSpace(repoCfg.RefineReasoning) != "" {
 		return NormalizeReasoning(repoCfg.RefineReasoning)
 	}
 
+	if globalCfg != nil && strings.TrimSpace(globalCfg.RefineReasoning) != "" {
+		return NormalizeReasoning(globalCfg.RefineReasoning)
+	}
+
 	return "standard", nil // Default for refine: balanced analysis
 }
 
 // ResolveFixReasoning determines reasoning level for fix.
-// Priority: explicit > per-repo config > default (standard)
-func ResolveFixReasoning(explicit string, repoPath string) (string, error) {
+// Priority: explicit > per-repo config > global config > default (standard)
+func ResolveFixReasoning(explicit string, repoPath string, globalCfg *Config) (string, error) {
 	if strings.TrimSpace(explicit) != "" {
 		return NormalizeReasoning(explicit)
 	}
 
-	if repoCfg, err := LoadRepoConfig(repoPath); err == nil && repoCfg != nil && strings.TrimSpace(repoCfg.FixReasoning) != "" {
+	repoCfg, err := LoadRepoConfig(repoPath)
+	if err != nil {
+		return "", err
+	}
+	if repoCfg != nil && strings.TrimSpace(repoCfg.FixReasoning) != "" {
 		return NormalizeReasoning(repoCfg.FixReasoning)
 	}
 
+	if globalCfg != nil && strings.TrimSpace(globalCfg.FixReasoning) != "" {
+		return NormalizeReasoning(globalCfg.FixReasoning)
+	}
+
 	return "standard", nil // Default for fix: balanced analysis
 }
 

internal/config/config_test.go

@@ -348,29 +348,50 @@ func TestResolveJobTimeout(t *testing.T) {
 }
 
 func TestResolveReasoning(t *testing.T) {
-	type resolverFunc func(explicit string, dir string) (string, error)
+	type resolverFunc func(explicit string, dir string, globalCfg *Config) (string, error)
 
 	runTests := func(t *testing.T, name string, fn resolverFunc, configKey, defaultVal, repoVal string) {
 		t.Run(name, func(t *testing.T) {
 			tests := []struct {
-				testName   string
-				explicit   string
-				repoConfig string
-				want       string
-				wantErr    bool
+				testName     string
+				explicit     string
+				repoConfig   string
+				globalConfig string
+				want         string
+				wantErr      bool
 			}{
-				{"default when no config", "", "", defaultVal, false},
-				{"repo config when explicit empty", "", fmt.Sprintf(`%s = "%s"`, configKey, repoVal), repoVal, false},
-				{"explicit overrides repo config", "fast", fmt.Sprintf(`%s = "%s"`, configKey, repoVal), "fast", false},
-				{"explicit normalization", "FAST", "", "fast", false},
-				{"invalid explicit", "unknown", "", "", true},
-				{"invalid repo config", "", fmt.Sprintf(`%s = "invalid"`, configKey), "", true},
+				{"default when no config", "", "", "", defaultVal, false},
+				{"global config when explicit and repo empty", "", "", fmt.Sprintf(`%s = "%s"`, configKey, repoVal), repoVal, false},
+				{"repo config when explicit empty", "", fmt.Sprintf(`%s = "%s"`, configKey, repoVal), "", repoVal, false},
+				{"repo config overrides global config", "", fmt.Sprintf(`%s = "%s"`, configKey, repoVal), fmt.Sprintf(`%s = "%s"`, configKey, defaultVal), repoVal, false},
+				{"explicit overrides repo config", "fast", fmt.Sprintf(`%s = "%s"`, configKey, repoVal), fmt.Sprintf(`%s = "%s"`, configKey, defaultVal), "fast", false},
+				{"explicit normalization", "FAST", "", "", "fast", false},
+				{"invalid explicit", "unknown", "", "", "", true},
+				{"invalid repo config", "", fmt.Sprintf(`%s = "invalid"`, configKey), "", "", true},
+				{"malformed repo config does not fall back to global", "", fmt.Sprintf(`%s = [`, configKey), fmt.Sprintf(`%s = "%s"`, configKey, repoVal), "", true},
+				{"invalid global config", "", "", fmt.Sprintf(`%s = "invalid"`, configKey), "", true},
 			}
 
 			for _, tt := range tests {
 				t.Run(tt.testName, func(t *testing.T) {
+					dataDir := t.TempDir()
+					t.Setenv("ROBOREV_DATA_DIR", dataDir)
+					if tt.globalConfig != "" {
+						err := os.WriteFile(
+							filepath.Join(dataDir, "config.toml"),
+							[]byte(tt.globalConfig),
+							0o644,
+						)
+						require.NoError(t, err)
+					}
+					var globalCfg *Config
+					if tt.globalConfig != "" {
+						cfg, loadErr := LoadGlobalFrom(filepath.Join(dataDir, "config.toml"))
+						require.NoError(t, loadErr)
+						globalCfg = cfg
+					}
 					tmpDir := newTempRepo(t, tt.repoConfig)
-					got, err := fn(tt.explicit, tmpDir)
+					got, err := fn(tt.explicit, tmpDir, globalCfg)
 					if (err != nil) != tt.wantErr {
 						assert.Condition(t, func() bool {
 							return false
@@ -401,7 +422,7 @@ func TestFixEmptyReasoningSelectsStandardAgent(t *testing.T) {
 		"fix_agent_fast":     "gemini",
 	})
 
-	reasoning, err := ResolveFixReasoning("", tmpDir)
+	reasoning, err := ResolveFixReasoning("", tmpDir, nil)
 	require.Condition(t, func() bool {
 		return err == nil
 	}, "ResolveFixReasoning: %v", err)

internal/daemon/server.go

@@ -859,15 +859,16 @@ func (s *Server) handleEnqueue(w http.ResponseWriter, r *http.Request) {
 	}
 
 	workflow := workflowForJob(req.JobType, req.ReviewType)
+	cfg := s.configWatcher.Config()
 
 	// Resolve reasoning level for the determined workflow.
 	// Compact jobs use fix reasoning (default "standard"), not review
 	// reasoning (default "thorough").
 	var reasoning string
 	if workflow == "fix" {
-		reasoning, err = config.ResolveFixReasoning(req.Reasoning, repoRoot)
+		reasoning, err = config.ResolveFixReasoning(req.Reasoning, repoRoot, cfg)
 	} else {
-		reasoning, err = config.ResolveReviewReasoning(req.Reasoning, repoRoot)
+		reasoning, err = config.ResolveReviewReasoning(req.Reasoning, repoRoot, cfg)
 	}
 	if err != nil {
 		writeError(w, http.StatusBadRequest, err.Error())
@@ -878,7 +879,6 @@ func (s *Server) handleEnqueue(w http.ResponseWriter, r *http.Request) {
 	requestedProvider := strings.TrimSpace(req.Provider)
 
 	// Resolve agent for workflow at this reasoning level
-	cfg := s.configWatcher.Config()
 	resolution := agent.ResolveWorkflowConfig(
 		req.Agent, repoRoot, cfg, workflow, reasoning,
 	)

internal/daemon/server_jobs_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/roborev-dev/roborev/internal/config"
 	gitpkg "github.com/roborev-dev/roborev/internal/git"
 	"github.com/roborev-dev/roborev/internal/storage"
+	"github.com/roborev-dev/roborev/internal/testenv"
 	"github.com/roborev-dev/roborev/internal/testutil"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -2693,6 +2694,50 @@ func TestHandleEnqueueCompactReasoning(t *testing.T) {
 	}
 }
 
+func TestHandleEnqueueUsesConfiguredReviewReasoning(t *testing.T) {
+	_ = testenv.SetDataDir(t)
+
+	configPath := filepath.Join(t.TempDir(), "daemon-config.toml")
+	err := os.WriteFile(
+		configPath,
+		[]byte(`review_reasoning = "maximum"`),
+		0o644,
+	)
+	require.NoError(t, err)
+
+	repoDir := t.TempDir()
+	testutil.InitTestGitRepo(t, repoDir)
+
+	db, _ := testutil.OpenTestDBWithDir(t)
+	cfg, err := config.LoadGlobalFrom(configPath)
+	require.NoError(t, err)
+	server := NewServer(db, cfg, configPath)
+	t.Cleanup(func() {
+		require.NoError(t, server.Close())
+	})
+
+	reqData := EnqueueRequest{
+		RepoPath: repoDir,
+		GitRef:   "HEAD",
+		Agent:    "test",
+	}
+	req := testutil.MakeJSONRequest(
+		t, http.MethodPost, "/api/enqueue", reqData,
+	)
+	w := httptest.NewRecorder()
+	server.handleEnqueue(w, req)
+
+	if w.Code != http.StatusCreated {
+		require.Condition(t, func() bool {
+			return false
+		}, "expected 201, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var job storage.ReviewJob
+	testutil.DecodeJSON(t, w, &job)
+	assert.Equal(t, "maximum", job.Reasoning)
+}
+
 func TestHandleListJobsSlashNormalization(t *testing.T) {
 	server, db, tmpDir := newTestServer(t)