@golba98/codexa 1.0.2 → 1.0.4

package/src/core/executables/antigravityExecutable.ts

@@ -0,0 +1,48 @@
+import { runCommand } from "../process/CommandRunner.js";
+import { resolveExecutable } from "./executableResolver.js";
+
+type CommandRunner = typeof runCommand;
+
+let cachedExecutable: string | null = null;
+
+export function resetAgyExecutableCacheForTests(): void {
+  cachedExecutable = null;
+}
+
+/**
+ * Returns the resolved Antigravity CLI executable (full path or bare name).
+ *
+ * Priority:
+ *   1. Configured path override (antigravityCommandPath)
+ *   2. AGY_EXECUTABLE env var
+ *   3. Windows PATH lookup for real files: agy.exe, agy.cmd, agy.bat, agy
+ *   4. Bare name fallback "agy" (Unix PATH resolution)
+ */
+export async function resolveAgyExecutable(options?: {
+  runCommandImpl?: CommandRunner;
+  cwd?: string;
+  configuredPath?: string | null;
+}): Promise<string> {
+  if (!options?.configuredPath && !options?.runCommandImpl && cachedExecutable !== null) {
+    return cachedExecutable;
+  }
+
+  const result = await resolveExecutable({
+    runCommandImpl: options?.runCommandImpl,
+    cwd: options?.cwd,
+    configuredPath: options?.configuredPath,
+    envOverrides: ["AGY_EXECUTABLE"],
+    commandNames: process.platform === "win32"
+      ? ["agy.exe", "agy.cmd", "agy.bat", "agy"]
+      : ["agy"],
+    knownPathDirectories: [],
+    knownFilePaths: [],
+    label: "antigravity",
+    allowBareFallback: true,
+  });
+
+  if (!options?.configuredPath && !options?.runCommandImpl) {
+    cachedExecutable = result;
+  }
+  return result;
+}

package/src/core/executables/codexExecutable.ts

@@ -101,6 +101,7 @@ export function spawnCodexProcess(
   options: SpawnOptions,
 ): ReturnType<typeof spawn> {
   const spec = buildSpawnSpec(executable, args);
+  if (!spec.executable) throw new Error("Codex executable path is empty.");
   return spawn(spec.executable, spec.args, { ...options, shell: false });
 }
 

package/src/core/executables/executableResolver.ts

@@ -21,18 +21,27 @@ export interface ExecutableResolverOptions {
   requireResolvedFile?: boolean;
 }
 
