diff --git a/apps/ui/src/components/views/board-view/shared/model-selector.tsx b/apps/ui/src/components/views/board-view/shared/model-selector.tsx
index 323190c8..dc95f39f 100644
--- a/apps/ui/src/components/views/board-view/shared/model-selector.tsx
+++ b/apps/ui/src/components/views/board-view/shared/model-selector.tsx
@@ -4,7 +4,6 @@ import { Badge } from '@/components/ui/badge';
 import { Brain, AlertTriangle } from 'lucide-react';
 import { AnthropicIcon, CursorIcon, OpenAIIcon } from '@/components/ui/provider-icon';
 import { cn } from '@/lib/utils';
-import type { ModelAlias } from '@/store/app-store';
 import { useAppStore } from '@/store/app-store';
 import { useSetupStore } from '@/store/setup-store';
 import { getModelProvider, PROVIDER_PREFIXES, stripProviderPrefix } from '@automaker/types';
@@ -19,6 +18,10 @@ interface ModelSelectorProps {
   testIdPrefix?: string;
 }
 
+const CODEX_EMPTY_AVAILABLE_MESSAGE = 'No Codex models available';
+const CODEX_EMPTY_ENABLED_MESSAGE =
+  'No Codex models enabled. Enable models in Settings → AI Providers.';
+
 export function ModelSelector({
   selectedModel,
   onModelSelect,
@@ -27,6 +30,8 @@ export function ModelSelector({
   const {
     enabledCursorModels,
     cursorDefaultModel,
+    enabledCodexModels,
+    codexDefaultModel,
     codexModels,
     codexModelsLoading,
     codexModelsError,
@@ -49,8 +54,10 @@ export function ModelSelector({
     }
   }, [isCodexAvailable, codexModels.length, codexModelsLoading, fetchCodexModels]);
 
+  const enabledCodexModelIds = new Set(enabledCodexModels);
+
   // Transform codex models from store to ModelOption format
-  const dynamicCodexModels: ModelOption[] = codexModels.map((model) => {
+  const codexModelOptions: ModelOption[] = codexModels.map((model) => {
     // Infer badge based on tier
     let badge: string | undefined;
     if (model.tier === 'premium') badge = 'Premium';
@@ -67,6 +74,10 @@ export function ModelSelector({
     };
   });
 
+  const enabledCodexModelOptions = codexModelOptions.filter((model) =>
+    enabledCodexModelIds.has(model.id)
+  );
+
   // Filter Cursor models based on enabled models from global settings
   const filteredCursorModels = CURSOR_MODELS.filter((model) => {
     // Extract the cursor model ID from the prefixed ID (e.g., "cursor-auto" -> "auto")
@@ -74,21 +85,36 @@ export function ModelSelector({
     return enabledCursorModels.includes(cursorModelId as any);
   });
 
+  const hasEnabledCodexModels = enabledCodexModelOptions.length > 0;
+  const codexDefaultSelection =
+    codexModelOptions.find((model) => model.id === codexDefaultModel)?.id ||
+    enabledCodexModelOptions[0]?.id ||
+    codexModelOptions[0]?.id;
+
   const handleProviderChange = (provider: ModelProvider) => {
     if (provider === 'cursor' && selectedProvider !== 'cursor') {
       // Switch to Cursor's default model (from global settings)
       onModelSelect(`${PROVIDER_PREFIXES.cursor}${cursorDefaultModel}`);
     } else if (provider === 'codex' && selectedProvider !== 'codex') {
-      // Switch to Codex's default model (use isDefault flag from dynamic models)
-      const defaultModel = codexModels.find((m) => m.isDefault);
-      const defaultModelId = defaultModel?.id || codexModels[0]?.id || 'codex-gpt-5.2-codex';
-      onModelSelect(defaultModelId);
+      // Switch to Codex's default model (from global settings)
+      if (codexDefaultSelection) {
+        onModelSelect(codexDefaultSelection);
+      }
     } else if (provider === 'claude' && selectedProvider !== 'claude') {
       // Switch to Claude's default model
       onModelSelect('sonnet');
     }
   };
 
+  const showCodexAvailableEmpty =
+    !codexModelsLoading && !codexModelsError && codexModelOptions.length === 0;
+  const showCodexEnabledEmpty =
+    !codexModelsLoading &&
+    !codexModelsError &&
+    codexModelOptions.length > 0 &&
+    !hasEnabledCodexModels;
+  const showCodexList = !codexModelsLoading && !codexModelsError && hasEnabledCodexModels;
+
   return (
     <div className="space-y-4">
       {/* Provider Selection */}
@@ -272,7 +298,7 @@ export function ModelSelector({
           </div>
 
           {/* Loading state */}
-          {codexModelsLoading && dynamicCodexModels.length === 0 && (
+          {codexModelsLoading && codexModelOptions.length === 0 && (
             <div className="flex items-center justify-center gap-2 p-6 text-sm text-muted-foreground">
               <RefreshCw className="w-4 h-4 animate-spin" />
               Loading models...
@@ -297,15 +323,21 @@ export function ModelSelector({
           )}
 
           {/* Model list */}
-          {!codexModelsLoading && !codexModelsError && dynamicCodexModels.length === 0 && (
+          {showCodexAvailableEmpty && (
             <div className="text-sm text-muted-foreground p-3 border border-dashed rounded-md text-center">
-              No Codex models available
+              {CODEX_EMPTY_AVAILABLE_MESSAGE}
             </div>
           )}
 
-          {!codexModelsLoading && dynamicCodexModels.length > 0 && (
+          {showCodexEnabledEmpty && (
+            <div className="text-sm text-muted-foreground p-3 border border-dashed rounded-md text-center">
+              {CODEX_EMPTY_ENABLED_MESSAGE}
+            </div>
+          )}
+
+          {showCodexList && (
             <div className="flex flex-col gap-2">
-              {dynamicCodexModels.map((option) => {
+              {enabledCodexModelOptions.map((option) => {
                 const isSelected = selectedModel === option.id;
                 return (
                   <button
diff --git a/apps/ui/src/components/views/settings-view/model-defaults/phase-model-selector.tsx b/apps/ui/src/components/views/settings-view/model-defaults/phase-model-selector.tsx
index db5a4d2f..c4aca635 100644
--- a/apps/ui/src/components/views/settings-view/model-defaults/phase-model-selector.tsx
+++ b/apps/ui/src/components/views/settings-view/model-defaults/phase-model-selector.tsx
@@ -159,6 +159,9 @@ export function PhaseModelSelector({
   const expandedCodexTriggerRef = useRef<HTMLDivElement>(null);
   const {
     enabledCursorModels,
+    enabledCodexModels,
+    enabledOpencodeModels,
+    enabledDynamicModelIds,
     favoriteModels,
     toggleFavoriteModel,
     codexModels,
@@ -261,6 +264,14 @@ export function PhaseModelSelector({
     }));
   }, [codexModels]);
 
+  const availableCodexModels = useMemo(
+    () =>
+      transformedCodexModels.filter((model) =>
+        enabledCodexModels.includes(model.id as CodexModelId)
+      ),
+    [transformedCodexModels, enabledCodexModels]
+  );
+
   // Filter Cursor models to only show enabled ones
   const availableCursorModels = CURSOR_MODELS.filter((model) => {
     const cursorId = stripProviderPrefix(model.id) as CursorModelId;
@@ -366,16 +377,20 @@ export function PhaseModelSelector({
   // Combine static and dynamic OpenCode models
   const allOpencodeModels: ModelOption[] = useMemo(() => {
     // Start with static models
-    const staticModels = [...OPENCODE_MODELS];
+    const staticModels = OPENCODE_MODELS.filter((model) =>
+      enabledOpencodeModels.includes(model.id)
+    );
 
     // Add dynamic models (convert ModelDefinition to ModelOption)
-    const dynamicModelOptions: ModelOption[] = dynamicOpencodeModels.map((model) => ({
-      id: model.id,
-      label: model.name,
-      description: model.description,
-      badge: model.tier === 'premium' ? 'Premium' : model.tier === 'basic' ? 'Free' : undefined,
-      provider: 'opencode' as const,
-    }));
+    const dynamicModelOptions: ModelOption[] = dynamicOpencodeModels
+      .filter((model) => enabledDynamicModelIds.includes(model.id))
+      .map((model) => ({
+        id: model.id,
+        label: model.name,
+        description: model.description,
+        badge: model.tier === 'premium' ? 'Premium' : model.tier === 'basic' ? 'Free' : undefined,
+        provider: 'opencode' as const,
+      }));
 
     // Merge, avoiding duplicates (static models take precedence for same ID)
     // In practice, static and dynamic IDs don't overlap
@@ -383,14 +398,14 @@ export function PhaseModelSelector({
     const uniqueDynamic = dynamicModelOptions.filter((m) => !staticIds.has(m.id));
 
     return [...staticModels, ...uniqueDynamic];
-  }, [dynamicOpencodeModels]);
+  }, [dynamicOpencodeModels, enabledOpencodeModels, enabledDynamicModelIds]);
 
   // Group models
   const { favorites, claude, cursor, codex, opencode } = useMemo(() => {
     const favs: typeof CLAUDE_MODELS = [];
     const cModels: typeof CLAUDE_MODELS = [];
     const curModels: typeof CURSOR_MODELS = [];
-    const codModels: typeof transformedCodexModels = [];
+    const codModels: typeof availableCodexModels = [];
     const ocModels: ModelOption[] = [];
 
     // Process Claude Models
@@ -412,7 +427,7 @@ export function PhaseModelSelector({
     });
 
     // Process Codex Models
-    transformedCodexModels.forEach((model) => {
+    availableCodexModels.forEach((model) => {
       if (favoriteModels.includes(model.id)) {
         favs.push(model);
       } else {
@@ -436,7 +451,7 @@ export function PhaseModelSelector({
       codex: codModels,
       opencode: ocModels,
     };
-  }, [favoriteModels, availableCursorModels, transformedCodexModels, allOpencodeModels]);
+  }, [favoriteModels, availableCursorModels, availableCodexModels, allOpencodeModels]);
 
   // Group OpenCode models by model type for better organization
   const opencodeSections = useMemo(() => {
@@ -453,8 +468,11 @@ export function PhaseModelSelector({
       free: {},
       dynamic: {},
     };
+    const enabledDynamicProviders = dynamicOpencodeModels.filter((model) =>
+      enabledDynamicModelIds.includes(model.id)
+    );
     const dynamicProviderById = new Map(
-      dynamicOpencodeModels.map((model) => [model.id, model.provider])
+      enabledDynamicProviders.map((model) => [model.id, model.provider])
     );
 
     const resolveProviderKey = (modelId: string): string => {
@@ -524,10 +542,10 @@ export function PhaseModelSelector({
     }).filter(Boolean) as OpencodeSection[];
 
     return builtSections;
-  }, [opencode, dynamicOpencodeModels]);
+  }, [opencode, dynamicOpencodeModels, enabledDynamicModelIds]);
 
   // Render Codex model item with secondary popover for reasoning effort (only for models that support it)
-  const renderCodexModelItem = (model: (typeof transformedCodexModels)[0]) => {
+  const renderCodexModelItem = (model: (typeof availableCodexModels)[0]) => {
     const isSelected = selectedModel === model.id;
     const isFavorite = favoriteModels.includes(model.id);
     const hasReasoning = codexModelHasThinking(model.id as CodexModelId);
@@ -708,7 +726,7 @@ export function PhaseModelSelector({
   };
 
   // Render OpenCode model item (simple selector, no thinking/reasoning options)
-  const renderOpencodeModelItem = (model: (typeof OPENCODE_MODELS)[0]) => {
+  const renderOpencodeModelItem = (model: ModelOption) => {
     const isSelected = selectedModel === model.id;
     const isFavorite = favoriteModels.includes(model.id);
 
@@ -1154,7 +1172,7 @@ export function PhaseModelSelector({
                     }
                     // Codex model
                     if (model.provider === 'codex') {
-                      return renderCodexModelItem(model as (typeof transformedCodexModels)[0]);
+                      return renderCodexModelItem(model as (typeof availableCodexModels)[0]);
                     }
                     // OpenCode model
                     if (model.provider === 'opencode') {