@golba98/codexa 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@golba98/codexa",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Terminal UI for Codexa — TypeScript + Bun + Ink",
   "type": "module",
   "bin": {

package/src/app.tsx

@@ -15,12 +15,13 @@ function normalizeRuntimeAvailability(value: unknown): RuntimeAvailability {
   return "unknown";
 }
 
-function formatRuntimeProviderLabel(providerId: ProviderId): string {
-  if (providerId === "local") return "Local";
-  if (providerId === "google") return "Google";
-  if (providerId === "anthropic") return "Anthropic";
-  if (providerId === "antigravity") return "Antigravity";
-  return "OpenAI";
+function formatRuntimeProviderLabel(providerId: ProviderId): string {
+  if (providerId === "local") return "Local";
+  if (providerId === "google") return "Google";
+  if (providerId === "anthropic") return "Anthropic";
+  if (providerId === "mistral") return "Mistral Vibe CLI";
+  if (providerId === "antigravity") return "Antigravity";
+  return "OpenAI";
 }
 
 function readDiagnosticString(
@@ -131,6 +132,7 @@ import {
   normalizeReasoningForModelCapabilities,
   type CodexModelCapabilities,
 } from "./core/models/codexModelCapabilities.js";
+import { loadSeededCodexCapabilities } from "./core/models/codexModelsCacheSeed.js";
 import {
   buildDevLaunchNotice,
   buildWorkspaceCommandContext,
@@ -171,11 +173,18 @@ import {
   getProviderRuntime,
   isProviderRouteConfigured,
   isProviderRoutableInCodexa,
+  persistProviderDiscovery,
   resolveActiveProviderRoute,
   validateProviderRouteActivation,
 } from "./core/providerRuntime/registry.js";
 import { hasGeminiApiKey, runGeminiDiagnostics } from "./core/providerRuntime/gemini.js";
 import { checkLocalProvider, runLocalDiagnostics, setLocalProviderConfig } from "./core/providerRuntime/local.js";
+import {
+  detectVibeActiveModel,
+  launchMistralVibeCli,
+  resetMistralVibeSession,
+  resolveVibeExecutable,
+} from "./core/providerRuntime/mistralVibe.js";
 import { validateAnthropicRoute, ANTHROPIC_ROUTE_SETUP_MESSAGE } from "./core/providerRuntime/anthropic.js";
 import { providerModelsToCodexCapabilities } from "./core/providerRuntime/models.js";
 import {
@@ -229,25 +238,25 @@ import {
   submitPlanFeedback,
   type PlanFlowState,
 } from "./session/planFlow.js";
-import { AuthPanel } from "./ui/AuthPanel.js";
-import { BackendPicker } from "./ui/BackendPicker.js";
-import { measureBottomComposerRows, MemoizedBottomComposer } from "./ui/BottomComposer.js";
+import { AuthPanel } from "./ui/panels/AuthPanel.js";
+import { BackendPicker } from "./ui/panels/BackendPicker.js";
+import { measureBottomComposerRows, MemoizedBottomComposer } from "./ui/chrome/BottomComposer.js";
 import { resolveStartupHeaderMode, useTerminalViewport } from "./ui/layout.js";
-import { ModelPickerScreen } from "./ui/ModelPickerScreen.js";
-import { ModePicker } from "./ui/ModePicker.js";
-import { PlanActionPicker, type PlanActionValue, measurePlanActionPickerRows } from "./ui/PlanActionPicker.js";
-import { PermissionsPanel, type PermissionsPanelAction } from "./ui/PermissionsPanel.js";
-import { ProviderPicker } from "./ui/ProviderPicker.js";
-import { ReasoningPicker } from "./ui/ReasoningPicker.js";
-import { AttachmentImportPanel, type PendingImportFile } from "./ui/AttachmentImportPanel.js";
-import { SelectionPanel } from "./ui/SelectionPanel.js";
-import { SettingsPanel } from "./ui/SettingsPanel.js";
-import { UpdatePromptPanel } from "./ui/UpdatePromptPanel.js";
-import { measureTextEntryPanelRows, TextEntryPanel } from "./ui/TextEntryPanel.js";
-import { ThemePicker } from "./ui/ThemePicker.js";
-import { getFocusTargetForScreen, FOCUS_IDS } from "./ui/focus.js";
+import { ModelPickerScreen } from "./ui/panels/ModelPickerScreen.js";
+import { ModePicker } from "./ui/panels/ModePicker.js";
+import { PlanActionPicker, type PlanActionValue, measurePlanActionPickerRows } from "./ui/panels/PlanActionPicker.js";
+import { PermissionsPanel, type PermissionsPanelAction } from "./ui/panels/PermissionsPanel.js";
+import { ProviderPicker } from "./ui/panels/ProviderPicker.js";
+import { ReasoningPicker } from "./ui/panels/ReasoningPicker.js";
+import { AttachmentImportPanel, type PendingImportFile } from "./ui/panels/AttachmentImportPanel.js";
+import { SelectionPanel } from "./ui/panels/SelectionPanel.js";
+import { SettingsPanel } from "./ui/panels/SettingsPanel.js";
+import { UpdatePromptPanel } from "./ui/panels/UpdatePromptPanel.js";
+import { measureTextEntryPanelRows, TextEntryPanel } from "./ui/panels/TextEntryPanel.js";
+import { ThemePicker } from "./ui/panels/ThemePicker.js";
+import { getFocusTargetForScreen, FOCUS_IDS } from "./ui/input/focus.js";
 import { ThemeProvider, THEMES } from "./ui/theme.js";
-import { buildActiveRuntimeDisplay, runtimeDisplayToSummary } from "./ui/runtimeDisplay.js";
+import { buildActiveRuntimeDisplay, runtimeDisplayToSummary } from "./ui/render/runtimeDisplay.js";
 import {
   cancelThemeSelection,
   commitThemeSelection,
@@ -257,9 +266,9 @@ import {
   type ThemeSelectionState,
 } from "./ui/themeFlow.js";
 import { isBusy as isUiBusy } from "./session/types.js";
-import { AppShell } from "./ui/AppShell.js";
-import { TranscriptShell } from "./ui/TranscriptShell.js";
-import type { RuntimeAvailability } from "./ui/RuntimeStatusBar.js";
+import { AppShell } from "./ui/chrome/AppShell.js";
+import { TranscriptShell } from "./ui/timeline/TranscriptShell.js";
+import type { RuntimeAvailability } from "./ui/chrome/RuntimeStatusBar.js";
 import { checkForUpdates, formatLocalDevUpdateStatus, formatUpdateInstructions, shouldRunStartupUpdateCheck, type UpdateCheckResult } from "./core/version/updateCheck.js";
 import { isLocalDevChannel } from "./core/version/channel.js";
 import {
@@ -319,7 +328,7 @@ function createProviderMigrationNoticeEvent(
     createdAt: Date.now(),
     title: sanitizeTerminalOutput("Provider migrated"),
     content: sanitizeTerminalOutput(
-      `${formatRuntimeProviderLabel(notice.deprecatedProviderId as ProviderId)} provider is no longer supported. Reverted to ${resolvedProviderLabel}.`,
+      `${formatRuntimeProviderLabel(notice.deprecatedProviderId as ProviderId)} provider is no longer supported. Reverted to ${resolvedProviderLabel}.`,
       { preserveTabs: false, tabSize: 2 },
     ),
   };
@@ -483,8 +492,14 @@ export function App({ launchArgs }: AppProps) {
   const [authStatusBusy, setAuthStatusBusy] = useState(false);
   // Running character total across the conversation — used to estimate token usage
   const [conversationChars, setConversationChars] = useState(0);
-  const [modelCapabilities, setModelCapabilities] = useState<CodexModelCapabilities | null>(null);
+  // Seeded synchronously from local caches (codex's models_cache.json or the
+  // persisted last-good discovery) so the model picker opens instantly with
+  // real models; live discovery replaces this in the background.
+  const [modelCapabilities, setModelCapabilities] = useState<CodexModelCapabilities | null>(() => loadSeededCodexCapabilities());
   const [modelCapabilitiesBusy, setModelCapabilitiesBusy] = useState(false);
+  // True while a provider route switch is validating (subprocess probes);
+  // drives the model picker's loading state for non-openai providers.
+  const [routeSwitchBusy, setRouteSwitchBusy] = useState(false);
   const [activeContextMetadata, setActiveContextMetadata] = useState<ModelContextMetadata | null>(null);
   const { stdout } = useStdout();
   const { stdin } = useStdin();
@@ -658,6 +673,7 @@ export function App({ launchArgs }: AppProps) {
       setLocalProviderConfig(providerWorkspaceConfig.providers?.local);
       return buildProviderRegistry({
         activeModel: model,
+        workspaceRoot,
         workspaceConfig: providerWorkspaceConfig,
         diagnostics: providerDiagnosticsRef.current,
         routeErrors: providerRouteErrorsRef.current,
@@ -667,7 +683,7 @@ export function App({ launchArgs }: AppProps) {
     // updates mutate providerDiagnosticsRef/providerRouteErrorsRef (refs, not state)
     // and then increment the nonce to trigger a re-read of those refs.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [model, providerWorkspaceConfig, registryNonce],
+    [model, providerWorkspaceConfig, registryNonce, workspaceRoot],
   );
   const workspaceDefaultProvider = useMemo(
     () => providerRegistry.find((provider) => provider.isDefault) ?? providerRegistry[0] ?? null,
@@ -717,7 +733,10 @@ export function App({ launchArgs }: AppProps) {
   const modelPickerDiscovery = useMemo(() => {
     if (modelPickerProviderId === "openai") return null;
     return discoverProviderModels(modelPickerProviderId);
-  }, [modelPickerProviderId]);
+    // registryNonce is intentionally included: route validation discovers models
+    // as a side effect and bumps the nonce so an open picker re-reads them.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [modelPickerProviderId, registryNonce]);
   const providerModelCapabilities = useMemo(() => {
     if (!modelPickerDiscovery) return null;
     return providerModelsToCodexCapabilities(modelPickerDiscovery.models, activeProviderRoute.modelId);
@@ -1568,6 +1587,9 @@ export function App({ launchArgs }: AppProps) {
           providerRouteErrorsRef.current["anthropic"] = result.message ?? ANTHROPIC_ROUTE_SETUP_MESSAGE;
         } else {
           delete providerRouteErrorsRef.current["anthropic"];
+          // Persist the freshly discovered catalog so newly released Claude
+          // models replace the stale on-disk cache without a manual refresh.
+          persistProviderDiscovery(discoverProviderModels("anthropic"));
         }
       } catch {
         // Best-effort probe — failures are surfaced only when the user activates the route.
@@ -1993,6 +2015,12 @@ export function App({ launchArgs }: AppProps) {
     }
 
     modelSelectionInFlightRef.current = true;
+    // Reflect the target provider in the model picker immediately: route
+    // validation below can take seconds (subprocess probes), and until it
+    // persists the new active route, modelPickerProviderId would otherwise
+    // keep resolving to the stale route.
+    setPendingRouteProviderId(providerId);
+    setRouteSwitchBusy(true);
     traceInputDebug("model_selection_app_start", getInputDebugSnapshot({
       handler: "setModelAndReasoningWithNotice",
       model: nextModel,
@@ -2062,6 +2090,10 @@ export function App({ launchArgs }: AppProps) {
         model: nextModel,
         reasoningLevel: normalizedReasoning,
       }));
+      if (providerId === "mistral" && activeProviderRoute.providerId !== "mistral") {
+        // Switching to Vibe starts a fresh CLI conversation instead of resuming a stale one.
+        resetMistralVibeSession(workspaceRoot);
+      }
       persistActiveRoute(providerId, nextModel, normalizedReasoning, validation.backendKind, geminiSelection);
       setPendingRouteProviderId(null);
       traceInputDebug("model_selection_app_success", getInputDebugSnapshot({
@@ -2079,8 +2111,10 @@ export function App({ launchArgs }: AppProps) {
         reasoning: nextReasoning,
         error: message,
       }));
+      setPendingRouteProviderId(null);
       appendErrorEvent("Model selection failed", message);
     } finally {
+      setRouteSwitchBusy(false);
       modelSelectionInFlightRef.current = false;
       returnToChatMode("selection");
     }
@@ -2269,7 +2303,11 @@ export function App({ launchArgs }: AppProps) {
   }, [appendSystemEvent, busy]);
 
   const openProviderPicker = useCallback(() => {
-    setPendingRouteProviderId(null);
+    // Mid route switch, keep the pending id so initialProviderId highlights
+    // the provider being activated instead of the stale route.
+    if (!modelSelectionInFlightRef.current) {
+      setPendingRouteProviderId(null);
+    }
     const gate = guardConfigMutation("backend", busy);
     if (!gate.allowed) {
       appendSystemEvent("Busy", gate.message ?? "Finish the current run before opening providers.");
@@ -2277,6 +2315,31 @@ export function App({ launchArgs }: AppProps) {
     }
 
     setScreen("provider-picker");
+    providerDiagnosticsRef.current.mistral = {
+      ...providerDiagnosticsRef.current.mistral,
+      selectedModel: detectVibeActiveModel({ cwd: workspaceRoot }).modelId,
+      availabilityStatus: "checking",
+    };
+    void resolveVibeExecutable({ cwd: workspaceRoot }).then((resolvedCommand) => {
+      if (!isMountedRef.current) return;
+      const modelDetection = detectVibeActiveModel({ cwd: workspaceRoot });
+      providerDiagnosticsRef.current.mistral = {
+        resolvedCommand,
+        selectedModel: modelDetection.modelId,
+        modelSource: modelDetection.source,
+        configPath: modelDetection.configPath,
+        availabilityStatus: resolvedCommand ? "available" : "unavailable",
+      };
+      setRegistryNonce((n) => n + 1);
+    }).catch(() => {
+      if (!isMountedRef.current) return;
+      providerDiagnosticsRef.current.mistral = {
+        selectedModel: detectVibeActiveModel({ cwd: workspaceRoot }).modelId,
+        resolvedCommand: null,
+        availabilityStatus: "unavailable",
+      };
+      setRegistryNonce((n) => n + 1);
+    });
     markProviderAvailability("local", "checking", "provider-picker-open");
     void checkLocalProvider({ override: providerWorkspaceConfig.providers?.local }).then((result) => {
       if (!isMountedRef.current) return;
@@ -2290,7 +2353,7 @@ export function App({ launchArgs }: AppProps) {
       }
       setRegistryNonce((n) => n + 1);
     }).catch(() => undefined);
-  }, [appendSystemEvent, busy, markProviderAvailability, providerWorkspaceConfig.providers]);
+  }, [appendSystemEvent, busy, markProviderAvailability, providerWorkspaceConfig.providers, workspaceRoot]);
 
   const setWorkspaceDefaultProviderWithNotice = useCallback((providerId: ProviderId) => {
     const provider = findProvider(providerRegistry, providerId);
@@ -2307,7 +2370,9 @@ export function App({ launchArgs }: AppProps) {
       const routeConfigured = isProviderRouteConfigured(providerId);
       appendSystemEvent(
         "Provider default updated",
-        provider.routeMode === "in-codexa" && routeConfigured
+        provider.routeMode === "launch-only"
+          ? `${provider.displayName} is now the workspace default external CLI. Active chat route remains ${activeRouteProvider?.displayName ?? "OpenAI"} / ${model}.`
+          : provider.routeMode === "in-codexa" && routeConfigured
           ? `${provider.displayName} is now the workspace default provider. Active chat route remains ${activeRouteProvider?.displayName ?? "OpenAI"} / ${model}.`
           : `${provider.displayName} is set as the workspace default, but in-Codexa routing is not configured yet. Active chat route remains ${activeRouteProvider?.displayName ?? "OpenAI"} / ${model}.`,
       );
@@ -2466,6 +2531,7 @@ export function App({ launchArgs }: AppProps) {
             cwd: workspaceRoot,
             localConfig: providerId === "local" ? providerWorkspaceConfig.providers?.local : undefined,
           }).then((discovery) => {
+            persistProviderDiscovery(discovery);
             if (discovery.diagnostics) {
               providerDiagnosticsRef.current[providerId] = discovery.diagnostics as Record<string, string | number | boolean | null>;
             }
@@ -2557,10 +2623,10 @@ export function App({ launchArgs }: AppProps) {
     setScreen("main");
     appendSystemEvent(
       "Provider launch",
-      `Suspending Codexa and launching ${provider.displayName}. Codexa will resume when the external CLI exits.`,
+      `Suspending Codexa and launching ${provider.displayName}${providerId === "mistral" ? ` / ${provider.currentModel}` : ""}. Codexa will resume when the external CLI exits.`,
     );
 
-    void launchProviderCli(provider, {
+    const launchOptions = {
       cwd: workspaceRoot,
       stdin,
       beforeLaunch: () => {
@@ -2570,9 +2636,18 @@ export function App({ launchArgs }: AppProps) {
       afterLaunch: () => {
         terminalControl.setMouseReporting(effectiveMouseCapture, "src/app.tsx:providerLaunch.restoreMouse");
       },
-    }).then((result) => {
+    };
+    const launchPromise = providerId === "mistral"
+      ? launchMistralVibeCli(provider, launchOptions)
+      : launchProviderCli(provider, launchOptions);
+
+    void launchPromise.then((result) => {
       if (!isMountedRef.current) return;
-      appendSystemEvent("Provider launch", result.message);
+      if (providerId === "mistral" && (result.status === "missing-command" || result.status === "spawn-error")) {
+        appendErrorEvent("Mistral Vibe launch failed", result.message);
+      } else {
+        appendSystemEvent("Provider launch", result.message);
+      }
     }).catch((error) => {
       if (!isMountedRef.current) return;
       const message = error instanceof Error ? error.message : "Provider launch failed.";
@@ -2599,7 +2674,11 @@ export function App({ launchArgs }: AppProps) {
   ]);
 
   const openModelPicker = useCallback(() => {
-    setPendingRouteProviderId(null);
+    // While a route switch is validating, keep the pending id so the picker
+    // shows the target provider instead of snapping back to the stale route.
+    if (!modelSelectionInFlightRef.current) {
+      setPendingRouteProviderId(null);
+    }
     traceInputDebug("model_picker_open_request", getInputDebugSnapshot({
       handler: "openModelPicker",
       currentScreen: screen,
@@ -3121,6 +3200,7 @@ export function App({ launchArgs }: AppProps) {
     activeTurnIdRef.current = null;
     activeRunLifecycleRef.current = null;
     activeRunTimingRef.current = null;
+    resetMistralVibeSession(workspaceRoot);
     setPlanFlow(resetPlanFlow());
     renderDebug.traceEvent("terminal", "clearReactStateRequested", {
       clearGeneration,
@@ -3139,7 +3219,7 @@ export function App({ launchArgs }: AppProps) {
         liveInkInstanceResolved: Boolean(inkInstance),
       });
     }
-  }, [cancelActiveRun, clearFrameBoundaryController, inkInstance, launchContext, providerWorkspaceConfig, resetToHomeScreen, sessionState.clearEpoch, stdout.columns, terminalControl]);
+  }, [cancelActiveRun, clearFrameBoundaryController, inkInstance, launchContext, providerWorkspaceConfig, resetToHomeScreen, sessionState.clearEpoch, stdout.columns, terminalControl, workspaceRoot]);
 
   const handleShellExecute = useCallback((command: string) => {
     const safeCommand = sanitizeTerminalInput(command).trim();
@@ -4174,13 +4254,13 @@ export function App({ launchArgs }: AppProps) {
         case "diagnose_providers": {
           const lines: string[] = ["Provider CLI diagnostics:"];
           const diags = providerDiagnosticsRef.current;
-          const providerIds = ["openai", "anthropic", "local", "antigravity"] as const;
-          const labels: Record<string, string> = {
-            openai: "OpenAI/Codex",
-            anthropic: "Anthropic/Claude",
-            local: "Local OpenAI-compatible",
-            antigravity: "Antigravity CLI",
-          };
+          const providerIds = ["openai", "anthropic", "local", "antigravity"] as const;
+          const labels: Record<string, string> = {
+            openai: "OpenAI/Codex",
+            anthropic: "Anthropic/Claude",
+            local: "Local OpenAI-compatible",
+            antigravity: "Antigravity CLI",
+          };
           for (const id of providerIds) {
             const diag = diags[id];
             lines.push(`\n  ${labels[id] ?? id}:`);
@@ -4705,7 +4785,8 @@ export function App({ launchArgs }: AppProps) {
                 currentModel={modelPickerCurrentModel}
                 currentReasoning={modelPickerCurrentReasoning}
                 activeProviderLabel={modelPickerProviderLabel}
-                isLoading={modelPickerProviderId === "openai" && modelCapabilitiesBusy && modelPickerModels.length === 0}
+                isLoading={modelPickerModels.length === 0
+                  && ((modelPickerProviderId === "openai" && modelCapabilitiesBusy) || routeSwitchBusy)}
                 emptyMessage={modelPickerEmptyMessage}
                 onSelect={(m, r, geminiSelection) => {
                   if (pendingRouteProviderId && pendingRouteProviderId !== activeProviderRoute.providerId) {

package/src/commands/handler.ts

@@ -18,7 +18,6 @@ import {
   AUTH_PREFERENCES,
   AVAILABLE_BACKENDS,
   AVAILABLE_MODELS,
-  AVAILABLE_REASONING_LEVELS,
   AVAILABLE_THEMES,
   BUSY_LOADER_SETTING_VALUES,
   WORKSPACE_DISPLAY_MODES,
@@ -150,10 +149,6 @@ function expandReasoningAliases(arg: string): string {
   return normalized === "extra high" ? "xhigh" : normalized;
 }
 
-function isKnownFallbackReasoning(value: string): boolean {
-  return AVAILABLE_REASONING_LEVELS.some((item) => item.id === value);
-}
-
 function simplePolicySetter<T extends string>(
   rest: string,
   normalizedRest: string,
@@ -520,17 +515,11 @@ export function handleCommand(text: string, context: CommandContext): CommandRes
             message: `Unknown reasoning level for ${context.runtime.model}: ${arg}. Valid: ${valid}`,
           };
         }
-        if (isKnownFallbackReasoning(normalized)) {
-          return {
-            action: "reasoning",
-            value: normalized,
-            message: `Reasoning level switched to ${formatReasoningLabel(normalized)} (runtime metadata unavailable)`,
-          };
-        }
-        return {
-          action: "unknown",
-          message: `Unknown reasoning level: ${arg}. Runtime reasoning metadata is unavailable for ${context.runtime.model}.`,
-        };
+        return {
+          action: "reasoning",
+          value: normalized,
+          message: `Reasoning level switched to ${formatReasoningLabel(normalized)} (runtime metadata unavailable; unverified until runtime)`,
+        };
       }
 
       case "plan": {

package/src/config/buildInfo.ts

@@ -1,3 +1,3 @@
 // Generated by scripts/gen-build-info.mjs — do not edit manually.
-export const BUILD_COMMIT = "b066a15b77696d2a0945ea7c6c3d07630584296b" as const;
-export const APP_VERSION = "1.0.4" as const;
+export const BUILD_COMMIT = "aaffb655176a0acb1bc7800ddbb3e6402e5933f4" as const;
+export const APP_VERSION = "1.0.5" as const;

package/src/core/models/codexModelCapabilities.ts

@@ -1,6 +1,9 @@
 import { type ChildProcess } from "child_process";
 import { APP_NAME, APP_VERSION, DEFAULT_MODEL, LEGACY_FALLBACK_MODELS, formatReasoningLabel } from "../../config/settings.js";
 import { resolveCodexExecutable, spawnCodexProcess } from "../executables/codexExecutable.js";
+import { loadSeededCodexCapabilities } from "./codexModelsCacheSeed.js";
+import { saveCachedProviderModels } from "./providerModelCache.js";
+import type { ProviderModel } from "../providerRuntime/types.js";
 
 export type ModelCapabilitySource = "runtime" | "fallback";
 export type ModelCapabilityStatus = "ready" | "fallback";
@@ -47,6 +50,8 @@ export interface GetCodexModelCapabilitiesOptions extends DiscoverCodexModelCapa
   ttlMs?: number;
   resolveExecutable?: typeof resolveCodexExecutable;
   discover?: typeof discoverCodexModelCapabilities;
+  seed?: typeof loadSeededCodexCapabilities;
+  persist?: typeof persistCodexModelCapabilities;
 }
 
 interface JsonRpcResponse {
@@ -439,14 +444,36 @@ export async function discoverCodexModelCapabilities(
   });
 }
 
-// Cache chain: TTL-based in-memory cache → live discovery → fallback model list on error.
-// Failed discoveries are evicted from the cache so retries are possible.
+// Persist a successful live discovery so the next launch can seed the model
+// picker without spawning the codex app-server. Best-effort by design.
+export function persistCodexModelCapabilities(capabilities: CodexModelCapabilities): void {
+  const models: ProviderModel[] = capabilities.models
+    .filter((capability) => !capability.hidden)
+    .map((capability) => ({
+      id: capability.id,
+      modelId: capability.model,
+      label: capability.label,
+      description: capability.description,
+      defaultReasoningLevel: capability.defaultReasoningLevel,
+      supportedReasoningLevels: capability.supportedReasoningLevels,
+      source: "discovered",
+    }));
+  saveCachedProviderModels("openai", { discoveredAt: capabilities.discoveredAt, models });
+}
+
+// Cache chain: TTL-based in-memory cache → live discovery → seeded local caches
+// (codex's own models_cache.json / Codexa's last-good discovery) → static
+// fallback model list. Failed discoveries are evicted from the in-memory cache
+// so retries are possible even when a seed satisfied the request.
 export async function getCodexModelCapabilities(
   options: GetCodexModelCapabilitiesOptions = {},
 ): Promise<CodexModelCapabilities> {
   const now = options.now?.() ?? Date.now();
   const ttlMs = options.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+  const seed = options.seed ?? loadSeededCodexCapabilities;
+  const persist = options.persist ?? persistCodexModelCapabilities;
   let executable: string | null = null;
+  let liveDiscoverySucceeded = false;
 
   try {
     executable = options.executable ?? await (options.resolveExecutable ?? resolveCodexExecutable)();
@@ -462,7 +489,25 @@ export async function getCodexModelCapabilities(
       includeHidden: options.includeHidden,
       timeoutMs: options.timeoutMs,
       now: () => now,
-    }).catch((error) => createFallbackModelCapabilities(error, { discoveredAt: now, executable }));
+    }).then((discovered) => {
+      liveDiscoverySucceeded = true;
+      try {
+        persist(discovered);
+      } catch {
+        // Persistence must never fail a successful discovery.
+      }
+      return discovered;
+    }).catch((error) => {
+      try {
+        const seeded = seed();
+        if (seeded) {
+          return seeded;
+        }
+      } catch {
+        // Seed read failures fall through to the static list.
+      }
+      return createFallbackModelCapabilities(error, { discoveredAt: now, executable });
+    });
 
     capabilityCache.set(cacheKey, {
       expiresAt: now + ttlMs,
@@ -470,12 +515,20 @@ export async function getCodexModelCapabilities(
     });
 
     const result = await promise;
-    if (result.status === "fallback") {
+    if (!liveDiscoverySucceeded) {
       capabilityCache.delete(cacheKey);
     }
 
     return result;
   } catch (error) {
+    try {
+      const seeded = seed();
+      if (seeded) {
+        return seeded;
+      }
+    } catch {
+      // Seed read failures fall through to the static list.
+    }
     return createFallbackModelCapabilities(error, { discoveredAt: now, executable });
   }
 }