-function validateConfiguredExecutable(value: string, label: string, cwd: string): string {
-  return normalizeExecutableValue(value, {
+function validateConfiguredExecutable(value: string, label: string, cwd: string): string {
+  return normalizeExecutableValue(value, {
     label,
     cwd,
     requireExistingPath: /[\\/]/.test(value) || /^[\s"']*[A-Za-z]:/.test(value),
     allowBareExecutable: true,
-  });
-}
-
-async function resolveWithWhere(
-  runCommandImpl: CommandRunner,
-  cwd: string,
+  });
+}
+
+function validateResolvedExecutable(value: string, label: string, cwd: string): string {
+  return normalizeExecutableValue(value, {
+    label,
+    cwd,
+    requireExistingPath: false,
+    allowBareExecutable: true,
+  });
+}
+
+async function resolveWithWhere(
+  runCommandImpl: CommandRunner,
+  cwd: string,
   query: string,
   requireResolvedFile: boolean,
 ): Promise<string | null> {
@@ -47,13 +56,19 @@ async function resolveWithWhere(
   const lines = whereResult.stdout
     .trim()
     .split(/[\r\n]+/)
-    .map((l) => l.trim())
-    .filter(Boolean);
-  for (const line of lines) {
-    if (!requireResolvedFile || existsSync(line)) return line;
-  }
-  return null;
-}
+    .map((l) => l.trim())
+    .filter(Boolean);
+  for (const line of lines) {
+    let candidate: string;
+    try {
+      candidate = validateResolvedExecutable(line, "where.exe result", cwd);
+    } catch {
+      continue;
+    }
+    if (!requireResolvedFile || existsSync(candidate)) return candidate;
+  }
+  return null;
+}
 
 /**
  * Resolves an executable's location.
@@ -98,41 +113,48 @@ export async function resolveExecutable(options: ExecutableResolverOptions): Pro
       for (const candidate of options.commandNames) {
         knownCandidates.push(join(dir, candidate));
       }
-    }
-
-    for (const candidate of knownCandidates) {
-      if (existsSync(candidate)) return candidate;
-    }
-  }
-
-  // 5. Explicit known file fallbacks
-  for (const candidate of options.knownFilePaths ?? []) {
-    if (existsSync(candidate)) return candidate;
-  }
+    }
+
+    for (const candidate of knownCandidates) {
+      const validated = validateResolvedExecutable(candidate, `${options.label} known executable`, cwd);
+      if (existsSync(validated)) return validated;
+    }
+  }
+
+  // 5. Explicit known file fallbacks
+  for (const candidate of options.knownFilePaths ?? []) {
+    const validated = validateResolvedExecutable(candidate, `${options.label} known executable`, cwd);
+    if (existsSync(validated)) return validated;
+  }
 
   if (options.allowBareFallback === false) {
     throw new Error(`${options.label} executable was not found.`);
   }
 
-  // 6. Bare name fallback — prefer the name without an extension (works on Unix).
-  const bareName = options.commandNames.find((c) => !c.includes(".")) ?? options.commandNames[0];
-  return bareName!;
-}
+  // 6. Bare name fallback — prefer the name without an extension (works on Unix).
+  const bareName = options.commandNames.find((c) => !c.includes(".")) ?? options.commandNames[0];
+  return validateResolvedExecutable(bareName!, `${options.label} executable`, cwd);
+}
 
 /**
  * Builds the spawn spec for a resolved executable.
  * .cmd and .bat files must be invoked via `cmd.exe /d /s /c` on Windows.
+ *
+ * `platform` defaults to the host platform; it is injectable so the Windows
+ * wrapping branch can be unit-tested from any OS.
  */
-export function buildSpawnSpec(
-  executable: string,
-  args: string[],
-): { executable: string; args: string[] } {
-  if (process.platform === "win32") {
-    const lower = executable.toLowerCase();
-    if (lower.endsWith(".cmd") || lower.endsWith(".bat")) {
-      validateWindowsBatchExecutableForCmd(executable, "Windows batch executable");
-      return { executable: "cmd.exe", args: ["/d", "/s", "/c", "call", executable, ...args] };
-    }
-  }
-  return { executable, args };
-}
+export function buildSpawnSpec(
+  executable: string,
+  args: string[],
+  platform: NodeJS.Platform = process.platform,
+): { executable: string; args: string[] } {
+  const validatedExecutable = validateResolvedExecutable(executable, "Executable", process.cwd());
+  if (platform === "win32") {
+    const lower = validatedExecutable.toLowerCase();
+    if (lower.endsWith(".cmd") || lower.endsWith(".bat")) {
+      validateWindowsBatchExecutableForCmd(validatedExecutable, "Windows batch executable");
+      return { executable: "cmd.exe", args: ["/d", "/s", "/c", "call", validatedExecutable, ...args] };
+    }
+  }
+  return { executable: validatedExecutable, args };
+}

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/processValidation.ts

@@ -23,10 +23,14 @@ function stripBalancedWrappingQuotes(value: string): string {
   return value;
 }
 
-function looksLikePath(value: string): boolean {
-  return /[\\/]/.test(value) || /^[A-Za-z]:/.test(value);
-}
-
+function looksLikePath(value: string): boolean {
+  return /[\\/]/.test(value) || /^[A-Za-z]:/.test(value);
+}
+
+function isWindowsAbsolutePath(value: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(value);
+}
+
 function hasWindowsBatchExtension(value: string): boolean {
   return /\.(?:cmd|bat)$/i.test(value);
 }
@@ -67,7 +71,7 @@ export function normalizeExecutableValue(
     return trimmed;
   }
 
-  const normalized = isAbsolute(trimmed) ? resolve(trimmed) : resolve(cwd, trimmed);
+  const normalized = isAbsolute(trimmed) || isWindowsAbsolutePath(trimmed) ? trimmed : resolve(cwd, trimmed);
   validateCommonExecutableSyntax(normalized, options.label);
 
   if (requireExistingPath && !existsSync(normalized)) {

package/src/core/providerLauncher/launcher.ts

@@ -1,8 +1,9 @@
-import { spawn, type ChildProcess } from "child_process";
-import { existsSync } from "fs";
-import { buildSpawnSpec } from "../executables/executableResolver.js";
-import { normalizeExecutableValue } from "../process/processValidation.js";
-import type { ProviderConfig, ProviderLaunchCommand } from "./types.js";
+import { spawn, type ChildProcess } from "child_process";
+import { accessSync, constants, existsSync } from "fs";
+import { delimiter, join } from "path";
+import { buildSpawnSpec } from "../executables/executableResolver.js";
+import { normalizeExecutableValue } from "../process/processValidation.js";
+import type { ProviderConfig, ProviderLaunchCommand } from "./types.js";
 
 export interface ProviderLaunchSpec {
   executable: string;
@@ -75,43 +76,55 @@ function setRawMode(stdin: RawModeStream | null | undefined, enabled: boolean):
   }
 }
 
-function executableLooksLikePath(executable: string): boolean {
-  return /[\\/]/.test(executable) || /^[A-Za-z]:/.test(executable);
-}
-
-// Probe-spawns the executable to check if it exits cleanly — used instead of `which`/`where`
-// because path-lookup alone doesn't verify the file is actually runnable.
-function captureProcessExit(executable: string, args: string[]): Promise<boolean> {
-  return new Promise((resolve) => {
-    let child: ChildProcess;
-    try {
-      child = spawn(executable, args, {
-        stdio: "ignore",
-        shell: false,
-      });
-    } catch {
-      resolve(false);
-      return;
-    }
-
-    child.once("error", () => resolve(false));
-    child.once("close", (exitCode) => resolve(exitCode === 0));
-  });
-}
-
-export async function commandExistsOnPath(executable: string): Promise<boolean> {
-  const trimmed = executable.trim();
-  if (!trimmed) return false;
-  if (executableLooksLikePath(trimmed)) {
-    return existsSync(trimmed);
-  }
-
-  if (process.platform === "win32") {
-    return captureProcessExit("where.exe", [trimmed]);
-  }
-
-  return captureProcessExit("sh", ["-c", `command -v "$1" >/dev/null 2>&1`, "sh", trimmed]);
-}
+function executableLooksLikePath(executable: string): boolean {
+  return /[\\/]/.test(executable) || /^[A-Za-z]:/.test(executable);
+}
+
+function canAccessExecutable(path: string): boolean {
+  try {
+    if (process.platform === "win32") {
+      return existsSync(path);
+    }
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getPathExecutableCandidates(executable: string): string[] {
+  if (process.platform !== "win32" || /\.[A-Za-z0-9_-]+$/.test(executable)) {
+    return [executable];
+  }
+
+  const pathExt = process.env.PATHEXT?.split(";").filter(Boolean) ?? [".COM", ".EXE", ".BAT", ".CMD"];
+  return [executable, ...pathExt.map((ext) => `${executable}${ext.toLowerCase()}`)];
+}
+
+export async function commandExistsOnPath(executable: string): Promise<boolean> {
+  let candidate: string;
+  try {
+    candidate = normalizeExecutableValue(executable, {
+      label: "Provider launch command",
+      allowBareExecutable: true,
+    });
+  } catch {
+    return false;
+  }
+
+  const trimmed = candidate.trim();
+  if (executableLooksLikePath(trimmed)) {
+    return canAccessExecutable(trimmed);
+  }
+
+  const pathEntries = process.env.PATH?.split(delimiter).filter(Boolean) ?? [];
+  for (const dir of pathEntries) {
+    for (const name of getPathExecutableCandidates(trimmed)) {
+      if (canAccessExecutable(join(dir, name))) return true;
+    }
+  }
+  return false;
+}
 
 function formatSpawnError(provider: ProviderConfig, executable: string, error: NodeJS.ErrnoException): ProviderLaunchResult {
   if (error.code === "ENOENT") {
@@ -162,6 +175,10 @@ export async function launchProviderCli(
       let child: ChildProcess;
       try {
         const spawnSpec = buildSpawnSpec(spec.executable, spec.args);
+        if (!spawnSpec.executable) {
+          resolve({ status: "spawn-error", message: "Executable path is empty after resolution." });
+          return;
+        }
         child = spawnImpl(spawnSpec.executable, spawnSpec.args, {
           cwd: spec.cwd,
           shell: false,

package/src/core/providerLauncher/registry.ts

@@ -14,12 +14,16 @@ 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 { 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", "local", "antigravity"];
+const KNOWN_PROVIDER_IDS: readonly ProviderId[] = ["openai", "anthropic", "google", "local", "antigravity"];
 
 const DEFAULT_PROVIDER_ID: ProviderId = "openai";
 
@@ -63,8 +67,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 +76,23 @@ 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.",
+  },
+  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 {
@@ -128,13 +143,14 @@ function applyOverride(
   };
 }
 
-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;
 }

package/src/core/providerLauncher/types.ts

@@ -1,10 +1,11 @@
-export type ProviderId = "openai" | "anthropic" | "google" | "local";
+export type ProviderId = "openai" | "anthropic" | "google" | "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"
+  | "antigravity-cli-auth"
+  | "openai-api-key"
   | "gemini-api-key"
   | "anthropic-api-key"
   | "local-openai-compatible"
@@ -69,10 +70,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;
   }