@golba98/codexa 1.0.3 → 1.0.5

package/src/core/models/codexModelsCacheSeed.ts

@@ -0,0 +1,153 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { formatReasoningLabel } from "../../config/settings.js";
+import type { ProviderModel } from "../providerRuntime/types.js";
+import type {
+  CodexModelCapabilities,
+  CodexModelCapability,
+  ReasoningEffortCapability,
+} from "./codexModelCapabilities.js";
+import { loadCachedProviderModels, type CachedProviderModels } from "./providerModelCache.js";
+
+// The codex CLI maintains its own model catalog cache with slugs, labels and
+// reasoning levels. Reading it seeds Codexa's OpenAI model list instantly —
+// no subprocess — and stays current because the codex CLI refreshes the file
+// on its own runs.
+// Resolved per call from env (matching claudeCodeDiscovery) so HOME
+// redirection in tests holds — Bun's homedir() ignores runtime HOME changes.
+export function getCodexModelsCacheFile(): string {
+  const home = process.env.USERPROFILE ?? process.env.HOME ?? homedir();
+  return join(home, ".codex", "models_cache.json");
+}
+
+interface CodexSeed {
+  fetchedAt: number;
+  models: readonly ProviderModel[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asString(value: unknown): string | null {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function parseReasoningLevels(raw: unknown): readonly ReasoningEffortCapability[] | null {
+  if (!Array.isArray(raw)) {
+    return null;
+  }
+  const levels = raw
+    .map((entry): ReasoningEffortCapability | null => {
+      if (!isRecord(entry)) {
+        return null;
+      }
+      const id = asString(entry.effort);
+      if (!id) {
+        return null;
+      }
+      return { id, label: formatReasoningLabel(id), description: asString(entry.description) };
+    })
+    .filter((entry): entry is ReasoningEffortCapability => entry !== null);
+  return levels.length > 0 ? levels : null;
+}
+
+function parseSeedModel(raw: unknown): ProviderModel | null {
+  if (!isRecord(raw)) {
+    return null;
+  }
+  // Models with visibility "hide" are internal codex routes (e.g. auto-review).
+  if (asString(raw.visibility) === "hide") {
+    return null;
+  }
+  const modelId = asString(raw.slug);
+  if (!modelId) {
+    return null;
+  }
+  return {
+    id: modelId,
+    modelId,
+    label: asString(raw.display_name) ?? modelId,
+    description: asString(raw.description),
+    defaultReasoningLevel: asString(raw.default_reasoning_level),
+    supportedReasoningLevels: parseReasoningLevels(raw.supported_reasoning_levels),
+    source: "discovered",
+  };
+}
+
+export function loadCodexSeedModels(cacheFile = getCodexModelsCacheFile()): CodexSeed | null {
+  try {
+    if (!existsSync(cacheFile)) {
+      return null;
+    }
+    const parsed: unknown = JSON.parse(readFileSync(cacheFile, "utf8"));
+    if (!isRecord(parsed) || !Array.isArray(parsed.models)) {
+      return null;
+    }
+    const models = parsed.models
+      .map(parseSeedModel)
+      .filter((model): model is ProviderModel => model !== null);
+    if (models.length === 0) {
+      return null;
+    }
+    const fetchedAtRaw = asString(parsed.fetched_at);
+    const fetchedAt = fetchedAtRaw ? Date.parse(fetchedAtRaw) : Number.NaN;
+    return { fetchedAt: Number.isFinite(fetchedAt) ? fetchedAt : 0, models };
+  } catch {
+    return null;
+  }
+}
+
+// Freshest locally known OpenAI models without spawning a subprocess:
+// codex's own cache file vs Codexa's persisted last-good discovery.
+export function loadSeededOpenAiModels(options: {
+  codexCacheFile?: string;
+  providerCacheFile?: string;
+} = {}): CachedProviderModels | null {
+  const seed = loadCodexSeedModels(options.codexCacheFile);
+  const persisted = options.providerCacheFile === undefined
+    ? loadCachedProviderModels("openai")
+    : loadCachedProviderModels("openai", options.providerCacheFile);
+  if (seed && (!persisted || seed.fetchedAt >= persisted.discoveredAt)) {
+    return { discoveredAt: seed.fetchedAt, models: seed.models };
+  }
+  return persisted;
+}
+
+function toCapability(model: ProviderModel, index: number): CodexModelCapability {
+  return {
+    id: model.id,
+    model: model.modelId,
+    label: model.label,
+    description: model.description,
+    available: true,
+    hidden: false,
+    isDefault: index === 0,
+    defaultReasoningLevel: model.defaultReasoningLevel,
+    supportedReasoningLevels: model.supportedReasoningLevels,
+    reasoningLevelCount: model.supportedReasoningLevels ? model.supportedReasoningLevels.length : null,
+    source: "runtime",
+    raw: model,
+  };
+}
+
+// Capabilities for the OpenAI picker sourced purely from local caches.
+// Returns null when nothing is cached yet (first ever launch).
+export function loadSeededCodexCapabilities(options: {
+  codexCacheFile?: string;
+  providerCacheFile?: string;
+} = {}): CodexModelCapabilities | null {
+  const seeded = loadSeededOpenAiModels(options);
+  if (!seeded) {
+    return null;
+  }
+  return {
+    status: "ready",
+    source: "runtime",
+    models: seeded.models.map(toCapability),
+    discoveredAt: seeded.discoveredAt,
+    executable: null,
+    error: null,
+  };
+}

package/src/core/models/providerModelCache.ts

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ProviderId } from "../providerLauncher/types.js";
+import type { ProviderModel } from "../providerRuntime/types.js";
+
+// Persistent last-good model discovery results, one entry per provider.
+// Lets pickers open instantly with the previous session's discovered models
+// while a background refresh runs. Corrupt or missing cache degrades to null.
+// Resolved per call from env (matching claudeCodeDiscovery) so HOME
+// redirection in tests holds — Bun's homedir() ignores runtime HOME changes.
+export function getProviderModelCacheFile(): string {
+  const home = process.env.USERPROFILE ?? process.env.HOME ?? homedir();
+  return join(home, ".codexa-model-cache.json");
+}
+
+const CACHE_VERSION = 1;
+
+export interface CachedProviderModels {
+  discoveredAt: number;
+  models: readonly ProviderModel[];
+}
+
+interface ProviderModelCacheFile {
+  version: number;
+  providers: Partial<Record<ProviderId, CachedProviderModels>>;
+}
+
+function readCacheFile(cacheFile: string): ProviderModelCacheFile | null {
+  try {
+    if (!existsSync(cacheFile)) {
+      return null;
+    }
+    const parsed: unknown = JSON.parse(readFileSync(cacheFile, "utf8"));
+    if (
+      typeof parsed !== "object" || parsed === null || Array.isArray(parsed)
+      || (parsed as ProviderModelCacheFile).version !== CACHE_VERSION
+      || typeof (parsed as ProviderModelCacheFile).providers !== "object"
+      || (parsed as ProviderModelCacheFile).providers === null
+    ) {
+      return null;
+    }
+    return parsed as ProviderModelCacheFile;
+  } catch {
+    return null;
+  }
+}
+
+// A model id is passed straight to a provider CLI, so it must be a bare token.
+// Discovery scrapes CLI output, and a buggy build can bake an ANSI escape into
+// an id (e.g. "claude-fable-5\x1b[1m"). Reject rather than repair: a cached id
+// we cannot vouch for is dropped so discovery re-probes for a clean one.
+const VALID_MODEL_ID = /^[A-Za-z0-9._:\/-]+$/;
+
+function isUsableModel(model: unknown): model is ProviderModel {
+  if (typeof model !== "object" || model === null) {
+    return false;
+  }
+  const candidate = model as ProviderModel;
+  return typeof candidate.id === "string"
+    && typeof candidate.modelId === "string"
+    && typeof candidate.label === "string"
+    && VALID_MODEL_ID.test(candidate.id)
+    && VALID_MODEL_ID.test(candidate.modelId);
+}
+
+function isValidEntry(entry: unknown): entry is CachedProviderModels {
+  if (typeof entry !== "object" || entry === null) {
+    return false;
+  }
+  const candidate = entry as CachedProviderModels;
+  return typeof candidate.discoveredAt === "number" && Array.isArray(candidate.models);
+}
+
+export function loadCachedProviderModels(
+  providerId: ProviderId,
+  cacheFile = getProviderModelCacheFile(),
+): CachedProviderModels | null {
+  const cache = readCacheFile(cacheFile);
+  const entry = cache?.providers?.[providerId];
+  if (!entry || !isValidEntry(entry)) {
+    return null;
+  }
+  const models = entry.models.filter(isUsableModel);
+  if (models.length === 0) {
+    return null;
+  }
+  return { discoveredAt: entry.discoveredAt, models };
+}
+
+export function saveCachedProviderModels(
+  providerId: ProviderId,
+  entry: CachedProviderModels,
+  cacheFile = getProviderModelCacheFile(),
+): void {
+  if (entry.models.length === 0) {
+    return;
+  }
+  try {
+    const cache = readCacheFile(cacheFile) ?? { version: CACHE_VERSION, providers: {} };
+    cache.providers[providerId] = entry;
+    writeFileSync(cacheFile, `${JSON.stringify(cache, null, 2)}\n`, "utf8");
+  } catch {
+    // Persistence is best-effort; discovery still works without it.
+  }
+}

package/src/core/perf/renderDebug.ts

@@ -4,14 +4,14 @@ import { useEffect, useRef } from "react";
 
 type DebugEnv = Record<string, string | undefined>;
 
-// Global debug state — populated lazily on first check, or eagerly via configureRenderDebug().
+// Global debug state — populated lazily on first check, or eagerly via configureRenderDebug().
 let configured = false;
 let enabled = false;
 let renderTraceEnabled = false;
 let lifecycleEnabled = false;
 let flickerEnabled = false;
 let plainActionsEnabled = false;
-let logPath = join(process.cwd(), ".codexa-debug", "render-debug.log");
+let logPath = join(process.cwd(), ".codexa", "debug", "render-status.log");
 let sessionId = `${Date.now()}-${process.pid}`;
 const counters = new Map<string, number>();
 
@@ -19,13 +19,17 @@ function configureFromEnv(env: DebugEnv = process.env): void {
   renderTraceEnabled = env["CODEXA_DEBUG_RENDER_TRACE"] === "1";
   // Both CODEXA_RENDER_DEBUG and CODEXA_DEBUG_RENDER activate render debugging —
   // two names exist for historical reasons; either one is sufficient.
-  enabled = env["CODEXA_RENDER_DEBUG"] === "1"
-    || env["CODEXA_DEBUG_RENDER"] === "1"
-    || renderTraceEnabled;
+  // CODEXA_TERMINAL_TRACE is a focused alias for diagnosing terminal/clear/resize
+  // render-state issues; it lights up the same `terminal` trace channel.
+  enabled = env["CODEXA_RENDER_DEBUG"] === "1"
+    || env["CODEXA_DEBUG_MODEL_STATE"] === "1"
+    || env["CODEXA_DEBUG_RENDER"] === "1"
+    || env["CODEXA_TERMINAL_TRACE"] === "1"
+    || renderTraceEnabled;
   lifecycleEnabled = env["CODEXA_DEBUG_LIFECYCLE"] === "1";
   flickerEnabled = env["CODEXA_DEBUG_FLICKER"] === "1";
   plainActionsEnabled = env["CODEXA_DEBUG_PLAIN_ACTIONS"] === "1";
-  logPath = env["CODEXA_RENDER_DEBUG_FILE"]?.trim() || join(process.cwd(), ".codexa-debug", "render-debug.log");
+  logPath = env["CODEXA_RENDER_DEBUG_FILE"]?.trim() || join(process.cwd(), ".codexa", "debug", "render-status.log");
   sessionId = `${Date.now()}-${process.pid}`;
   configured = true;
 }

package/src/core/process/CommandRunner.ts

@@ -9,6 +9,7 @@ export interface CommandSpec {
   cwd: string;
   env?: NodeJS.ProcessEnv;
   timeoutMs?: number;
+  stdinData?: string;
 }
 
 export interface CommandResult {
@@ -177,10 +178,20 @@ function runProcess(
     cwd: spec.cwd,
     env: spec.env,
     shell: false,
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: [spec.stdinData !== undefined ? "pipe" : "ignore", "pipe", "pipe"],
   });
   handlers.onProcessLifecycle?.("spawned");
 
+  if (spec.stdinData !== undefined) {
+    try {
+      child.stdin?.on("error", () => { /* EPIPE when the process exits before reading stdin */ });
+      child.stdin?.write(spec.stdinData);
+      child.stdin?.end();
+    } catch {
+      // stdin already closed; the close/error handlers report the outcome
+    }
+  }
+
   const result = new Promise<CommandResult>((resolve) => {
     const finish = (partial: Omit<CommandResult, "stdout" | "stderr" | "startedAt" | "endedAt" | "durationMs" | "userMessage"> & { endedAt?: number }) => {
       if (timeoutHandle) clearTimeout(timeoutHandle);

package/src/core/providerLauncher/registry.ts

@@ -14,12 +14,17 @@ import {
   isProviderRoutableInCodexa,
   isProviderRouteConfigured,
 } from "../providerRuntime/registry.js";
-import { normalizeGeminiModelId } from "../providerRuntime/models.js";
-import { setLocalProviderConfig } from "../providerRuntime/local.js";
+import { normalizeGeminiModelId } from "../providerRuntime/models.js";
+import { ANTIGRAVITY_DEFAULT_MODEL_ID } from "../providerRuntime/antigravity.js";
+import { discoverMistralVibeModels } from "../providerRuntime/mistralVibe.js";
+import { setLocalProviderConfig } from "../providerRuntime/local.js";
 import { formatContextLength, resolveModelContextLengthCached } from "../providerRuntime/contextMetadata.js";
 import { resolveModelCapabilityProfileCached } from "../providerRuntime/capabilityProfile.js";
 
-const PROVIDER_ORDER: readonly ProviderId[] = ["openai", "anthropic", "google", "local"];
+// Google/Gemini remains a recognized legacy config value so existing workspace
+// files can be migrated, but it is no longer a selectable Codexa provider.
+const PROVIDER_ORDER: readonly ProviderId[] = ["openai", "anthropic", "mistral", "local", "antigravity"];
+const KNOWN_PROVIDER_IDS: readonly ProviderId[] = ["openai", "anthropic", "google", "mistral", "local", "antigravity"];
 
 const DEFAULT_PROVIDER_ID: ProviderId = "openai";
 
@@ -63,8 +68,8 @@ const DEFAULT_PROVIDERS: Record<ProviderId, ProviderDefault> = {
     isActiveRoute: false,
     routeUnavailableReason: null,
   },
-  local: {
-    id: "local",
+  local: {
+    id: "local",
     displayName: "Local",
     currentModel: () => "Local default",
     backendType: "local-openai-compatible",
@@ -72,12 +77,34 @@ const DEFAULT_PROVIDERS: Record<ProviderId, ProviderDefault> = {
     enabled: false,
     launchCommand: null,
     isActiveRoute: false,
-    routeUnavailableReason: "Local provider unavailable. Start LM Studio, load a model, and enable the local server.",
+    routeUnavailableReason: "Local provider unavailable. Start LM Studio, load a model, and enable the local server.",
+  },
+  mistral: {
+    id: "mistral",
+    displayName: "Mistral Vibe CLI",
+    currentModel: () => "Vibe default",
+    backendType: "mistral-vibe-cli-auth",
+    routeMode: "in-codexa",
+    enabled: true,
+    launchCommand: { executable: "vibe", args: [] },
+    isActiveRoute: false,
+    routeUnavailableReason: null,
   },
-};
+  antigravity: {
+    id: "antigravity",
+    displayName: "Antigravity",
+    currentModel: () => ANTIGRAVITY_DEFAULT_MODEL_ID,
+    backendType: "antigravity-cli-auth",
+    routeMode: "in-codexa",
+    enabled: true,
+    launchCommand: { executable: "agy", args: [] },
+    isActiveRoute: false,
+    routeUnavailableReason: null,
+  },
+};
 
-function isProviderId(value: unknown): value is ProviderId {
-  return typeof value === "string" && PROVIDER_ORDER.includes(value as ProviderId);
+function isProviderId(value: unknown): value is ProviderId {
+  return typeof value === "string" && KNOWN_PROVIDER_IDS.includes(value as ProviderId);
 }
 
 function normalizeLaunchCommand(value: ProviderWorkspaceOverride["command"] | undefined): ProviderLaunchCommand | null | undefined {
@@ -122,25 +149,29 @@ function applyOverride(
       : provider.currentModel,
     enabled: nextEnabled,
     launchCommand: nextCommand,
-    statusLabel: nextEnabled
-      ? (provider.routeUnavailableReason ? "Needs config" : "Enabled")
-      : "Disabled",
+    statusLabel: !nextEnabled
+      ? "Disabled"
+      : provider.routeMode === "launch-only"
+        ? provider.statusLabel
+        : (provider.routeUnavailableReason ? "Needs config" : "Enabled"),
   };
 }
 
-export function getDefaultProviderId(config: ProviderWorkspaceConfig | null | undefined): ProviderId {
-  return isProviderId(config?.workspaceDefaultProviderId) ? config.workspaceDefaultProviderId : DEFAULT_PROVIDER_ID;
-}
+export function getDefaultProviderId(config: ProviderWorkspaceConfig | null | undefined): ProviderId {
+  const providerId = config?.workspaceDefaultProviderId;
+  return isProviderId(providerId) && providerId !== "google" ? providerId : DEFAULT_PROVIDER_ID;
+}
 
 export function getActiveRouteProviderId(config: ProviderWorkspaceConfig | null | undefined): ProviderId {
   const providerId = config?.activeRoute?.providerId;
-  return isProviderId(providerId) && isProviderRoutableInCodexa(providerId)
+  return isProviderId(providerId) && providerId !== "google" && isProviderRoutableInCodexa(providerId)
     ? providerId
     : DEFAULT_PROVIDER_ID;
 }
 
 export function buildProviderRegistry(options: {
   activeModel: string;
+  workspaceRoot?: string;
   workspaceConfig?: ProviderWorkspaceConfig | null;
   diagnostics?: Record<string, Record<string, string | number | boolean | null>>;
   routeErrors?: Record<string, string>;
@@ -154,7 +185,9 @@ export function buildProviderRegistry(options: {
     }
     const defaults = DEFAULT_PROVIDERS[id];
     const runtime = getProviderRuntime(id);
-    const discovery = runtime.discoverModels();
+    const discovery = id === "mistral"
+      ? discoverMistralVibeModels(options.workspaceRoot ?? process.cwd())
+      : runtime.discoverModels();
 
     const activeRoute = options.workspaceConfig?.activeRoute;
     const isThisActive = activeRoute?.providerId === id;
@@ -189,6 +222,10 @@ export function buildProviderRegistry(options: {
       }
     }
 
+    if (id === "mistral") {
+      currentModelLabel = discovery.models[0]?.modelId ?? "Vibe default";
+    }
+
     const rawMetadataForModel = discovery.models.find((model) => model.modelId === currentModelLabel)?.raw;
     const contextMetadata = resolveModelContextLengthCached({
       providerId: id,
@@ -214,7 +251,16 @@ export function buildProviderRegistry(options: {
 
     const enabled = id === "local" ? discovery.status === "ready" : defaults.enabled;
 
-    const statusLabel = id === "local"
+    const availabilityStatus = options.diagnostics?.[id]?.availabilityStatus;
+    const statusLabel = id === "mistral"
+      ? availabilityStatus === "checking"
+        ? "Checking"
+        : availabilityStatus === "unavailable"
+          ? "Missing"
+          : routeUnavailableReason
+            ? "Needs config"
+            : "Enabled"
+      : id === "local"
       ? (discovery.status === "ready" ? "Enabled" : "Disabled")
       : !defaults.enabled
         ? "Disabled"

package/src/core/providerLauncher/types.ts

@@ -1,10 +1,12 @@
-export type ProviderId = "openai" | "anthropic" | "google" | "local";
+export type ProviderId = "openai" | "anthropic" | "google" | "mistral" | "local" | "antigravity";
 
 export type ProviderBackendType =
-  | "codex-cli-auth"
-  | "gemini-cli-auth"
-  | "claude-code-auth"
-  | "openai-api-key"
+  | "codex-cli-auth"
+  | "gemini-cli-auth"
+  | "claude-code-auth"
+  | "mistral-vibe-cli-auth"
+  | "antigravity-cli-auth"
+  | "openai-api-key"
   | "gemini-api-key"
   | "anthropic-api-key"
   | "local-openai-compatible"
@@ -69,10 +71,11 @@ export interface ProviderWorkspaceOverride {
   defaultModel?: string;
   models?: Record<string, ProviderModelWorkspaceOverride>;
   command?: string | ProviderLaunchCommand | null;
-  claudeCommandPath?: string;
-  geminiCommandPath?: string;
-  codexCommandPath?: string;
-}
+  claudeCommandPath?: string;
+  geminiCommandPath?: string;
+  codexCommandPath?: string;
+  antigravityCommandPath?: string;
+}
 
 export interface ProviderModelWorkspaceOverride {
   contextLength?: number;

package/src/core/providerLauncher/workspaceConfig.ts

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { DEFAULT_MODEL } from "../../config/settings.js";
-import { normalizeWorkspaceRoot } from "../workspaceRoot.js";
+import { normalizeWorkspaceRoot } from "../workspace/workspaceRoot.js";
 import { isKnownProviderId } from "./registry.js";
 import { getDefaultRouteModel, getProviderRuntime, isProviderRouteConfigured, isProviderRoutableInCodexa } from "../providerRuntime/registry.js";
 import { normalizeGeminiModelId } from "../providerRuntime/models.js";
@@ -13,8 +13,9 @@ import type {
   ProviderWorkspaceOverride,
 } from "./types.js";
 
-const DEPRECATED_ANTIGRAVITY_PROVIDER_ID = "antigravity";
-const DEPRECATED_ANTIGRAVITY_BACKENDS = new Set(["antigravity-cli-auth", "agy"]);
+const DEPRECATED_ANTIGRAVITY_PROVIDER_ID = "antigravity";
+const DEPRECATED_ANTIGRAVITY_BACKENDS = new Set(["antigravity-cli-auth", "agy"]);
+const DEPRECATED_GOOGLE_PROVIDER_ID = "google";
 
 export function getProviderWorkspaceConfigFile(workspaceRoot: string): string {
   return join(normalizeWorkspaceRoot(workspaceRoot), ".codexa", "providers.json");
@@ -28,16 +29,20 @@ function isDeprecatedAntigravityProviderId(value: unknown): boolean {
   return value === DEPRECATED_ANTIGRAVITY_PROVIDER_ID;
 }
 
-function isDeprecatedAntigravityRoute(value: unknown): boolean {
+function isDeprecatedAntigravityRoute(value: unknown): boolean {
   if (!isRecord(value)) return false;
   return isDeprecatedAntigravityProviderId(value.providerId ?? value.provider_id)
     || DEPRECATED_ANTIGRAVITY_BACKENDS.has(String(value.backendKind ?? value.backend_kind));
-}
+}
+
+function isDeprecatedGoogleRoute(value: unknown): boolean {
+  return isRecord(value) && (value.providerId ?? value.provider_id) === DEPRECATED_GOOGLE_PROVIDER_ID;
+}
 
 function resolveDeprecatedProviderFallback(
   providers: Partial<Record<ProviderId, ProviderWorkspaceOverride>>,
 ): ProviderId {
-  const candidates: readonly ProviderId[] = ["openai", "google", "anthropic", "local"];
+  const candidates: readonly ProviderId[] = ["openai", "anthropic", "local"];
   return candidates.find((providerId) =>
     isProviderRoutableInCodexa(providerId)
     && (providerId === "openai" || providers[providerId] !== undefined || isProviderRouteConfigured(providerId))
@@ -214,22 +219,24 @@ function parseActiveRoute(value: unknown): ProviderActiveRoute | undefined {
 export function parseProviderWorkspaceConfig(data: unknown): ProviderWorkspaceConfig {
   if (!isRecord(data)) return {};
 
-  const config: ProviderWorkspaceConfig = {};
-  const providers: Partial<Record<ProviderId, ProviderWorkspaceOverride>> = {};
-  let foundDeprecatedAntigravity = false;
+  const config: ProviderWorkspaceConfig = {};
+  const providers: Partial<Record<ProviderId, ProviderWorkspaceOverride>> = {};
+  let foundDeprecatedAntigravity = false;
+  let foundDeprecatedGoogle = false;
 
   if (isRecord(data.providers)) {
     for (const [id, value] of Object.entries(data.providers)) {
-      if (isDeprecatedAntigravityProviderId(id)) {
-        foundDeprecatedAntigravity = true;
-        continue;
-      }
-      if (!isKnownProviderId(id)) continue;
-      const override = parseProviderOverride(value);
-      if (id === "google" && override?.currentModel) {
-        override.currentModel = normalizeGeminiModelId(override.currentModel);
-      }
-      if (override) providers[id] = override;
+      if (isDeprecatedAntigravityProviderId(id)) {
+        foundDeprecatedAntigravity = true;
+        continue;
+      }
+      if (id === DEPRECATED_GOOGLE_PROVIDER_ID) {
+        foundDeprecatedGoogle = true;
+        continue;
+      }
+      if (!isKnownProviderId(id)) continue;
+      const override = parseProviderOverride(value);
+      if (override) providers[id] = override;
     }
     config.providers = providers;
   }
@@ -238,7 +245,10 @@ export function parseProviderWorkspaceConfig(data: unknown): ProviderWorkspaceCo
     ?? data.workspace_default_provider_id
     ?? data.defaultProviderId
     ?? data.default_provider_id;
-  if (isDeprecatedAntigravityProviderId(defaultProvider)) {
+  if (defaultProvider === DEPRECATED_GOOGLE_PROVIDER_ID) {
+    foundDeprecatedGoogle = true;
+    config.workspaceDefaultProviderId = resolveDeprecatedProviderFallback(providers);
+  } else if (isDeprecatedAntigravityProviderId(defaultProvider)) {
     foundDeprecatedAntigravity = true;
     config.workspaceDefaultProviderId = resolveDeprecatedProviderFallback(providers);
   } else if (typeof defaultProvider === "string" && isKnownProviderId(defaultProvider)) {
@@ -246,7 +256,12 @@ export function parseProviderWorkspaceConfig(data: unknown): ProviderWorkspaceCo
   }
 
   const rawActiveRoute = data.activeRoute ?? data.active_route;
-  if (isDeprecatedAntigravityRoute(rawActiveRoute)) {
+  if (isDeprecatedGoogleRoute(rawActiveRoute)) {
+    foundDeprecatedGoogle = true;
+    const fallbackProviderId = resolveDeprecatedProviderFallback(providers);
+    config.activeRoute = createFallbackActiveRoute(fallbackProviderId, providers);
+    config.workspaceDefaultProviderId ??= fallbackProviderId;
+  } else if (isDeprecatedAntigravityRoute(rawActiveRoute)) {
     foundDeprecatedAntigravity = true;
     const fallbackProviderId = resolveDeprecatedProviderFallback(providers);
     config.activeRoute = createFallbackActiveRoute(fallbackProviderId, providers);
@@ -258,12 +273,12 @@ export function parseProviderWorkspaceConfig(data: unknown): ProviderWorkspaceCo
     }
   }
 
-  if (foundDeprecatedAntigravity) {
+  if (foundDeprecatedGoogle || foundDeprecatedAntigravity) {
     const revertedProviderId = config.activeRoute?.providerId
       ?? config.workspaceDefaultProviderId
       ?? resolveDeprecatedProviderFallback(providers);
     config.migrationNotice = {
-      deprecatedProviderId: DEPRECATED_ANTIGRAVITY_PROVIDER_ID,
+      deprecatedProviderId: foundDeprecatedGoogle ? DEPRECATED_GOOGLE_PROVIDER_ID : DEPRECATED_ANTIGRAVITY_PROVIDER_ID,
       revertedProviderId,
     };
   }
@@ -348,13 +363,13 @@ export function saveProviderWorkspaceConfig(workspaceRoot: string, config: Provi
   renameSync(tmpFile, filePath);
 }
 
-export function setProviderWorkspaceDefault(
+export function setProviderWorkspaceDefault(
   config: ProviderWorkspaceConfig,
   providerId: ProviderId,
 ): ProviderWorkspaceConfig {
   return {
     ...config,
-    workspaceDefaultProviderId: providerId,
+    workspaceDefaultProviderId: providerId === DEPRECATED_GOOGLE_PROVIDER_ID ? "openai" : providerId,
   };
 }
 
@@ -396,7 +411,7 @@ export function setProviderActiveRoute(
   config: ProviderWorkspaceConfig,
   activeRoute: ProviderActiveRoute,
 ): ProviderWorkspaceConfig {
-  if (!isProviderRoutableInCodexa(activeRoute.providerId) || !isProviderRouteConfigured(activeRoute.providerId)) {
+  if (activeRoute.providerId === DEPRECATED_GOOGLE_PROVIDER_ID || !isProviderRoutableInCodexa(activeRoute.providerId) || !isProviderRouteConfigured(activeRoute.providerId)) {
     return config;
   }