feat: add reasoning effort support for Codex models

- Add ReasoningEffortSelector component for UI selection
- Integrate reasoning effort in feature creation/editing dialogs
- Add reasoning effort support to phase model selector
- Update agent service and board actions to handle reasoning effort
- Add reasoning effort fields to feature and settings types
- Update model selector and agent info panel with reasoning effort display
- Enhance agent context parser for reasoning effort processing

Reasoning effort allows fine-tuned control over Codex model reasoning
capabilities, providing options from 'none' to 'xhigh' for different
task complexity requirements.

apps/ui/src/components/views/board-view/dialogs/add-feature-dialog.tsx

@@ -41,9 +41,12 @@ import {
   PlanningMode,
   Feature,
 } from '@/store/app-store';
+import type { ReasoningEffort } from '@automaker/types';
+import { codexModelHasThinking, supportsReasoningEffort } from '@automaker/types';
 import {
   ModelSelector,
   ThinkingLevelSelector,
+  ReasoningEffortSelector,
   ProfileQuickSelect,
   TestingTabContent,
   PrioritySelector,
@@ -78,6 +81,7 @@ type FeatureData = {
   skipTests: boolean;
   model: AgentModel;
   thinkingLevel: ThinkingLevel;
+  reasoningEffort: ReasoningEffort;
   branchName: string; // Can be empty string to use current branch
   priority: number;
   planningMode: PlanningMode;
@@ -134,6 +138,7 @@ export function AddFeatureDialog({
     skipTests: false,
     model: 'opus' as ModelAlias,
     thinkingLevel: 'none' as ThinkingLevel,
+    reasoningEffort: 'none' as ReasoningEffort,
     branchName: '',
     priority: 2 as number, // Default to medium priority
   });
@@ -220,6 +225,9 @@ export function AddFeatureDialog({
     const normalizedThinking = modelSupportsThinking(selectedModel)
       ? newFeature.thinkingLevel
       : 'none';
+    const normalizedReasoning = supportsReasoningEffort(selectedModel)
+      ? newFeature.reasoningEffort
+      : 'none';
 
     // Use current branch if toggle is on
     // If currentBranch is provided (non-primary worktree), use it
@@ -260,6 +268,7 @@ export function AddFeatureDialog({
       skipTests: newFeature.skipTests,
       model: selectedModel,
       thinkingLevel: normalizedThinking,
+      reasoningEffort: normalizedReasoning,
       branchName: finalBranchName,
       priority: newFeature.priority,
       planningMode,
@@ -281,6 +290,7 @@ export function AddFeatureDialog({
       model: 'opus',
       priority: 2,
       thinkingLevel: 'none',
+      reasoningEffort: 'none',
       branchName: '',
     });
     setUseCurrentBranch(true);
@@ -394,6 +404,9 @@ export function AddFeatureDialog({
   const newModelAllowsThinking =
     !isCurrentModelCursor && modelSupportsThinking(newFeature.model || 'sonnet');
 
+  // Codex models that support reasoning effort - show reasoning selector
+  const newModelAllowsReasoning = supportsReasoningEffort(newFeature.model || '');
+
   return (
     <Dialog open={open} onOpenChange={handleDialogClose}>
       <DialogContent
@@ -619,6 +632,14 @@ export function AddFeatureDialog({
                     }
                   />
                 )}
+                {newModelAllowsReasoning && (
+                  <ReasoningEffortSelector
+                    selectedEffort={newFeature.reasoningEffort}
+                    onEffortSelect={(effort) =>
+                      setNewFeature({ ...newFeature, reasoningEffort: effort })
+                    }
+                  />
+                )}
               </>
             )}
           </TabsContent>

apps/ui/src/components/views/board-view/dialogs/edit-feature-dialog.tsx

@@ -41,9 +41,11 @@ import {
   useAppStore,
   PlanningMode,
 } from '@/store/app-store';
+import type { ReasoningEffort } from '@automaker/types';
 import {
   ModelSelector,
   ThinkingLevelSelector,
+  ReasoningEffortSelector,
   ProfileQuickSelect,
   TestingTabContent,
   PrioritySelector,
@@ -60,7 +62,7 @@ import {
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
 import type { DescriptionHistoryEntry } from '@automaker/types';
 import { DependencyTreeDialog } from './dependency-tree-dialog';
-import { isCursorModel, PROVIDER_PREFIXES } from '@automaker/types';
+import { isCursorModel, PROVIDER_PREFIXES, supportsReasoningEffort } from '@automaker/types';
 
 const logger = createLogger('EditFeatureDialog');
 
@@ -76,6 +78,7 @@ interface EditFeatureDialogProps {
       skipTests: boolean;
       model: ModelAlias;
       thinkingLevel: ThinkingLevel;
+      reasoningEffort: ReasoningEffort;
       imagePaths: DescriptionImagePath[];
       textFilePaths: DescriptionTextFilePath[];
       branchName: string; // Can be empty string to use current branch
@@ -180,6 +183,9 @@ export function EditFeatureDialog({
     const normalizedThinking: ThinkingLevel = modelSupportsThinking(selectedModel)
       ? (editingFeature.thinkingLevel ?? 'none')
       : 'none';
+    const normalizedReasoning: ReasoningEffort = supportsReasoningEffort(selectedModel)
+      ? (editingFeature.reasoningEffort ?? 'none')
+      : 'none';
 
     // Use current branch if toggle is on
     // If currentBranch is provided (non-primary worktree), use it
@@ -195,6 +201,7 @@ export function EditFeatureDialog({
       skipTests: editingFeature.skipTests ?? false,
       model: selectedModel,
       thinkingLevel: normalizedThinking,
+      reasoningEffort: normalizedReasoning,
       imagePaths: editingFeature.imagePaths ?? [],
       textFilePaths: editingFeature.textFilePaths ?? [],
       branchName: finalBranchName,
@@ -233,15 +240,17 @@ export function EditFeatureDialog({
     if (!editingFeature) return;
     // For Cursor models, thinking is handled by the model itself
     // For Claude models, check if it supports extended thinking
+    // For Codex models, use reasoning effort instead
     const isCursor = isCursorModel(model);
+    const supportsThinking = modelSupportsThinking(model);
+    const supportsReasoning = supportsReasoningEffort(model);
+
     setEditingFeature({
       ...editingFeature,
       model: model as ModelAlias,
-      thinkingLevel: isCursor
-        ? 'none'
-        : modelSupportsThinking(model)
-          ? editingFeature.thinkingLevel
-          : 'none',
+      thinkingLevel:
+        isCursor || !supportsThinking ? 'none' : (editingFeature.thinkingLevel ?? 'none'),
+      reasoningEffort: !supportsReasoning ? 'none' : (editingFeature.reasoningEffort ?? 'none'),
     });
   };
 
@@ -312,6 +321,9 @@ export function EditFeatureDialog({
   const editModelAllowsThinking =
     !isCurrentModelCursor && modelSupportsThinking(editingFeature?.model);
 
+  // Codex models that support reasoning effort - show reasoning selector
+  const editModelAllowsReasoning = supportsReasoningEffort(editingFeature?.model || '');
+
   if (!editingFeature) {
     return null;
   }
@@ -634,6 +646,18 @@ export function EditFeatureDialog({
                     testIdPrefix="edit-thinking-level"
                   />
                 )}
+                {editModelAllowsReasoning && (
+                  <ReasoningEffortSelector
+                    selectedEffort={editingFeature.reasoningEffort ?? 'none'}
+                    onEffortSelect={(effort) =>
+                      setEditingFeature({
+                        ...editingFeature,
+                        reasoningEffort: effort,
+                      })
+                    }
+                    testIdPrefix="edit-reasoning-effort"
+                  />
+                )}
               </>
             )}
           </TabsContent>