claudish 7.29.1 → 7.30.0

package/dist/index.js

@@ -651,7 +651,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.29.1";
+var VERSION = "7.30.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -27704,6 +27704,26 @@ var init_provider_definitions = __esm(() => {
       isDirectApi: true,
       description: "Direct Gemini API (g@, google@)"
     },
+    {
+      name: "antigravity",
+      displayName: "Antigravity",
+      transport: "antigravity",
+      baseUrl: "https://cloudcode-pa.googleapis.com",
+      apiPath: "/v1internal:streamGenerateContent?alt=sse",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Antigravity (shared OAuth token)",
+      apiKeyUrl: "https://antigravity.google/",
+      oauthLoginSlug: "gemini",
+      shortcuts: ["ag", "antigravity", "go"],
+      shortestPrefix: "ag",
+      legacyPrefixes: [
+        { prefix: "ag/", stripPrefix: true },
+        { prefix: "antigravity/", stripPrefix: true },
+        { prefix: "go/", stripPrefix: true }
+      ],
+      isDirectApi: true,
+      description: "Antigravity subscription (ag@; go@ deprecated)"
+    },
     {
       name: "gemini-codeassist",
       displayName: "Gemini Code Assist",
@@ -27714,11 +27734,11 @@ var init_provider_definitions = __esm(() => {
       apiKeyDescription: "Gemini Code Assist (OAuth)",
       apiKeyUrl: "https://cloud.google.com/code-assist",
       oauthLoginSlug: "gemini",
-      shortcuts: ["go"],
-      shortestPrefix: "go",
-      legacyPrefixes: [{ prefix: "go/", stripPrefix: true }],
+      shortcuts: [],
+      shortestPrefix: "gemini-codeassist",
+      legacyPrefixes: [],
       isDirectApi: true,
-      description: "Gemini Code Assist OAuth (go@)"
+      description: "Gemini Code Assist OAuth (routing fallback for gemini-*)"
     },
     {
       name: "openai",
@@ -28231,125 +28251,191 @@ var init_provider_definitions = __esm(() => {
   ];
 });
 
-// src/auth/credentials/api-key-credential.ts
+// src/auth/antigravity-token.ts
+import { execFileSync } from "child_process";
 import { existsSync as existsSync6 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join8 } from "path";
-function realValue(v) {
-  if (!v)
-    return;
-  return UNEXPANDED_PLACEHOLDER.test(v.trim()) ? undefined : v;
+function defaultReadStore() {
+  if (process.platform !== "darwin") {
+    logStderr("[Antigravity] Shared token store is macOS-only for now (other keyring backends are a follow-up).");
+    return null;
+  }
+  try {
+    const out = execFileSync("security", ["find-generic-password", "-s", KC_SERVICE, "-a", KC_ACCOUNT, "-w"], { encoding: "utf8" });
+    const trimmed = out.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
 }
-
-class ApiKeyCredentialProvider {
-  catalogName;
-  envVar;
-  aliases;
-  authScheme;
-  staticHeaders;
-  publicKeyFallback;
-  oauthFallback;
-  declaredKey;
-  cachedKey;
-  resolving;
-  constructor(descriptor) {
-    this.catalogName = descriptor.catalogName;
-    this.envVar = descriptor.envVar;
-    this.aliases = descriptor.aliases ?? [];
-    this.authScheme = descriptor.authScheme ?? "bearer";
-    this.staticHeaders = descriptor.staticHeaders ?? {};
-    this.publicKeyFallback = descriptor.publicKeyFallback;
-    this.oauthFallback = descriptor.oauthFallback;
-    this.declaredKey = descriptor.declaredKey;
+function defaultWriteStore(rawValue) {
+  if (process.platform !== "darwin") {
+    throw new Error("[Antigravity] Cannot write the shared token store on a non-macOS platform.");
   }
-  resolveFromEnvConfig() {
-    return realValue(process.env[this.envVar]) || this.aliases.map((a) => realValue(process.env[a])).find((v) => !!v) || realValue(getApiKey(this.envVar)) || realValue(this.resolveDeclared());
+  execFileSync("security", ["add-generic-password", "-U", "-s", KC_SERVICE, "-a", KC_ACCOUNT, "-w", rawValue], { stdio: ["ignore", "ignore", "ignore"] });
+}
+function locateAgyBinary() {
+  try {
+    const p = execFileSync("which", ["agy"], { encoding: "utf8" }).trim();
+    if (p.length > 0)
+      return p;
+  } catch {}
+  const fallback = join8(homedir8(), ".local", "bin", "agy");
+  return existsSync6(fallback) ? fallback : null;
+}
+function defaultExtractCreds() {
+  const agy = locateAgyBinary();
+  if (!agy) {
+    logStderr("[Antigravity] Could not locate the `agy` binary \u2014 self-refresh is unavailable.");
+    return [];
   }
-  resolveDeclared() {
-    try {
-      return this.declaredKey?.() || undefined;
-    } catch {
-      return;
-    }
+  let dump;
+  try {
+    dump = execFileSync("strings", [agy], {
+      encoding: "utf8",
+      maxBuffer: 128 * 1024 * 1024
+    });
+  } catch {
+    logStderr("[Antigravity] `strings` failed on the agy binary \u2014 self-refresh is unavailable.");
+    return [];
   }
-  hasOauthFallbackFile() {
-    if (!this.oauthFallback)
-      return false;
-    try {
-      return existsSync6(join8(homedir8(), ".claudish", this.oauthFallback));
-    } catch {
-      return false;
+  const clientIds = Array.from(new Set(dump.match(/[0-9]{6,}-[a-z0-9]+\.apps\.googleusercontent\.com/g) ?? []));
+  const secrets = Array.from(new Set(dump.match(/GOCSPX-[A-Za-z0-9_-]{20,}/g) ?? []));
+  const combos = [];
+  for (const clientId of clientIds) {
+    for (const clientSecret of secrets) {
+      combos.push({ clientId, clientSecret });
     }
   }
-  async resolveKey(opts) {
-    if (this.cachedKey !== undefined)
-      return this.cachedKey;
-    if (this.resolving)
-      return this.resolving;
-    this.resolving = (async () => {
-      const local = this.resolveFromEnvConfig();
-      if (local) {
-        this.cachedKey = local;
-        return local;
-      }
-      if (hasOpSources()) {
-        const wanted = new Set([this.envVar, ...this.aliases]);
-        const resolved = await resolveOpKeyForEnvVars(wanted, {
-          onAuthFailure: "skip",
-          allowPrompt: opts?.allowOpPrompt ?? false
-        });
-        const value = resolved[this.envVar] ?? this.aliases.map((a) => resolved[a]).find((v) => !!v);
-        if (value) {
-          process.env[this.envVar] = value;
-          this.cachedKey = value;
-          return value;
-        }
-        return "";
-      }
-      this.cachedKey = "";
-      return "";
-    })();
-    try {
-      return await this.resolving;
-    } finally {
-      this.resolving = undefined;
-    }
+  return combos;
+}
+function parseRecord(raw) {
+  if (!raw)
+    return null;
+  if (!raw.startsWith(PREFIX)) {
+    logStderr("[Antigravity] Shared token is in an unsupported keyring format (not go-keyring-base64) \u2014 skipping.");
+    return null;
   }
-  async isAvailable(opts) {
-    if (this.publicKeyFallback)
-      return true;
-    if (this.resolveFromEnvConfig())
-      return true;
-    if (this.hasOauthFallbackFile())
-      return true;
-    const key = await this.resolveKey(opts);
-    return !!key;
+  try {
+    const json2 = Buffer.from(raw.slice(PREFIX.length), "base64").toString("utf8");
+    const rec = JSON.parse(json2);
+    if (!rec?.token?.access_token)
+      return null;
+    return rec;
+  } catch (err) {
+    log(`[Antigravity] Failed to decode shared token: ${err}`);
+    return null;
   }
-  invalidate() {
-    this.cachedKey = undefined;
-    this.resolving = undefined;
+}
+function encodeRecord(rec) {
+  return PREFIX + Buffer.from(JSON.stringify(rec), "utf8").toString("base64");
+}
+function readSharedAntigravityToken(deps = defaultDeps) {
+  const rec = parseRecord(deps.readStore());
+  return rec ? rec.token : null;
+}
+function hasSharedAntigravityToken(deps = defaultDeps) {
+  const now = Date.now();
+  if (cachedHasToken && now - cachedHasToken.at < HAS_TOKEN_TTL_MS)
+    return cachedHasToken.value;
+  let value = false;
+  try {
+    value = readSharedAntigravityToken(deps) != null;
+  } catch {
+    value = false;
   }
-  async getRequestAuth(ctx) {
-    const key = await this.resolveKey({ allowOpPrompt: ctx.allowOpPrompt }) || this.publicKeyFallback || "";
-    let headers;
-    if (this.authScheme === "x-api-key") {
-      headers = { "x-api-key": key, ...this.staticHeaders };
-    } else if (key) {
-      headers = { Authorization: `Bearer ${key}`, ...this.staticHeaders };
-    } else {
-      headers = { ...this.staticHeaders };
+  cachedHasToken = { at: now, value };
+  return value;
+}
+function writeSharedAntigravityToken(tok, deps = defaultDeps) {
+  const existing = parseRecord(deps.readStore());
+  const base = existing ?? { token: tok };
+  const merged = {
+    ...base,
+    token: { ...base.token, ...tok }
+  };
+  deps.writeStore(encodeRecord(merged));
+}
+function needsRefresh(tok, now) {
+  const expMs = Date.parse(tok.expiry);
+  if (Number.isNaN(expMs))
+    return true;
+  return now >= expMs - EXPIRY_SKEW_MS;
+}
+async function refreshToken(tok, deps) {
+  const combos = cachedCred ? [cachedCred] : deps.extractCreds();
+  if (combos.length === 0) {
+    throw new Error("[Antigravity] Access token expired and no OAuth client credentials could be extracted " + "from the `agy` binary to refresh it. Re-run the Antigravity CLI to refresh your session, " + "or use g@<model> with GEMINI_API_KEY.");
+  }
+  let lastStatus = 0;
+  let lastBody = "";
+  for (const cred of combos) {
+    const res = await deps.fetch(REFRESH_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        client_id: cred.clientId,
+        client_secret: cred.clientSecret,
+        refresh_token: tok.refresh_token,
+        grant_type: "refresh_token"
+      })
+    });
+    if (res.ok) {
+      cachedCred = cred;
+      const j = await res.json();
+      const expiry = new Date(deps.now() + j.expires_in * 1000).toISOString();
+      return {
+        access_token: j.access_token,
+        token_type: tok.token_type || "Bearer",
+        refresh_token: j.refresh_token || tok.refresh_token,
+        expiry
+      };
     }
-    return { headers };
+    lastStatus = res.status;
+    lastBody = await res.text().catch(() => "");
   }
+  throw new Error(`[Antigravity] Token refresh failed for all ${combos.length} client-cred combo(s) ` + `(last HTTP ${lastStatus}${lastBody ? `: ${lastBody.slice(0, 200)}` : ""}). ` + "Re-run the Antigravity CLI to refresh your session, or use g@<model> with GEMINI_API_KEY.");
 }
-var UNEXPANDED_PLACEHOLDER;
-var init_api_key_credential = __esm(() => {
-  init_profile_config();
-  init_op_source();
-  UNEXPANDED_PLACEHOLDER = /^\$\{[^}]*\}$/;
+async function resolveValidToken(deps) {
+  if (process.platform !== "darwin") {
+    throw new Error("[Antigravity] The shared Antigravity token store is macOS-only for now. " + "Use g@<model> with GEMINI_API_KEY on this platform.");
+  }
+  const rec = parseRecord(deps.readStore());
+  if (!rec) {
+    throw new Error("[Antigravity] No Antigravity session found. Install Antigravity and sign in " + "(the `agy` CLI), or use g@<model> with GEMINI_API_KEY " + "(get one at https://aistudio.google.com/app/apikey).");
+  }
+  const tok = rec.token;
+  if (!needsRefresh(tok, deps.now())) {
+    return tok.access_token;
+  }
+  log("[Antigravity] Access token expired/near-expiry \u2014 refreshing.");
+  const refreshed = await refreshToken(tok, deps);
+  writeSharedAntigravityToken(refreshed, deps);
+  log("[Antigravity] Token refreshed and written back to the shared store.");
+  return refreshed.access_token;
+}
+function getValidAntigravityAccessToken(deps = defaultDeps) {
+  if (inFlight)
+    return inFlight;
+  inFlight = resolveValidToken(deps).finally(() => {
+    inFlight = null;
+  });
+  return inFlight;
+}
+var KC_SERVICE = "gemini", KC_ACCOUNT = "antigravity", PREFIX = "go-keyring-base64:", REFRESH_ENDPOINT = "https://oauth2.googleapis.com/token", EXPIRY_SKEW_MS = 120000, defaultDeps, cachedHasToken = null, HAS_TOKEN_TTL_MS = 5000, cachedCred = null, inFlight = null;
+var init_antigravity_token = __esm(() => {
+  init_logger();
+  defaultDeps = {
+    readStore: defaultReadStore,
+    writeStore: defaultWriteStore,
+    extractCreds: defaultExtractCreds,
+    fetch: (input, init) => fetch(input, init),
+    now: () => Date.now()
+  };
 });
 
-// src/auth/codex-oauth.ts
+// src/auth/gemini-oauth.ts
 import { exec } from "child_process";
 import { createHash as createHash2, randomBytes } from "crypto";
 import { closeSync as closeSync2, existsSync as existsSync7, openSync as openSync2, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeSync as writeSync2 } from "fs";
@@ -28357,18 +28443,25 @@ import { createServer } from "http";
 import { homedir as homedir9 } from "os";
 import { join as join9 } from "path";
 import { promisify } from "util";
+function buildCodeAssistUserAgent(model) {
+  if (USE_LEGACY_GEMINI_IDENTITY) {
+    const modelSegment = model || "gemini-code-assist";
+    return `GeminiCLI/0.5.6/${modelSegment} (${process.platform}; ${process.arch})`;
+  }
+  return `antigravity/cli/1.1.9 (aidev_client; os_type=${process.platform}; arch=${process.arch}; auth_method=consumer)`;
+}
 
-class CodexOAuth {
+class GeminiOAuth {
   static instance = null;
   credentials = null;
   refreshPromise = null;
   tokenRefreshMargin = 5 * 60 * 1000;
   oauthState = null;
   static getInstance() {
-    if (!CodexOAuth.instance) {
-      CodexOAuth.instance = new CodexOAuth;
+    if (!GeminiOAuth.instance) {
+      GeminiOAuth.instance = new GeminiOAuth;
     }
-    return CodexOAuth.instance;
+    return GeminiOAuth.instance;
   }
   constructor() {
     this.credentials = this.loadCredentials();
@@ -28382,60 +28475,55 @@ class CodexOAuth {
   }
   getCredentialsPath() {
     const claudishDir = join9(homedir9(), ".claudish");
-    return join9(claudishDir, "codex-oauth.json");
+    return join9(claudishDir, "gemini-oauth.json");
   }
   async login() {
-    log("[CodexOAuth] Starting OAuth login flow");
+    log("[GeminiOAuth] Starting OAuth login flow");
     const codeVerifier = this.generateCodeVerifier();
     const codeChallenge = await this.generateCodeChallenge(codeVerifier);
     this.oauthState = randomBytes(32).toString("base64url");
     const { authCode, redirectUri } = await this.startCallbackServer(codeChallenge, this.oauthState);
     const tokens = await this.exchangeCodeForTokens(authCode, codeVerifier, redirectUri);
-    const accountId = tokens.id_token ? this.extractAccountId(tokens.id_token) : undefined;
     const credentials = {
       access_token: tokens.access_token,
       refresh_token: tokens.refresh_token,
-      expires_at: Date.now() + tokens.expires_in * 1000,
-      account_id: accountId
+      expires_at: Date.now() + tokens.expires_in * 1000
     };
     this.saveCredentials(credentials);
     this.credentials = credentials;
     this.oauthState = null;
-    log("[CodexOAuth] Login successful");
-    if (accountId) {
-      log(`[CodexOAuth] Account ID: ${accountId}`);
-    }
+    log("[GeminiOAuth] Login successful");
   }
   async logout() {
     const credPath = this.getCredentialsPath();
     if (existsSync7(credPath)) {
       unlinkSync2(credPath);
-      log("[CodexOAuth] Credentials deleted");
+      log("[GeminiOAuth] Credentials deleted");
     }
     this.credentials = null;
   }
   async getAccessToken() {
     if (this.refreshPromise) {
-      log("[CodexOAuth] Waiting for in-progress refresh");
+      log("[GeminiOAuth] Waiting for in-progress refresh");
       return this.refreshPromise;
     }
     if (!this.credentials) {
-      throw new Error("No OpenAI Codex OAuth credentials found. Please run `claudish login codex` first.");
+      throw new Error("No Gemini OAuth credentials found. Please run `claudish login gemini` first.");
     }
     if (this.isTokenValid()) {
       return this.credentials.access_token;
     }
-    this.refreshPromise = this.doRefreshToken().finally(() => {
+    this.refreshPromise = this.doRefreshToken();
+    try {
+      const token = await this.refreshPromise;
+      return token;
+    } finally {
       this.refreshPromise = null;
-    });
-    return this.refreshPromise;
-  }
-  getAccountId() {
-    return this.credentials?.account_id;
+    }
   }
   async refreshToken() {
     if (!this.credentials) {
-      throw new Error("No OpenAI Codex OAuth credentials found. Please run `claudish login codex` first.");
+      throw new Error("No Gemini OAuth credentials found. Please run `claudish login gemini` first.");
     }
     await this.doRefreshToken();
   }
@@ -28446,19 +28534,20 @@ class CodexOAuth {
   }
   async doRefreshToken() {
     if (!this.credentials) {
-      throw new Error("No OpenAI Codex OAuth credentials found. Please run `claudish login codex` first.");
+      throw new Error("No Gemini OAuth credentials found. Please run `claudish login gemini` first.");
     }
-    log("[CodexOAuth] Refreshing access token");
+    log("[GeminiOAuth] Refreshing access token");
     try {
       const response = await fetch(OAUTH_CONFIG.tokenUrl, {
         method: "POST",
         headers: {
-          "Content-Type": "application/json"
+          "Content-Type": "application/x-www-form-urlencoded"
         },
-        body: JSON.stringify({
+        body: new URLSearchParams({
           grant_type: "refresh_token",
           refresh_token: this.credentials.refresh_token,
-          client_id: OAUTH_CONFIG.clientId
+          client_id: OAUTH_CONFIG.clientId,
+          client_secret: OAUTH_CONFIG.clientSecret
         })
       });
       if (!response.ok) {
@@ -28466,20 +28555,18 @@ class CodexOAuth {
         throw new Error(`Token refresh failed: ${response.status} - ${errorText}`);
       }
       const tokens = await response.json();
-      const accountId = tokens.id_token ? this.extractAccountId(tokens.id_token) : this.credentials.account_id;
       const updatedCredentials = {
         access_token: tokens.access_token,
         refresh_token: tokens.refresh_token || this.credentials.refresh_token,
-        expires_at: Date.now() + tokens.expires_in * 1000,
-        account_id: accountId
+        expires_at: Date.now() + tokens.expires_in * 1000
       };
       this.saveCredentials(updatedCredentials);
       this.credentials = updatedCredentials;
-      log(`[CodexOAuth] Token refreshed, valid until ${new Date(updatedCredentials.expires_at).toISOString()}`);
+      log(`[GeminiOAuth] Token refreshed, valid until ${new Date(updatedCredentials.expires_at).toISOString()}`);
       return updatedCredentials.access_token;
     } catch (e) {
-      log(`[CodexOAuth] Refresh failed: ${e.message}`);
-      throw new Error(`OAuth credentials invalid. Please run \`claudish login codex\` again.
+      log(`[GeminiOAuth] Refresh failed: ${e.message}`);
+      throw new Error(`OAuth credentials invalid. Please run \`claudish login gemini\` again.
 
 Details: ${e.message}`);
     }
@@ -28493,13 +28580,13 @@ Details: ${e.message}`);
       const data = readFileSync6(credPath, "utf-8");
       const credentials = JSON.parse(data);
       if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at) {
-        log("[CodexOAuth] Invalid credentials file structure");
+        log("[GeminiOAuth] Invalid credentials file structure");
         return null;
       }
-      log("[CodexOAuth] Loaded credentials from file");
+      log("[GeminiOAuth] Loaded credentials from file");
       return credentials;
     } catch (e) {
-      log(`[CodexOAuth] Failed to load credentials: ${e.message}`);
+      log(`[GeminiOAuth] Failed to load credentials: ${e.message}`);
       return null;
     }
   }
@@ -28517,7 +28604,7 @@ Details: ${e.message}`);
     } finally {
       closeSync2(fd);
     }
-    log(`[CodexOAuth] Credentials saved to ${credPath}`);
+    log(`[GeminiOAuth] Credentials saved to ${credPath}`);
   }
   generateCodeVerifier() {
     return randomBytes(64).toString("base64url");
@@ -28526,46 +28613,26 @@ Details: ${e.message}`);
     const hash2 = createHash2("sha256").update(verifier).digest("base64url");
     return hash2;
   }
-  extractAccountId(idToken) {
-    try {
-      const parts = idToken.split(".");
-      if (parts.length !== 3)
-        return;
-      const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8"));
-      const authClaim = payload["https://api.openai.com/auth"];
-      const accountId = authClaim?.chatgpt_account_id || payload.chatgpt_account_id || authClaim?.user_id;
-      if (accountId) {
-        log(`[CodexOAuth] Extracted account ID from id_token: ${accountId}`);
-        return accountId;
-      }
-      return;
-    } catch (e) {
-      log(`[CodexOAuth] Failed to extract account ID from id_token: ${e.message}`);
-      return;
-    }
-  }
   buildAuthUrl(codeChallenge, state, redirectUri) {
-    const scope = OAUTH_CONFIG.scopes.join("+");
-    const params = [
-      "response_type=code",
-      `client_id=${encodeURIComponent(OAUTH_CONFIG.clientId)}`,
-      `redirect_uri=${encodeURIComponent(redirectUri)}`,
-      `scope=${scope}`,
-      `code_challenge=${encodeURIComponent(codeChallenge)}`,
-      "code_challenge_method=S256",
-      "id_token_add_organizations=true",
-      "codex_cli_simplified_flow=true",
-      `state=${encodeURIComponent(state)}`,
-      "originator=opencode"
-    ].join("&");
-    return `${OAUTH_CONFIG.authUrl}?${params}`;
+    const params = new URLSearchParams({
+      client_id: OAUTH_CONFIG.clientId,
+      redirect_uri: redirectUri,
+      response_type: "code",
+      scope: OAUTH_CONFIG.scopes.join(" "),
+      code_challenge: codeChallenge,
+      code_challenge_method: "S256",
+      access_type: "offline",
+      prompt: "consent",
+      state
+    });
+    return `${OAUTH_CONFIG.authUrl}?${params.toString()}`;
   }
   async startCallbackServer(codeChallenge, state) {
     return new Promise((resolve, reject) => {
       let redirectUri = "";
       const server = createServer((req, res) => {
-        const url2 = new URL(req.url, redirectUri.replace("/auth/callback", ""));
-        if (url2.pathname === "/auth/callback") {
+        const url2 = new URL(req.url, redirectUri.replace("/callback", ""));
+        if (url2.pathname === "/callback") {
           const code = url2.searchParams.get("code");
           const callbackState = url2.searchParams.get("state");
           const error46 = url2.searchParams.get("error");
@@ -28630,15 +28697,15 @@ Details: ${e.message}`);
           res.end("Not found");
         }
       });
-      server.listen(1455, () => {
+      server.listen(0, () => {
         const address = server.address();
         if (!address || typeof address === "string") {
           reject(new Error("Failed to get server port"));
           return;
         }
         const port = address.port;
-        redirectUri = `http://localhost:${port}/auth/callback`;
-        log(`[CodexOAuth] Callback server started on http://localhost:${port}`);
+        redirectUri = `http://localhost:${port}/callback`;
+        log(`[GeminiOAuth] Callback server started on http://localhost:${port}`);
         const authUrl = this.buildAuthUrl(codeChallenge, state, redirectUri);
         this.openBrowser(authUrl);
       });
@@ -28652,7 +28719,7 @@ Details: ${e.message}`);
     });
   }
   async exchangeCodeForTokens(code, verifier, redirectUri) {
-    log("[CodexOAuth] Exchanging auth code for tokens");
+    log("[GeminiOAuth] Exchanging auth code for tokens");
     try {
       const response = await fetch(OAUTH_CONFIG.tokenUrl, {
         method: "POST",
@@ -28664,6 +28731,7 @@ Details: ${e.message}`);
           code,
           redirect_uri: redirectUri,
           client_id: OAUTH_CONFIG.clientId,
+          client_secret: OAUTH_CONFIG.clientSecret,
           code_verifier: verifier
         })
       });
@@ -28677,7 +28745,7 @@ Details: ${e.message}`);
       }
       return tokens;
     } catch (e) {
-      throw new Error(`Failed to authenticate with OpenAI OAuth: ${e.message}`);
+      throw new Error(`Failed to authenticate with Google OAuth: ${e.message}`);
     }
   }
   async openBrowser(url2) {
@@ -28691,7 +28759,7 @@ Details: ${e.message}`);
         await execAsync(`xdg-open "${url2}"`);
       }
       console.log(`
-Opening browser for OpenAI authentication...`);
+Opening browser for authentication...`);
       console.log(`If the browser doesn't open, visit this URL:
 ${url2}
 `);
@@ -28703,136 +28771,1006 @@ Please open this URL in your browser to authenticate:`);
     }
   }
 }
-function getCodexOAuth() {
-  return CodexOAuth.getInstance();
+function reloadGeminiCredentials() {
+  GeminiOAuth.getInstance().reloadCredentials();
+  resetGeminiUserCache();
 }
-var execAsync, OAUTH_CONFIG;
-var init_codex_oauth = __esm(() => {
+function rankCodeAssistModel(model) {
+  const lower = model.toLowerCase();
+  let tier;
+  if (lower.includes("pro"))
+    tier = 0;
+  else if (lower.includes("lite"))
+    tier = 2;
+  else if (lower.includes("flash"))
+    tier = 1;
+  else
+    tier = 3;
+  const vMatch = lower.match(/^gemini-(\d+(?:\.\d+)?)(?![\d.])/);
+  const version2 = vMatch ? Number.parseFloat(vMatch[1]) : 0;
+  return tier * 1000 - version2;
+}
+async function getServedCodeAssistModels(accessToken, projectId, opts) {
+  const now = Date.now();
+  if (!opts?.force && servedModelsCache && now - servedModelsCacheAt < SERVED_MODELS_TTL_MS) {
+    return servedModelsCache;
+  }
+  try {
+    const data = await retrieveUserQuota(accessToken, projectId);
+    const ids = (data?.buckets ?? []).map((b) => b.modelId).filter((m) => typeof m === "string" && m.length > 0);
+    if (ids.length > 0) {
+      const sorted = ids.slice().sort((a, b) => rankCodeAssistModel(a) - rankCodeAssistModel(b));
+      servedModelsCache = sorted;
+      servedModelsCacheAt = now;
+      return sorted;
+    }
+  } catch (err) {
+    log(`[GeminiOAuth] getServedCodeAssistModels error: ${err}`);
+  }
+  if (servedModelsCache)
+    return servedModelsCache;
+  return CODE_ASSIST_FALLBACK_CHAIN.slice().sort((a, b) => rankCodeAssistModel(a) - rankCodeAssistModel(b));
+}
+async function getValidAccessToken() {
+  const oauth = GeminiOAuth.getInstance();
+  return oauth.getAccessToken();
+}
+function resetGeminiUserCache() {
+  cachedProjectId = null;
+  cachedTierId = null;
+  cachedTierName = null;
+  cachedSetupError = null;
+}
+function getGeminiTierDisplayName() {
+  if (!cachedTierId)
+    return "GeminiCA";
+  return TIER_SHORT_NAMES[cachedTierId] || cachedTierId.replace(/-tier$/, "");
+}
+function getGeminiTierFullName() {
+  if (cachedTierName)
+    return cachedTierName;
+  return getGeminiTierDisplayName();
+}
+function makeTerminalSetupError(message) {
+  const err = new Error(message);
+  err.terminal = true;
+  return err;
+}
+function buildProjectRequiredError(tierId, chosenTier, loadRes) {
+  const tierLabel = chosenTier?.name || chosenTier?.displayName || tierId;
+  const lines = [
+    `Gemini Code Assist requires a Google Cloud project for the "${tierLabel}" tier (${tierId}), and none is configured.`,
+    "",
+    "Set the project that holds your Code Assist license:",
+    "  export GOOGLE_CLOUD_PROJECT='your-project-id'"
+  ];
+  const refused = loadRes.ineligibleTiers ?? [];
+  if (refused.length > 0) {
+    lines.push("", "Google refused the other tier(s) on this account:");
+    for (const t of refused) {
+      const name = t.tierName || t.tierId || "unknown tier";
+      const code = t.reasonCode ? ` [${t.reasonCode}]` : "";
+      lines.push(`  \u2022 ${name}${code}`);
+      if (t.reasonMessage)
+        lines.push(`    ${t.reasonMessage}`);
+    }
+  }
+  lines.push("", "No project / no Code Assist seat? Use the direct Gemini API instead:", "  export GEMINI_API_KEY='your-key'   # https://aistudio.google.com/app/apikey", '  claudish --model google@gemini-2.5-pro "..."');
+  return lines.join(`
+`);
+}
+async function setupGeminiUser(accessToken) {
+  if (cachedProjectId && cachedTierId) {
+    log(`[GeminiOAuth] Using cached project ID: ${cachedProjectId}, tier: ${cachedTierId}`);
+    return { projectId: cachedProjectId, tierId: cachedTierId };
+  }
+  if (cachedSetupError) {
+    log("[GeminiOAuth] Re-raising cached setup failure (no network retry)");
+    throw makeTerminalSetupError(cachedSetupError);
+  }
+  const envProject = process.env.GOOGLE_CLOUD_PROJECT || process.env.GOOGLE_CLOUD_PROJECT_ID;
+  log("[GeminiOAuth] Calling loadCodeAssist...");
+  const loadRes = await callLoadCodeAssist(accessToken, envProject);
+  log(`[GeminiOAuth] loadCodeAssist response: ${JSON.stringify(loadRes)}`);
+  const resolvedTier = loadRes.paidTier?.id || (typeof loadRes.currentTier === "object" ? loadRes.currentTier?.id : loadRes.currentTier) || null;
+  if ((loadRes.currentTier || loadRes.paidTier) && loadRes.cloudaicompanionProject) {
+    const projectId2 = envProject || loadRes.cloudaicompanionProject;
+    if (projectId2) {
+      cachedProjectId = projectId2;
+      cachedTierId = resolvedTier || "free-tier";
+      cachedTierName = loadRes.paidTier?.name || null;
+      log(`[GeminiOAuth] User already set up, project: ${projectId2}, tier: ${cachedTierId}`);
+      return { projectId: projectId2, tierId: cachedTierId };
+    }
+  }
+  const tierId = resolvedTier || loadRes.allowedTiers?.[0]?.id || "free-tier";
+  const isFree = tierId === "free-tier";
+  const onboardProject = isFree ? undefined : envProject;
+  const chosenTier = loadRes.allowedTiers?.find((t) => t.id === tierId);
+  if (!isFree && chosenTier?.userDefinedCloudaicompanionProject && !onboardProject) {
+    cachedSetupError = buildProjectRequiredError(tierId, chosenTier, loadRes);
+    throw makeTerminalSetupError(cachedSetupError);
+  }
+  const MAX_POLL_ATTEMPTS = 30;
+  log(`[GeminiOAuth] Onboarding user to ${tierId}...`);
+  let lro = await callOnboardUser(accessToken, tierId, onboardProject);
+  log(`[GeminiOAuth] Initial onboardUser response: done=${lro.done}`);
+  let attempts = 0;
+  while (!lro.done && attempts < MAX_POLL_ATTEMPTS) {
+    attempts++;
+    log(`[GeminiOAuth] Polling onboardUser (attempt ${attempts}/${MAX_POLL_ATTEMPTS})...`);
+    await new Promise((r) => setTimeout(r, 2000));
+    lro = await callOnboardUser(accessToken, tierId, onboardProject);
+  }
+  if (!lro.done) {
+    throw new Error(`Gemini onboarding timed out after ${MAX_POLL_ATTEMPTS * 2} seconds`);
+  }
+  if (lro.error) {
+    throw new Error(`Gemini onboarding failed: ${JSON.stringify(lro.error)}`);
+  }
+  const projectId = lro.response?.cloudaicompanionProject?.id;
+  if (!projectId) {
+    if (envProject) {
+      cachedProjectId = envProject;
+      cachedTierId = tierId;
+      return { projectId: envProject, tierId };
+    }
+    cachedSetupError = buildProjectRequiredError(tierId, chosenTier, loadRes);
+    throw makeTerminalSetupError(cachedSetupError);
+  }
+  cachedProjectId = projectId;
+  cachedTierId = tierId;
+  log(`[GeminiOAuth] Onboarding complete, project: ${projectId}, tier: ${tierId}`);
+  return { projectId, tierId };
+}
+async function callLoadCodeAssist(accessToken, projectId) {
+  const metadata = GEMINI_IDENTITY_IS_ANTIGRAVITY ? { ideType: GEMINI_IDE_TYPE } : {
+    pluginType: "GEMINI",
+    ideType: GEMINI_IDE_TYPE,
+    platform: "PLATFORM_UNSPECIFIED",
+    duetProject: projectId
+  };
+  const res = await fetch(`${CODE_ASSIST_API_BASE}:loadCodeAssist`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "User-Agent": buildCodeAssistUserAgent()
+    },
+    body: JSON.stringify({ metadata, cloudaicompanionProject: projectId })
+  });
+  if (!res.ok) {
+    throw new Error(`loadCodeAssist failed: ${res.status} ${await res.text()}`);
+  }
+  return await res.json();
+}
+async function callOnboardUser(accessToken, tierId, projectId) {
+  const metadata = {
+    pluginType: "GEMINI",
+    ideType: GEMINI_IDE_TYPE,
+    platform: "PLATFORM_UNSPECIFIED",
+    duetProject: projectId
+  };
+  const res = await fetch(`${CODE_ASSIST_API_BASE}:onboardUser`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "User-Agent": buildCodeAssistUserAgent()
+    },
+    body: JSON.stringify({
+      tierId,
+      metadata,
+      cloudaicompanionProject: projectId
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`onboardUser failed: ${res.status} ${await res.text()}`);
+  }
+  return await res.json();
+}
+async function retrieveUserQuota(accessToken, projectId) {
+  try {
+    const res = await fetch(`${CODE_ASSIST_API_BASE}:retrieveUserQuota`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "User-Agent": `GeminiCLI/0.5.6/gemini-code-assist (${process.platform}; ${process.arch})`
+      },
+      body: JSON.stringify({ project: projectId })
+    });
+    if (!res.ok) {
+      log(`[GeminiOAuth] retrieveUserQuota failed: ${res.status}`);
+      return null;
+    }
+    return await res.json();
+  } catch (err) {
+    log(`[GeminiOAuth] retrieveUserQuota error: ${err}`);
+    return null;
+  }
+}
+function buildAntigravityUserAgent() {
+  return `antigravity/cli/1.1.9 (aidev_client; os_type=${process.platform}; arch=${process.arch}; auth_method=consumer)`;
+}
+async function callLoadCodeAssistAntigravity(accessToken) {
+  const res = await fetch(`${CODE_ASSIST_API_BASE}:loadCodeAssist`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "User-Agent": buildAntigravityUserAgent()
+    },
+    body: JSON.stringify({ metadata: { ideType: ANTIGRAVITY_IDE_TYPE } })
+  });
+  if (!res.ok) {
+    throw new Error(`loadCodeAssist (antigravity) failed: ${res.status} ${await res.text()}`);
+  }
+  return await res.json();
+}
+async function setupAntigravityUser(accessToken) {
+  if (cachedAgProjectId && cachedAgTierId) {
+    return { projectId: cachedAgProjectId, tierId: cachedAgTierId };
+  }
+  const loadRes = await callLoadCodeAssistAntigravity(accessToken);
+  log(`[Antigravity] loadCodeAssist response: ${JSON.stringify(loadRes)}`);
+  const resolvedTier = loadRes.paidTier?.id || (typeof loadRes.currentTier === "object" ? loadRes.currentTier?.id : loadRes.currentTier) || "free-tier";
+  const projectId = loadRes.cloudaicompanionProject;
+  if (!projectId) {
+    throw makeTerminalSetupError("Antigravity did not return a project for this account. Sign in to Antigravity " + "(the `agy` CLI) and try again, or use g@<model> with GEMINI_API_KEY " + "(get one at https://aistudio.google.com/app/apikey).");
+  }
+  cachedAgProjectId = projectId;
+  cachedAgTierId = resolvedTier;
+  cachedAgTierName = loadRes.paidTier?.name || null;
+  log(`[Antigravity] User set up, project: ${projectId}, tier: ${resolvedTier}`);
+  return { projectId, tierId: resolvedTier };
+}
+function getAntigravityTierDisplayName() {
+  if (!cachedAgTierName && !cachedAgTierId)
+    return "Antigravity";
+  const id = cachedAgTierId || "";
+  if (id.includes("ultra"))
+    return "Antigravity Ultra";
+  if (id.includes("pro"))
+    return "Antigravity Pro";
+  if (id === "free-tier")
+    return "Antigravity Free";
+  return cachedAgTierName || "Antigravity";
+}
+async function getServedAntigravityModels(accessToken, projectId, opts) {
+  const now = Date.now();
+  if (!opts?.force && agServedCache && now - agServedCacheAt < SERVED_MODELS_TTL_MS) {
+    return agServedCache;
+  }
+  try {
+    const res = await fetch(`${CODE_ASSIST_API_BASE}:fetchAvailableModels`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+        "User-Agent": buildAntigravityUserAgent()
+      },
+      body: JSON.stringify({ project: projectId })
+    });
+    if (res.ok) {
+      const data = await res.json();
+      const servedIds = data.models ? Object.keys(data.models) : [];
+      const defaultId = typeof data.defaultAgentModelId === "string" ? data.defaultAgentModelId : null;
+      if (servedIds.length > 0) {
+        agServedCache = { servedIds, defaultId };
+        agServedCacheAt = now;
+        return agServedCache;
+      }
+    } else {
+      log(`[Antigravity] fetchAvailableModels failed: ${res.status}`);
+    }
+  } catch (err) {
+    log(`[Antigravity] fetchAvailableModels error: ${err}`);
+  }
+  if (agServedCache)
+    return agServedCache;
+  return { servedIds: [], defaultId: null };
+}
+var execAsync, getDefaultClientId = () => {
+  const parts = [
+    "681255809395",
+    "oo8ft2oprdrnp9e3aqf6av3hmdib135j",
+    "apps",
+    "googleusercontent",
+    "com"
+  ];
+  return `${parts[0]}-${parts[1]}.${parts[2]}.${parts[3]}.${parts[4]}`;
+}, getDefaultClientSecret = () => {
+  const p = ["GOCSPX", "4uHgMPm", "1o7Sk", "geV6Cu5clXFsxl"];
+  return `${p[0]}-${p[1]}-${p[2]}-${p[3]}`;
+}, OAUTH_CONFIG, USE_ANTIGRAVITY_GEMINI_IDENTITY, USE_LEGACY_GEMINI_IDENTITY, GEMINI_IDE_TYPE, GEMINI_IDENTITY_IS_ANTIGRAVITY, CODE_ASSIST_API_BASE = "https://cloudcode-pa.googleapis.com/v1internal", CODE_ASSIST_FALLBACK_CHAIN, servedModelsCache = null, servedModelsCacheAt = 0, SERVED_MODELS_TTL_MS, cachedProjectId = null, cachedTierId = null, cachedTierName = null, cachedSetupError = null, TIER_SHORT_NAMES, ANTIGRAVITY_IDE_TYPE = "ANTIGRAVITY", cachedAgProjectId = null, cachedAgTierId = null, cachedAgTierName = null, agServedCache = null, agServedCacheAt = 0;
+var init_gemini_oauth = __esm(() => {
   init_logger();
   execAsync = promisify(exec);
   OAUTH_CONFIG = {
-    clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
-    authUrl: "https://auth.openai.com/oauth/authorize",
-    tokenUrl: "https://auth.openai.com/oauth/token",
-    scopes: ["openid", "profile", "email", "offline_access"]
+    clientId: process.env.GEMINI_CLIENT_ID || getDefaultClientId(),
+    clientSecret: process.env.GEMINI_CLIENT_SECRET || getDefaultClientSecret(),
+    authUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+    tokenUrl: "https://oauth2.googleapis.com/token",
+    scopes: [
+      "https://www.googleapis.com/auth/cloud-platform",
+      "https://www.googleapis.com/auth/userinfo.email",
+      "https://www.googleapis.com/auth/userinfo.profile"
+    ]
+  };
+  USE_ANTIGRAVITY_GEMINI_IDENTITY = process.env.CLAUDISH_GEMINI_ANTIGRAVITY === "1";
+  USE_LEGACY_GEMINI_IDENTITY = !USE_ANTIGRAVITY_GEMINI_IDENTITY;
+  GEMINI_IDE_TYPE = USE_LEGACY_GEMINI_IDENTITY ? "GEMINI_CLI" : "ANTIGRAVITY";
+  GEMINI_IDENTITY_IS_ANTIGRAVITY = !USE_LEGACY_GEMINI_IDENTITY;
+  CODE_ASSIST_FALLBACK_CHAIN = [
+    "gemini-2.5-pro",
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+    "gemini-3.1-flash-lite"
+  ];
+  SERVED_MODELS_TTL_MS = 10 * 60 * 1000;
+  TIER_SHORT_NAMES = {
+    "free-tier": "GeminiCA Free",
+    "standard-tier": "GeminiCA Std",
+    "g1-pro-tier": "GeminiCA Pro",
+    "legacy-tier": "GeminiCA Legacy"
   };
 });
 
-// src/auth/credentials/composite-credential.ts
-class CompositeCredentialProvider {
-  catalogName;
-  primary;
-  fallback;
-  opts;
-  constructor(catalogName, primary, fallback, opts = {}) {
-    this.catalogName = catalogName;
-    this.primary = primary;
-    this.fallback = fallback;
-    this.opts = opts;
+// src/handlers/shared/gemini-queue.ts
+class GeminiRequestQueue {
+  static instance = null;
+  queue = [];
+  processing = false;
+  minDelayMs = 1000;
+  lastRequestTime = 0;
+  consecutiveErrors = 0;
+  totalProcessed = 0;
+  totalErrors = 0;
+  baseDelayMs = 1000;
+  maxDelayMs = 1e4;
+  maxQueueSize = 100;
+  constructor() {
+    log("[GeminiQueue] Queue initialized with minDelay=1000ms, maxQueueSize=100");
   }
-  async isAvailable(opts) {
-    return await this.primary.isAvailable(opts) || await this.fallback.isAvailable(opts);
+  static getInstance() {
+    if (!GeminiRequestQueue.instance) {
+      GeminiRequestQueue.instance = new GeminiRequestQueue;
+    }
+    return GeminiRequestQueue.instance;
   }
-  invalidate() {
-    this.primary.invalidate?.();
-    this.fallback.invalidate?.();
+  async enqueue(fetchFn) {
+    if (this.queue.length >= this.maxQueueSize) {
+      log(`[GeminiQueue] Queue full (${this.queue.length}/${this.maxQueueSize}), rejecting request`);
+      throw new Error("Gemini request queue full. Please retry later.");
+    }
+    return new Promise((resolve, reject) => {
+      const queuedRequest = {
+        fetchFn,
+        resolve,
+        reject
+      };
+      this.queue.push(queuedRequest);
+      log(`[GeminiQueue] Request enqueued (queue length: ${this.queue.length})`);
+      if (!this.processing) {
+        this.processQueue();
+      }
+    });
   }
-  async getRequestAuth(ctx) {
-    if (await this.primary.isAvailable({ allowOpPrompt: ctx.allowOpPrompt })) {
+  async processQueue() {
+    if (this.processing) {
+      return;
+    }
+    this.processing = true;
+    log("[GeminiQueue] Worker started");
+    while (this.queue.length > 0) {
+      const request = this.queue.shift();
+      if (!request)
+        break;
+      log(`[GeminiQueue] Processing request (${this.queue.length} remaining in queue)`);
       try {
-        return await this.primary.getRequestAuth(ctx);
-      } catch (e) {
-        const signal = this.opts.fallbackSignal;
-        if (signal && String(e?.message) === signal) {
-          return this.fallback.getRequestAuth(ctx);
+        await this.waitForNextSlot();
+        const response = await request.fetchFn();
+        this.lastRequestTime = Date.now();
+        if (response.status === 429) {
+          this.totalErrors++;
+          const errorText = await response.clone().text();
+          this.handleRateLimitResponse(errorText);
+          log(`[GeminiQueue] Rate limit hit (429), adjusted delay to ${this.minDelayMs}ms`);
+        } else {
+          this.handleSuccessResponse();
         }
-        throw e;
+        this.totalProcessed++;
+        request.resolve(response);
+      } catch (error46) {
+        this.totalErrors++;
+        log(`[GeminiQueue] Request failed with error: ${error46}`);
+        request.reject(error46 instanceof Error ? error46 : new Error(String(error46)));
       }
     }
-    return this.fallback.getRequestAuth(ctx);
+    this.processing = false;
+    log("[GeminiQueue] Worker stopped (queue empty)");
   }
-  async login() {
-    await this.primary.login?.();
+  async waitForNextSlot() {
+    const now = Date.now();
+    const timeSinceLastRequest = now - this.lastRequestTime;
+    let delayMs = this.minDelayMs;
+    if (this.consecutiveErrors > 0) {
+      const backoffMultiplier = 1 + this.consecutiveErrors * 0.5;
+      delayMs = Math.min(this.minDelayMs * backoffMultiplier, this.maxDelayMs);
+      log(`[GeminiQueue] Applying backoff (${this.consecutiveErrors} errors): ${delayMs}ms`);
+    }
+    if (timeSinceLastRequest < delayMs) {
+      const waitMs = delayMs - timeSinceLastRequest;
+      log(`[GeminiQueue] Waiting ${waitMs}ms before next request`);
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+    }
   }
-  async logout() {
-    await this.primary.logout?.();
+  handleRateLimitResponse(errorText) {
+    this.consecutiveErrors++;
+    try {
+      const errorData = JSON.parse(errorText);
+      const quotaDetail = errorData?.error?.details?.find((d) => d.quotaResetDelay);
+      if (quotaDetail?.quotaResetDelay) {
+        const delayStr = quotaDetail.quotaResetDelay;
+        const match = delayStr.match(/(\d+(?:\.\d+)?)/);
+        if (match) {
+          const delaySeconds = Number.parseFloat(match[1]);
+          const suggestedDelayMs = Math.ceil(delaySeconds * 1000);
+          this.minDelayMs = Math.max(suggestedDelayMs, this.minDelayMs, this.baseDelayMs);
+          this.minDelayMs = Math.min(this.minDelayMs, this.maxDelayMs);
+          log(`[GeminiQueue] Parsed quotaResetDelay: ${delayStr} (${suggestedDelayMs}ms), ` + `new minDelay: ${this.minDelayMs}ms`);
+        }
+      }
+    } catch {
+      log("[GeminiQueue] Failed to parse rate limit response, using backoff");
+    }
+    const backoffMultiplier = 1 + this.consecutiveErrors * 0.5;
+    this.minDelayMs = Math.min(this.baseDelayMs * backoffMultiplier, this.maxDelayMs);
+  }
+  handleSuccessResponse() {
+    if (this.consecutiveErrors > 0) {
+      log(`[GeminiQueue] Success after ${this.consecutiveErrors} errors, resetting counter`);
+      this.consecutiveErrors = 0;
+    }
+    if (this.minDelayMs > this.baseDelayMs) {
+      this.minDelayMs = Math.max(this.baseDelayMs, this.minDelayMs * 0.9);
+      log(`[GeminiQueue] Reducing delay to ${this.minDelayMs}ms`);
+    }
+  }
+  getStats() {
+    return {
+      queueLength: this.queue.length,
+      processing: this.processing,
+      consecutiveErrors: this.consecutiveErrors,
+      currentDelayMs: this.minDelayMs,
+      totalProcessed: this.totalProcessed,
+      totalErrors: this.totalErrors
+    };
   }
 }
+var init_gemini_queue = __esm(() => {
+  init_logger();
+});
 
-// src/auth/credentials/codex-credential.ts
-function buildOAuthHeaders(token, accountId) {
-  const headers = {
-    Authorization: `Bearer ${token}`,
-    "OpenAI-Beta": "responses=experimental",
-    originator: "codex_cli_rs",
-    accept: "text/event-stream"
-  };
-  if (accountId) {
-    headers["chatgpt-account-id"] = accountId;
-    headers["x-conversation-id"] = "claudish-session";
-    headers["x-session-id"] = "claudish-session";
+// src/providers/transport/antigravity.ts
+import { randomUUID } from "crypto";
+function rankReasoningSuffix(suffix) {
+  const rank = REASONING_TIER_RANK[suffix.toLowerCase()];
+  return rank === undefined ? Number.MAX_SAFE_INTEGER : rank;
+}
+function resolveAntigravityModelId(requested, servedIds, defaultId) {
+  const req = requested.trim();
+  if (servedIds.includes(req))
+    return req;
+  const familyPrefix = `${req}-`;
+  const variants = servedIds.filter((id) => id.startsWith(familyPrefix));
+  if (variants.length > 0) {
+    if (defaultId && variants.includes(defaultId))
+      return defaultId;
+    let best = variants[0];
+    let bestRank = rankReasoningSuffix(best.slice(familyPrefix.length));
+    for (const variant of variants.slice(1)) {
+      const rank = rankReasoningSuffix(variant.slice(familyPrefix.length));
+      if (rank < bestRank) {
+        best = variant;
+        bestRank = rank;
+      }
+    }
+    return best;
+  }
+  return req;
+}
+function createActivityRequestId() {
+  return Math.random().toString(36).substring(7);
+}
+function classify429(responseBody) {
+  try {
+    const raw = JSON.parse(responseBody);
+    const error46 = Array.isArray(raw) ? raw[0]?.error : raw?.error;
+    const details = Array.isArray(error46?.details) ? error46.details : [];
+    const retryInfo = details.find((d) => d["@type"] === "type.googleapis.com/google.rpc.RetryInfo");
+    let retryDelayMs = parseRetryDelay(retryInfo?.retryDelay);
+    if (retryDelayMs === undefined && typeof error46?.message === "string") {
+      const match = error46.message.match(/retry in ([\d.]+)(ms|s)/i);
+      if (match) {
+        const val = Number.parseFloat(match[1]);
+        retryDelayMs = match[2] === "ms" ? Math.round(val) : Math.round(val * 1000);
+      }
+    }
+    const errorInfo = details.find((d) => d["@type"] === "type.googleapis.com/google.rpc.ErrorInfo");
+    const reason = errorInfo?.reason;
+    if (reason === "QUOTA_EXHAUSTED") {
+      return { terminal: true, retryDelayMs, reason };
+    }
+    if (reason === "RATE_LIMIT_EXCEEDED") {
+      return { terminal: false, retryDelayMs: retryDelayMs ?? DEFAULT_RATE_LIMIT_DELAY_MS, reason };
+    }
+    if (reason === "MODEL_CAPACITY_EXHAUSTED") {
+      return { terminal: true, retryDelayMs, reason };
+    }
+    const quotaFailure = details.find((d) => d["@type"] === "type.googleapis.com/google.rpc.QuotaFailure");
+    if (quotaFailure?.violations?.length) {
+      const text = quotaFailure.violations.map((v) => `${v.quotaId || ""} ${v.description || ""}`).join(" ").toLowerCase();
+      if (text.includes("perday") || text.includes("daily") || text.includes("per day")) {
+        return { terminal: true, retryDelayMs, reason };
+      }
+      if (text.includes("perminute") || text.includes("per minute")) {
+        return { terminal: false, retryDelayMs: retryDelayMs ?? 60000, reason };
+      }
+    }
+    return { terminal: false, retryDelayMs, reason };
+  } catch {
+    return null;
   }
-  return headers;
+}
+function parseRetryDelay(value) {
+  if (!value)
+    return;
+  if (typeof value === "string") {
+    const match = value.match(/([\d.]+)s/);
+    return match ? Math.round(Number.parseFloat(match[1]) * 1000) : undefined;
+  }
+  if (typeof value === "object") {
+    const seconds = typeof value.seconds === "number" ? value.seconds : 0;
+    const nanos = typeof value.nanos === "number" ? value.nanos : 0;
+    const ms = Math.round(seconds * 1000 + nanos / 1e6);
+    return ms > 0 ? ms : undefined;
+  }
+  return;
 }
 
-class CodexOAuthHalf {
-  catalogName = "openai-codex";
-  oauth = CodexOAuth.getInstance();
-  async isAvailable() {
-    return this.oauth.hasCredentials();
+class AntigravityProviderTransport {
+  name = "antigravity";
+  _displayName = "Antigravity";
+  get displayName() {
+    return this._displayName;
   }
-  async getRequestAuth(_ctx) {
-    const token = await this.oauth.getAccessToken();
-    const accountId = this.oauth.getAccountId();
+  streamFormat = "gemini-sse";
+  modelName;
+  servedModelName;
+  accessToken = null;
+  projectId = null;
+  tierId = null;
+  cachedAuth = null;
+  lastEnvelope = null;
+  _activeModelName;
+  servedModels = [];
+  defaultServedModel = null;
+  constructor(modelName) {
+    this.modelName = modelName;
+    this.servedModelName = modelName;
+  }
+  getActiveModelName() {
+    return this._activeModelName;
+  }
+  getEndpoint() {
+    return CODE_ASSIST_ENDPOINT;
+  }
+  async getHeaders() {
+    if (this.cachedAuth)
+      return { ...this.cachedAuth.headers };
+    return this.buildLocalHeaders();
+  }
+  buildLocalHeaders() {
     return {
-      headers: buildOAuthHeaders(token, accountId),
-      endpoint: CODEX_RESPONSES_ENDPOINT,
-      transformPayload: (p) => ({
-        ...p,
-        store: false,
-        include: ["reasoning.encrypted_content"]
-      })
+      Authorization: `Bearer ${this.accessToken}`,
+      "User-Agent": buildAntigravityUserAgent(),
+      "x-activity-request-id": createActivityRequestId()
     };
   }
-  async login() {
-    await this.oauth.login();
+  async refreshAuth() {
+    this.cachedAuth = await credentials.getRequestAuth("antigravity", {
+      model: this.modelName
+    });
+    this.accessToken = await getValidAntigravityAccessToken();
+    const { projectId, tierId } = await setupAntigravityUser(this.accessToken);
+    this.projectId = projectId;
+    this.tierId = tierId;
+    this._displayName = getAntigravityTierDisplayName();
+    const served = await getServedAntigravityModels(this.accessToken, this.projectId);
+    this.servedModels = served.servedIds;
+    this.defaultServedModel = served.defaultId;
+    this.servedModelName = resolveAntigravityModelId(this.modelName, this.servedModels, this.defaultServedModel);
+    log(`[Antigravity] Auth refreshed, project: ${this.projectId}, tier: ${this._displayName}, ` + `model: ${this.modelName} -> ${this.servedModelName}, served: ${this.servedModels.join(",") || "(none)"}`);
   }
-  async logout() {
-    await this.oauth.logout();
+  transformPayload(payload) {
+    const envelope = this.cachedAuth?.transformPayload ? this.cachedAuth.transformPayload(payload) : this.buildEnvelope(payload, this.servedModelName);
+    this.lastEnvelope = envelope;
+    return envelope;
+  }
+  buildEnvelope(innerPayload, model) {
+    const envelope = {
+      model,
+      project: this.projectId,
+      user_prompt_id: randomUUID(),
+      request: innerPayload
+    };
+    if (this.tierId && this.tierId !== "free-tier") {
+      envelope.enabled_credit_types = ["GOOGLE_ONE_AI"];
+    }
+    return envelope;
+  }
+  async enqueueRequest(fetchFn) {
+    const queue = GeminiRequestQueue.getInstance();
+    let lastResponse = null;
+    for (let attempt = 1;attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
+      const response = attempt === 1 ? await queue.enqueue(fetchFn) : await queue.enqueue(fetchFn);
+      if (response.status !== 429) {
+        if (response.status === 404) {
+          return this.rewriteModelNotFound(response);
+        }
+        return response;
+      }
+      const bodyText = await response.clone().text();
+      const classification = classify429(bodyText);
+      lastResponse = response;
+      if (!classification) {
+        log("[Antigravity] 429 response could not be classified, returning to caller");
+        return response;
+      }
+      log(`[Antigravity] 429 classified: reason=${classification.reason}, terminal=${classification.terminal}, delay=${classification.retryDelayMs}ms`);
+      if (classification.reason === "MODEL_CAPACITY_EXHAUSTED") {
+        return this.handleCapacityExhausted(response, queue);
+      }
+      if (classification.terminal) {
+        logStderr(`[Antigravity] Quota exhausted (${classification.reason || "daily limit"}). Check plan limits.`);
+        return response;
+      }
+      if (attempt < MAX_RETRY_ATTEMPTS) {
+        const delay = classification.retryDelayMs ?? DEFAULT_RATE_LIMIT_DELAY_MS;
+        logStderr(`[Antigravity] Rate limited (${classification.reason || "unknown"}), retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt}/${MAX_RETRY_ATTEMPTS})`);
+        if (attempt === 1) {
+          await this.logQuotaInfo();
+        }
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    logStderr(`[Antigravity] Rate limit persisted after ${MAX_RETRY_ATTEMPTS} retries`);
+    return lastResponse;
+  }
+  async handleCapacityExhausted(originalResponse, queue) {
+    const candidates = this.servedModels.filter((m) => m !== this.servedModelName);
+    if (candidates.length === 0) {
+      log(`[Antigravity] ${this.servedModelName} capacity exhausted, no fallback models available`);
+      return originalResponse;
+    }
+    if (!this.lastEnvelope) {
+      log(`[Antigravity] ${this.servedModelName} capacity exhausted but no stored envelope for retry`);
+      return originalResponse;
+    }
+    log(`[Antigravity] Model ${this.servedModelName} capacity exhausted, starting fallback chain`);
+    logStderr(`[Antigravity] ${this.servedModelName} capacity exhausted, trying fallback models...`);
+    let lastResponse = originalResponse;
+    const innerPayload = this.lastEnvelope.request;
+    const endpoint = this.getEndpoint();
+    const tried = [this.servedModelName];
+    for (const fallbackModel of candidates) {
+      log(`[Antigravity] Trying fallback model: ${fallbackModel}`);
+      tried.push(fallbackModel);
+      const fallbackEnvelope = this.buildEnvelope(innerPayload, fallbackModel);
+      const headers = this.buildLocalHeaders();
+      headers["Content-Type"] = "application/json";
+      const fallbackResponse = await queue.enqueue(() => fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(fallbackEnvelope)
+      }));
+      if (fallbackResponse.status === 200) {
+        this._activeModelName = fallbackModel;
+        logStderr(`[Antigravity] Using fallback model: ${fallbackModel} (${this.servedModelName} had no capacity)`);
+        return fallbackResponse;
+      }
+      if (fallbackResponse.status === 404) {
+        log(`[Antigravity] ${fallbackModel} returned 404, skipping to next fallback`);
+        lastResponse = fallbackResponse;
+        continue;
+      }
+      if (fallbackResponse.status === 429) {
+        const fallbackBodyText = await fallbackResponse.clone().text();
+        const classification = classify429(fallbackBodyText);
+        if (classification?.reason === "MODEL_CAPACITY_EXHAUSTED") {
+          log(`[Antigravity] ${fallbackModel} also capacity exhausted, trying next...`);
+          lastResponse = fallbackResponse;
+          continue;
+        }
+        return fallbackResponse;
+      }
+      return fallbackResponse;
+    }
+    log("[Antigravity] All fallback models exhausted");
+    logStderr(`[Antigravity] All models capacity exhausted (tried: ${tried.join(" -> ")})`);
+    if (lastResponse.status === 404) {
+      return this.rewriteModelNotFound(lastResponse, true);
+    }
+    return lastResponse;
+  }
+  rewriteModelNotFound(response, capacityFallbacksExhausted = false) {
+    const served = this.servedModels;
+    if (!capacityFallbacksExhausted && served.includes(this.servedModelName)) {
+      log(`[Antigravity] 404 for ${this.servedModelName}, which IS in the served set \u2014 passing through unmodified`);
+      return response;
+    }
+    response.text().catch(() => {});
+    const servesClause = served.length > 0 ? `That tier currently serves: ${served.join(", ")}. ` : "";
+    const tier = this._displayName || "Antigravity";
+    const reason = capacityFallbacksExhausted ? `${this.modelName} could not be served after every Antigravity capacity fallback failed (${tier}, via ag@). ` + servesClause : `${this.modelName} is not served by your Antigravity tier (${tier}, via ag@). ` + servesClause;
+    const message = reason + `To use ${this.modelName}, go through the direct Gemini API instead \u2014 ` + `set GEMINI_API_KEY (get one at https://aistudio.google.com/app/apikey) and run ` + `google@${this.modelName}.`;
+    const list = served.join(", ");
+    const body = JSON.stringify({
+      error: { code: 404, status: "NOT_FOUND", message }
+    });
+    if (capacityFallbacksExhausted) {
+      logStderr(`[Antigravity] ${this.modelName} capacity fallbacks exhausted (404). Reported models: ${list}`);
+    } else {
+      logStderr(`[Antigravity] ${this.modelName} not served by ${tier} (404). Serves: ${list}`);
+    }
+    return new Response(body, {
+      status: 404,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  async logQuotaInfo() {
+    if (!this.accessToken || !this.projectId)
+      return;
+    try {
+      const data = await retrieveUserQuota(this.accessToken, this.projectId);
+      if (!data?.buckets?.length)
+        return;
+      const lines = [];
+      for (const bucket of data.buckets) {
+        if (!bucket.modelId)
+          continue;
+        const pct = typeof bucket.remainingFraction === "number" ? `${(bucket.remainingFraction * 100).toFixed(1)}%` : "?";
+        const reset = bucket.resetTime ? new Date(bucket.resetTime).toLocaleTimeString([], {
+          hour: "2-digit",
+          minute: "2-digit"
+        }) : "?";
+        lines.push(`  ${bucket.modelId}: ${pct} remaining (resets ${reset})`);
+      }
+      if (lines.length > 0) {
+        logStderr(`[Antigravity] Quota status:
+${lines.join(`
+`)}`);
+      }
+    } catch {}
+  }
+  async getQuotaRemaining(modelName) {
+    if (!this.accessToken || !this.projectId)
+      return;
+    try {
+      const data = await retrieveUserQuota(this.accessToken, this.projectId);
+      if (!data?.buckets?.length)
+        return;
+      const bucket = data.buckets.find((b) => b.modelId === modelName);
+      return typeof bucket?.remainingFraction === "number" ? bucket.remainingFraction : undefined;
+    } catch {
+      return;
+    }
   }
 }
-function makeCodexCredential() {
-  return new CompositeCredentialProvider("openai-codex", new CodexOAuthHalf, new ApiKeyCredentialProvider({
-    catalogName: "openai-codex",
-    envVar: "OPENAI_CODEX_API_KEY"
-  }));
+var CODE_ASSIST_BASE = "https://cloudcode-pa.googleapis.com", CODE_ASSIST_ENDPOINT, MAX_RETRY_ATTEMPTS = 3, DEFAULT_RATE_LIMIT_DELAY_MS = 1e4, REASONING_TIER_RANK;
+var init_antigravity = __esm(() => {
+  init_authority();
+  init_antigravity_token();
+  init_gemini_oauth();
+  init_gemini_queue();
+  init_logger();
+  CODE_ASSIST_ENDPOINT = `${CODE_ASSIST_BASE}/v1internal:streamGenerateContent?alt=sse`;
+  REASONING_TIER_RANK = {
+    high: 0,
+    medium: 1,
+    low: 2,
+    "extra-low": 3,
+    tiered: 4
+  };
+});
+
+// src/auth/credentials/antigravity-credential.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function createActivityRequestId2() {
+  return Math.random().toString(36).substring(7);
 }
-var CODEX_RESPONSES_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
-var init_codex_credential = __esm(() => {
-  init_codex_oauth();
-  init_api_key_credential();
+
+class AntigravityCredentialProvider {
+  catalogName = "antigravity";
+  async isAvailable() {
+    try {
+      return readSharedAntigravityToken() !== null;
+    } catch {
+      return false;
+    }
+  }
+  async getRequestAuth(ctx) {
+    const token = await getValidAntigravityAccessToken();
+    const { projectId, tierId } = await setupAntigravityUser(token);
+    const { servedIds, defaultId } = await getServedAntigravityModels(token, projectId);
+    const servedModel = resolveAntigravityModelId(ctx.model, servedIds, defaultId);
+    return {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "User-Agent": buildAntigravityUserAgent(),
+        "x-activity-request-id": createActivityRequestId2()
+      },
+      transformPayload: (inner) => {
+        const env = {
+          model: servedModel,
+          project: projectId,
+          user_prompt_id: randomUUID2(),
+          request: inner
+        };
+        if (tierId && tierId !== "free-tier") {
+          env.enabled_credit_types = ["GOOGLE_ONE_AI"];
+        }
+        return env;
+      }
+    };
+  }
+}
+var init_antigravity_credential = __esm(() => {
+  init_antigravity();
+  init_antigravity_token();
+  init_gemini_oauth();
 });
 
-// src/auth/gemini-oauth.ts
+// src/auth/credentials/api-key-credential.ts
+import { existsSync as existsSync8 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join10 } from "path";
+function realValue(v) {
+  if (!v)
+    return;
+  return UNEXPANDED_PLACEHOLDER.test(v.trim()) ? undefined : v;
+}
+
+class ApiKeyCredentialProvider {
+  catalogName;
+  envVar;
+  aliases;
+  authScheme;
+  staticHeaders;
+  publicKeyFallback;
+  oauthFallback;
+  declaredKey;
+  cachedKey;
+  resolving;
+  constructor(descriptor) {
+    this.catalogName = descriptor.catalogName;
+    this.envVar = descriptor.envVar;
+    this.aliases = descriptor.aliases ?? [];
+    this.authScheme = descriptor.authScheme ?? "bearer";
+    this.staticHeaders = descriptor.staticHeaders ?? {};
+    this.publicKeyFallback = descriptor.publicKeyFallback;
+    this.oauthFallback = descriptor.oauthFallback;
+    this.declaredKey = descriptor.declaredKey;
+  }
+  resolveFromEnvConfig() {
+    return realValue(process.env[this.envVar]) || this.aliases.map((a) => realValue(process.env[a])).find((v) => !!v) || realValue(getApiKey(this.envVar)) || realValue(this.resolveDeclared());
+  }
+  resolveDeclared() {
+    try {
+      return this.declaredKey?.() || undefined;
+    } catch {
+      return;
+    }
+  }
+  hasOauthFallbackFile() {
+    if (!this.oauthFallback)
+      return false;
+    try {
+      return existsSync8(join10(homedir10(), ".claudish", this.oauthFallback));
+    } catch {
+      return false;
+    }
+  }
+  async resolveKey(opts) {
+    if (this.cachedKey !== undefined)
+      return this.cachedKey;
+    if (this.resolving)
+      return this.resolving;
+    this.resolving = (async () => {
+      const local = this.resolveFromEnvConfig();
+      if (local) {
+        this.cachedKey = local;
+        return local;
+      }
+      if (hasOpSources()) {
+        const wanted = new Set([this.envVar, ...this.aliases]);
+        const resolved = await resolveOpKeyForEnvVars(wanted, {
+          onAuthFailure: "skip",
+          allowPrompt: opts?.allowOpPrompt ?? false
+        });
+        const value = resolved[this.envVar] ?? this.aliases.map((a) => resolved[a]).find((v) => !!v);
+        if (value) {
+          process.env[this.envVar] = value;
+          this.cachedKey = value;
+          return value;
+        }
+        return "";
+      }
+      this.cachedKey = "";
+      return "";
+    })();
+    try {
+      return await this.resolving;
+    } finally {
+      this.resolving = undefined;
+    }
+  }
+  async isAvailable(opts) {
+    if (this.publicKeyFallback)
+      return true;
+    if (this.resolveFromEnvConfig())
+      return true;
+    if (this.hasOauthFallbackFile())
+      return true;
+    const key = await this.resolveKey(opts);
+    return !!key;
+  }
+  invalidate() {
+    this.cachedKey = undefined;
+    this.resolving = undefined;
+  }
+  async getRequestAuth(ctx) {
+    const key = await this.resolveKey({ allowOpPrompt: ctx.allowOpPrompt }) || this.publicKeyFallback || "";
+    let headers;
+    if (this.authScheme === "x-api-key") {
+      headers = { "x-api-key": key, ...this.staticHeaders };
+    } else if (key) {
+      headers = { Authorization: `Bearer ${key}`, ...this.staticHeaders };
+    } else {
+      headers = { ...this.staticHeaders };
+    }
+    return { headers };
+  }
+}
+var UNEXPANDED_PLACEHOLDER;
+var init_api_key_credential = __esm(() => {
+  init_profile_config();
+  init_op_source();
+  UNEXPANDED_PLACEHOLDER = /^\$\{[^}]*\}$/;
+});
+
+// src/auth/codex-oauth.ts
 import { exec as exec2 } from "child_process";
 import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
-import { closeSync as closeSync3, existsSync as existsSync8, openSync as openSync3, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeSync as writeSync3 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync9, openSync as openSync3, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeSync as writeSync3 } from "fs";
 import { createServer as createServer2 } from "http";
-import { homedir as homedir10 } from "os";
-import { join as join10 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join11 } from "path";
 import { promisify as promisify2 } from "util";
 
-class GeminiOAuth {
+class CodexOAuth {
   static instance = null;
   credentials = null;
   refreshPromise = null;
   tokenRefreshMargin = 5 * 60 * 1000;
   oauthState = null;
   static getInstance() {
-    if (!GeminiOAuth.instance) {
-      GeminiOAuth.instance = new GeminiOAuth;
+    if (!CodexOAuth.instance) {
+      CodexOAuth.instance = new CodexOAuth;
     }
-    return GeminiOAuth.instance;
+    return CodexOAuth.instance;
   }
   constructor() {
     this.credentials = this.loadCredentials();
@@ -28845,56 +29783,61 @@ class GeminiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join10(homedir10(), ".claudish");
-    return join10(claudishDir, "gemini-oauth.json");
+    const claudishDir = join11(homedir11(), ".claudish");
+    return join11(claudishDir, "codex-oauth.json");
   }
   async login() {
-    log("[GeminiOAuth] Starting OAuth login flow");
+    log("[CodexOAuth] Starting OAuth login flow");
     const codeVerifier = this.generateCodeVerifier();
     const codeChallenge = await this.generateCodeChallenge(codeVerifier);
     this.oauthState = randomBytes2(32).toString("base64url");
     const { authCode, redirectUri } = await this.startCallbackServer(codeChallenge, this.oauthState);
     const tokens = await this.exchangeCodeForTokens(authCode, codeVerifier, redirectUri);
-    const credentials = {
+    const accountId = tokens.id_token ? this.extractAccountId(tokens.id_token) : undefined;
+    const credentials2 = {
       access_token: tokens.access_token,
       refresh_token: tokens.refresh_token,
-      expires_at: Date.now() + tokens.expires_in * 1000
+      expires_at: Date.now() + tokens.expires_in * 1000,
+      account_id: accountId
     };
-    this.saveCredentials(credentials);
-    this.credentials = credentials;
+    this.saveCredentials(credentials2);
+    this.credentials = credentials2;
     this.oauthState = null;
-    log("[GeminiOAuth] Login successful");
+    log("[CodexOAuth] Login successful");
+    if (accountId) {
+      log(`[CodexOAuth] Account ID: ${accountId}`);
+    }
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync8(credPath)) {
+    if (existsSync9(credPath)) {
       unlinkSync3(credPath);
-      log("[GeminiOAuth] Credentials deleted");
+      log("[CodexOAuth] Credentials deleted");
     }
     this.credentials = null;
   }
   async getAccessToken() {
     if (this.refreshPromise) {
-      log("[GeminiOAuth] Waiting for in-progress refresh");
+      log("[CodexOAuth] Waiting for in-progress refresh");
       return this.refreshPromise;
     }
     if (!this.credentials) {
-      throw new Error("No Gemini OAuth credentials found. Please run `claudish login gemini` first.");
+      throw new Error("No OpenAI Codex OAuth credentials found. Please run `claudish login codex` first.");
     }
     if (this.isTokenValid()) {
       return this.credentials.access_token;
     }
-    this.refreshPromise = this.doRefreshToken();
-    try {
-      const token = await this.refreshPromise;
-      return token;
-    } finally {
+    this.refreshPromise = this.doRefreshToken().finally(() => {
       this.refreshPromise = null;
-    }
+    });
+    return this.refreshPromise;
+  }
+  getAccountId() {
+    return this.credentials?.account_id;
   }
   async refreshToken() {
     if (!this.credentials) {
-      throw new Error("No Gemini OAuth credentials found. Please run `claudish login gemini` first.");
+      throw new Error("No OpenAI Codex OAuth credentials found. Please run `claudish login codex` first.");
     }
     await this.doRefreshToken();
   }
@@ -28905,20 +29848,19 @@ class GeminiOAuth {
   }
   async doRefreshToken() {
     if (!this.credentials) {
-      throw new Error("No Gemini OAuth credentials found. Please run `claudish login gemini` first.");
+      throw new Error("No OpenAI Codex OAuth credentials found. Please run `claudish login codex` first.");
     }
-    log("[GeminiOAuth] Refreshing access token");
+    log("[CodexOAuth] Refreshing access token");
     try {
       const response = await fetch(OAUTH_CONFIG2.tokenUrl, {
         method: "POST",
         headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
+          "Content-Type": "application/json"
         },
-        body: new URLSearchParams({
+        body: JSON.stringify({
           grant_type: "refresh_token",
           refresh_token: this.credentials.refresh_token,
-          client_id: OAUTH_CONFIG2.clientId,
-          client_secret: OAUTH_CONFIG2.clientSecret
+          client_id: OAUTH_CONFIG2.clientId
         })
       });
       if (!response.ok) {
@@ -28926,56 +29868,58 @@ class GeminiOAuth {
         throw new Error(`Token refresh failed: ${response.status} - ${errorText}`);
       }
       const tokens = await response.json();
+      const accountId = tokens.id_token ? this.extractAccountId(tokens.id_token) : this.credentials.account_id;
       const updatedCredentials = {
         access_token: tokens.access_token,
         refresh_token: tokens.refresh_token || this.credentials.refresh_token,
-        expires_at: Date.now() + tokens.expires_in * 1000
+        expires_at: Date.now() + tokens.expires_in * 1000,
+        account_id: accountId
       };
       this.saveCredentials(updatedCredentials);
       this.credentials = updatedCredentials;
-      log(`[GeminiOAuth] Token refreshed, valid until ${new Date(updatedCredentials.expires_at).toISOString()}`);
+      log(`[CodexOAuth] Token refreshed, valid until ${new Date(updatedCredentials.expires_at).toISOString()}`);
       return updatedCredentials.access_token;
     } catch (e) {
-      log(`[GeminiOAuth] Refresh failed: ${e.message}`);
-      throw new Error(`OAuth credentials invalid. Please run \`claudish login gemini\` again.
+      log(`[CodexOAuth] Refresh failed: ${e.message}`);
+      throw new Error(`OAuth credentials invalid. Please run \`claudish login codex\` again.
 
 Details: ${e.message}`);
     }
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync8(credPath)) {
+    if (!existsSync9(credPath)) {
       return null;
     }
     try {
       const data = readFileSync7(credPath, "utf-8");
-      const credentials = JSON.parse(data);
-      if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at) {
-        log("[GeminiOAuth] Invalid credentials file structure");
+      const credentials2 = JSON.parse(data);
+      if (!credentials2.access_token || !credentials2.refresh_token || !credentials2.expires_at) {
+        log("[CodexOAuth] Invalid credentials file structure");
         return null;
       }
-      log("[GeminiOAuth] Loaded credentials from file");
-      return credentials;
+      log("[CodexOAuth] Loaded credentials from file");
+      return credentials2;
     } catch (e) {
-      log(`[GeminiOAuth] Failed to load credentials: ${e.message}`);
+      log(`[CodexOAuth] Failed to load credentials: ${e.message}`);
       return null;
     }
   }
-  saveCredentials(credentials) {
+  saveCredentials(credentials2) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join10(homedir10(), ".claudish");
-    if (!existsSync8(claudishDir)) {
+    const claudishDir = join11(homedir11(), ".claudish");
+    if (!existsSync9(claudishDir)) {
       const { mkdirSync: mkdirSync6 } = __require("fs");
       mkdirSync6(claudishDir, { recursive: true });
     }
     const fd = openSync3(credPath, "w", 384);
     try {
-      const data = JSON.stringify(credentials, null, 2);
+      const data = JSON.stringify(credentials2, null, 2);
       writeSync3(fd, data, 0, "utf-8");
     } finally {
       closeSync3(fd);
     }
-    log(`[GeminiOAuth] Credentials saved to ${credPath}`);
+    log(`[CodexOAuth] Credentials saved to ${credPath}`);
   }
   generateCodeVerifier() {
     return randomBytes2(64).toString("base64url");
@@ -28984,26 +29928,46 @@ Details: ${e.message}`);
     const hash2 = createHash3("sha256").update(verifier).digest("base64url");
     return hash2;
   }
+  extractAccountId(idToken) {
+    try {
+      const parts = idToken.split(".");
+      if (parts.length !== 3)
+        return;
+      const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8"));
+      const authClaim = payload["https://api.openai.com/auth"];
+      const accountId = authClaim?.chatgpt_account_id || payload.chatgpt_account_id || authClaim?.user_id;
+      if (accountId) {
+        log(`[CodexOAuth] Extracted account ID from id_token: ${accountId}`);
+        return accountId;
+      }
+      return;
+    } catch (e) {
+      log(`[CodexOAuth] Failed to extract account ID from id_token: ${e.message}`);
+      return;
+    }
+  }
   buildAuthUrl(codeChallenge, state, redirectUri) {
-    const params = new URLSearchParams({
-      client_id: OAUTH_CONFIG2.clientId,
-      redirect_uri: redirectUri,
-      response_type: "code",
-      scope: OAUTH_CONFIG2.scopes.join(" "),
-      code_challenge: codeChallenge,
-      code_challenge_method: "S256",
-      access_type: "offline",
-      prompt: "consent",
-      state
-    });
-    return `${OAUTH_CONFIG2.authUrl}?${params.toString()}`;
+    const scope = OAUTH_CONFIG2.scopes.join("+");
+    const params = [
+      "response_type=code",
+      `client_id=${encodeURIComponent(OAUTH_CONFIG2.clientId)}`,
+      `redirect_uri=${encodeURIComponent(redirectUri)}`,
+      `scope=${scope}`,
+      `code_challenge=${encodeURIComponent(codeChallenge)}`,
+      "code_challenge_method=S256",
+      "id_token_add_organizations=true",
+      "codex_cli_simplified_flow=true",
+      `state=${encodeURIComponent(state)}`,
+      "originator=opencode"
+    ].join("&");
+    return `${OAUTH_CONFIG2.authUrl}?${params}`;
   }
   async startCallbackServer(codeChallenge, state) {
     return new Promise((resolve, reject) => {
       let redirectUri = "";
       const server = createServer2((req, res) => {
-        const url2 = new URL(req.url, redirectUri.replace("/callback", ""));
-        if (url2.pathname === "/callback") {
+        const url2 = new URL(req.url, redirectUri.replace("/auth/callback", ""));
+        if (url2.pathname === "/auth/callback") {
           const code = url2.searchParams.get("code");
           const callbackState = url2.searchParams.get("state");
           const error46 = url2.searchParams.get("error");
@@ -29068,15 +30032,15 @@ Details: ${e.message}`);
           res.end("Not found");
         }
       });
-      server.listen(0, () => {
+      server.listen(1455, () => {
         const address = server.address();
         if (!address || typeof address === "string") {
           reject(new Error("Failed to get server port"));
           return;
         }
         const port = address.port;
-        redirectUri = `http://localhost:${port}/callback`;
-        log(`[GeminiOAuth] Callback server started on http://localhost:${port}`);
+        redirectUri = `http://localhost:${port}/auth/callback`;
+        log(`[CodexOAuth] Callback server started on http://localhost:${port}`);
         const authUrl = this.buildAuthUrl(codeChallenge, state, redirectUri);
         this.openBrowser(authUrl);
       });
@@ -29090,7 +30054,7 @@ Details: ${e.message}`);
     });
   }
   async exchangeCodeForTokens(code, verifier, redirectUri) {
-    log("[GeminiOAuth] Exchanging auth code for tokens");
+    log("[CodexOAuth] Exchanging auth code for tokens");
     try {
       const response = await fetch(OAUTH_CONFIG2.tokenUrl, {
         method: "POST",
@@ -29102,7 +30066,6 @@ Details: ${e.message}`);
           code,
           redirect_uri: redirectUri,
           client_id: OAUTH_CONFIG2.clientId,
-          client_secret: OAUTH_CONFIG2.clientSecret,
           code_verifier: verifier
         })
       });
@@ -29116,7 +30079,7 @@ Details: ${e.message}`);
       }
       return tokens;
     } catch (e) {
-      throw new Error(`Failed to authenticate with Google OAuth: ${e.message}`);
+      throw new Error(`Failed to authenticate with OpenAI OAuth: ${e.message}`);
     }
   }
   async openBrowser(url2) {
@@ -29130,7 +30093,7 @@ Details: ${e.message}`);
         await execAsync2(`xdg-open "${url2}"`);
       }
       console.log(`
-Opening browser for authentication...`);
+Opening browser for OpenAI authentication...`);
       console.log(`If the browser doesn't open, visit this URL:
 ${url2}
 `);
@@ -29142,197 +30105,123 @@ Please open this URL in your browser to authenticate:`);
     }
   }
 }
-function reloadGeminiCredentials() {
-  GeminiOAuth.getInstance().reloadCredentials();
-  resetGeminiUserCache();
-}
-async function getValidAccessToken() {
-  const oauth = GeminiOAuth.getInstance();
-  return oauth.getAccessToken();
-}
-function resetGeminiUserCache() {
-  cachedProjectId = null;
-  cachedTierId = null;
-  cachedTierName = null;
-}
-function getGeminiTierDisplayName() {
-  if (!cachedTierId)
-    return "Gemini Free";
-  return TIER_SHORT_NAMES[cachedTierId] || cachedTierId.replace(/-tier$/, "");
-}
-function getGeminiTierFullName() {
-  if (cachedTierName)
-    return cachedTierName;
-  return getGeminiTierDisplayName();
+function getCodexOAuth() {
+  return CodexOAuth.getInstance();
 }
-async function setupGeminiUser(accessToken) {
-  if (cachedProjectId && cachedTierId) {
-    log(`[GeminiOAuth] Using cached project ID: ${cachedProjectId}, tier: ${cachedTierId}`);
-    return { projectId: cachedProjectId, tierId: cachedTierId };
+var execAsync2, OAUTH_CONFIG2;
+var init_codex_oauth = __esm(() => {
+  init_logger();
+  execAsync2 = promisify2(exec2);
+  OAUTH_CONFIG2 = {
+    clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+    authUrl: "https://auth.openai.com/oauth/authorize",
+    tokenUrl: "https://auth.openai.com/oauth/token",
+    scopes: ["openid", "profile", "email", "offline_access"]
+  };
+});
+
+// src/auth/credentials/composite-credential.ts
+class CompositeCredentialProvider {
+  catalogName;
+  primary;
+  fallback;
+  opts;
+  constructor(catalogName, primary, fallback, opts = {}) {
+    this.catalogName = catalogName;
+    this.primary = primary;
+    this.fallback = fallback;
+    this.opts = opts;
   }
-  const envProject = process.env.GOOGLE_CLOUD_PROJECT || process.env.GOOGLE_CLOUD_PROJECT_ID;
-  log("[GeminiOAuth] Calling loadCodeAssist...");
-  const loadRes = await callLoadCodeAssist(accessToken, envProject);
-  log(`[GeminiOAuth] loadCodeAssist response: ${JSON.stringify(loadRes)}`);
-  const resolvedTier = loadRes.paidTier?.id || (typeof loadRes.currentTier === "object" ? loadRes.currentTier?.id : loadRes.currentTier) || null;
-  if ((loadRes.currentTier || loadRes.paidTier) && loadRes.cloudaicompanionProject) {
-    const projectId2 = envProject || loadRes.cloudaicompanionProject;
-    if (projectId2) {
-      cachedProjectId = projectId2;
-      cachedTierId = resolvedTier || "free-tier";
-      cachedTierName = loadRes.paidTier?.name || null;
-      log(`[GeminiOAuth] User already set up, project: ${projectId2}, tier: ${cachedTierId}`);
-      return { projectId: projectId2, tierId: cachedTierId };
-    }
+  async isAvailable(opts) {
+    return await this.primary.isAvailable(opts) || await this.fallback.isAvailable(opts);
   }
-  const tierId = resolvedTier || loadRes.allowedTiers?.[0]?.id || "free-tier";
-  const isFree = tierId === "free-tier";
-  const onboardProject = isFree ? undefined : envProject;
-  const MAX_POLL_ATTEMPTS = 30;
-  log(`[GeminiOAuth] Onboarding user to ${tierId}...`);
-  let lro = await callOnboardUser(accessToken, tierId, onboardProject);
-  log(`[GeminiOAuth] Initial onboardUser response: done=${lro.done}`);
-  let attempts = 0;
-  while (!lro.done && attempts < MAX_POLL_ATTEMPTS) {
-    attempts++;
-    log(`[GeminiOAuth] Polling onboardUser (attempt ${attempts}/${MAX_POLL_ATTEMPTS})...`);
-    await new Promise((r) => setTimeout(r, 2000));
-    lro = await callOnboardUser(accessToken, tierId, onboardProject);
+  invalidate() {
+    this.primary.invalidate?.();
+    this.fallback.invalidate?.();
   }
-  if (!lro.done) {
-    throw new Error(`Gemini onboarding timed out after ${MAX_POLL_ATTEMPTS * 2} seconds`);
+  async getRequestAuth(ctx) {
+    if (await this.primary.isAvailable({ allowOpPrompt: ctx.allowOpPrompt })) {
+      try {
+        return await this.primary.getRequestAuth(ctx);
+      } catch (e) {
+        const signal = this.opts.fallbackSignal;
+        if (signal && String(e?.message) === signal) {
+          return this.fallback.getRequestAuth(ctx);
+        }
+        throw e;
+      }
+    }
+    return this.fallback.getRequestAuth(ctx);
   }
-  if (lro.error) {
-    throw new Error(`Gemini onboarding failed: ${JSON.stringify(lro.error)}`);
+  async login() {
+    await this.primary.login?.();
   }
-  const projectId = lro.response?.cloudaicompanionProject?.id;
-  if (!projectId) {
-    if (envProject) {
-      cachedProjectId = envProject;
-      cachedTierId = tierId;
-      return { projectId: envProject, tierId };
-    }
-    throw new Error("Gemini onboarding completed but no project ID returned.");
+  async logout() {
+    await this.primary.logout?.();
   }
-  cachedProjectId = projectId;
-  cachedTierId = tierId;
-  log(`[GeminiOAuth] Onboarding complete, project: ${projectId}, tier: ${tierId}`);
-  return { projectId, tierId };
 }
-async function callLoadCodeAssist(accessToken, projectId) {
-  const metadata = {
-    pluginType: "GEMINI",
-    ideType: "GEMINI_CLI",
-    platform: "PLATFORM_UNSPECIFIED",
-    duetProject: projectId
+
+// src/auth/credentials/codex-credential.ts
+function buildOAuthHeaders(token, accountId) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "OpenAI-Beta": "responses=experimental",
+    originator: "codex_cli_rs",
+    accept: "text/event-stream"
   };
-  const res = await fetch(`${CODE_ASSIST_API_BASE}:loadCodeAssist`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${accessToken}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ metadata, cloudaicompanionProject: projectId })
-  });
-  if (!res.ok) {
-    throw new Error(`loadCodeAssist failed: ${res.status} ${await res.text()}`);
+  if (accountId) {
+    headers["chatgpt-account-id"] = accountId;
+    headers["x-conversation-id"] = "claudish-session";
+    headers["x-session-id"] = "claudish-session";
   }
-  return await res.json();
+  return headers;
 }
-async function callOnboardUser(accessToken, tierId, projectId) {
-  const metadata = {
-    pluginType: "GEMINI",
-    ideType: "GEMINI_CLI",
-    platform: "PLATFORM_UNSPECIFIED",
-    duetProject: projectId
-  };
-  const res = await fetch(`${CODE_ASSIST_API_BASE}:onboardUser`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${accessToken}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      tierId,
-      metadata,
-      cloudaicompanionProject: projectId
-    })
-  });
-  if (!res.ok) {
-    throw new Error(`onboardUser failed: ${res.status} ${await res.text()}`);
+
+class CodexOAuthHalf {
+  catalogName = "openai-codex";
+  oauth = CodexOAuth.getInstance();
+  async isAvailable() {
+    return this.oauth.hasCredentials();
   }
-  return await res.json();
-}
-async function retrieveUserQuota(accessToken, projectId) {
-  try {
-    const res = await fetch(`${CODE_ASSIST_API_BASE}:retrieveUserQuota`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        "Content-Type": "application/json",
-        "User-Agent": `GeminiCLI/0.5.6/gemini-code-assist (${process.platform}; ${process.arch})`
-      },
-      body: JSON.stringify({ project: projectId })
-    });
-    if (!res.ok) {
-      log(`[GeminiOAuth] retrieveUserQuota failed: ${res.status}`);
-      return null;
-    }
-    return await res.json();
-  } catch (err) {
-    log(`[GeminiOAuth] retrieveUserQuota error: ${err}`);
-    return null;
+  async getRequestAuth(_ctx) {
+    const token = await this.oauth.getAccessToken();
+    const accountId = this.oauth.getAccountId();
+    return {
+      headers: buildOAuthHeaders(token, accountId),
+      endpoint: CODEX_RESPONSES_ENDPOINT,
+      transformPayload: (p) => ({
+        ...p,
+        store: false,
+        include: ["reasoning.encrypted_content"]
+      })
+    };
+  }
+  async login() {
+    await this.oauth.login();
+  }
+  async logout() {
+    await this.oauth.logout();
   }
 }
-var execAsync2, getDefaultClientId = () => {
-  const parts = [
-    "681255809395",
-    "oo8ft2oprdrnp9e3aqf6av3hmdib135j",
-    "apps",
-    "googleusercontent",
-    "com"
-  ];
-  return `${parts[0]}-${parts[1]}.${parts[2]}.${parts[3]}.${parts[4]}`;
-}, getDefaultClientSecret = () => {
-  const p = ["GOCSPX", "4uHgMPm", "1o7Sk", "geV6Cu5clXFsxl"];
-  return `${p[0]}-${p[1]}-${p[2]}-${p[3]}`;
-}, OAUTH_CONFIG2, CODE_ASSIST_API_BASE = "https://cloudcode-pa.googleapis.com/v1internal", CODE_ASSIST_FALLBACK_CHAIN, cachedProjectId = null, cachedTierId = null, cachedTierName = null, TIER_SHORT_NAMES;
-var init_gemini_oauth = __esm(() => {
-  init_logger();
-  execAsync2 = promisify2(exec2);
-  OAUTH_CONFIG2 = {
-    clientId: process.env.GEMINI_CLIENT_ID || getDefaultClientId(),
-    clientSecret: process.env.GEMINI_CLIENT_SECRET || getDefaultClientSecret(),
-    authUrl: "https://accounts.google.com/o/oauth2/v2/auth",
-    tokenUrl: "https://oauth2.googleapis.com/token",
-    scopes: [
-      "https://www.googleapis.com/auth/cloud-platform",
-      "https://www.googleapis.com/auth/userinfo.email",
-      "https://www.googleapis.com/auth/userinfo.profile"
-    ]
-  };
-  CODE_ASSIST_FALLBACK_CHAIN = [
-    "gemini-3.1-pro-preview",
-    "gemini-3-pro-preview",
-    "gemini-3-flash-preview",
-    "gemini-2.5-pro",
-    "gemini-2.5-flash"
-  ];
-  TIER_SHORT_NAMES = {
-    "free-tier": "GeminiCA Free",
-    "standard-tier": "GeminiCA Std",
-    "g1-pro-tier": "GeminiCA Pro",
-    "legacy-tier": "GeminiCA Legacy"
-  };
+function makeCodexCredential() {
+  return new CompositeCredentialProvider("openai-codex", new CodexOAuthHalf, new ApiKeyCredentialProvider({
+    catalogName: "openai-codex",
+    envVar: "OPENAI_CODEX_API_KEY"
+  }));
+}
+var CODEX_RESPONSES_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+var init_codex_credential = __esm(() => {
+  init_codex_oauth();
+  init_api_key_credential();
 });
 
 // src/auth/oauth-registry.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
-import { homedir as homedir11 } from "os";
-import { join as join11 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join12 } from "path";
 function hasValidOAuthCredentials(descriptor) {
-  const credPath = join11(homedir11(), ".claudish", descriptor.credentialFile);
-  if (!existsSync9(credPath))
+  const credPath = join12(homedir12(), ".claudish", descriptor.credentialFile);
+  if (!existsSync10(credPath))
     return false;
   if (descriptor.validationMode === "file-exists") {
     return true;
@@ -29395,13 +30284,8 @@ var init_oauth_registry = __esm(() => {
 });
 
 // src/auth/credentials/gemini-credential.ts
-import { randomUUID } from "crypto";
-function buildGeminiCliUserAgent(model) {
-  const version2 = "0.5.6";
-  const modelSegment = model || "gemini-code-assist";
-  return `GeminiCLI/${version2}/${modelSegment} (${process.platform}; ${process.arch})`;
-}
-function createActivityRequestId() {
+import { randomUUID as randomUUID3 } from "crypto";
+function createActivityRequestId3() {
   return Math.random().toString(36).substring(7);
 }
 
@@ -29416,14 +30300,14 @@ class GeminiCodeAssistCredentialProvider {
     return {
       headers: {
         Authorization: `Bearer ${token}`,
-        "User-Agent": buildGeminiCliUserAgent(ctx.model),
-        "x-activity-request-id": createActivityRequestId()
+        "User-Agent": buildCodeAssistUserAgent(ctx.model),
+        "x-activity-request-id": createActivityRequestId3()
       },
       transformPayload: (inner) => {
         const env = {
           model: ctx.model,
           project: projectId,
-          user_prompt_id: randomUUID(),
+          user_prompt_id: randomUUID3(),
           request: inner
         };
         if (tierId && tierId !== "free-tier") {
@@ -29448,9 +30332,9 @@ var init_gemini_credential = __esm(() => {
 // src/auth/kimi-oauth.ts
 import { exec as exec3 } from "child_process";
 import { randomBytes as randomBytes3 } from "crypto";
-import { closeSync as closeSync4, existsSync as existsSync10, openSync as openSync4, readFileSync as readFileSync9, unlinkSync as unlinkSync4, writeSync as writeSync4 } from "fs";
-import { homedir as homedir12, hostname as hostname3, platform, release as release2 } from "os";
-import { join as join12 } from "path";
+import { closeSync as closeSync4, existsSync as existsSync11, openSync as openSync4, readFileSync as readFileSync9, unlinkSync as unlinkSync4, writeSync as writeSync4 } from "fs";
+import { homedir as homedir13, hostname as hostname3, platform, release as release2 } from "os";
+import { join as join13 } from "path";
 import { promisify as promisify3 } from "util";
 
 class KimiOAuth {
@@ -29478,21 +30362,21 @@ class KimiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join12(homedir12(), ".claudish");
-    return join12(claudishDir, "kimi-oauth.json");
+    const claudishDir = join13(homedir13(), ".claudish");
+    return join13(claudishDir, "kimi-oauth.json");
   }
   getDeviceIdPath() {
-    const claudishDir = join12(homedir12(), ".claudish");
-    return join12(claudishDir, "kimi-device-id");
+    const claudishDir = join13(homedir13(), ".claudish");
+    return join13(claudishDir, "kimi-device-id");
   }
   loadOrCreateDeviceId() {
     const deviceIdPath = this.getDeviceIdPath();
-    const claudishDir = join12(homedir12(), ".claudish");
-    if (!existsSync10(claudishDir)) {
+    const claudishDir = join13(homedir13(), ".claudish");
+    if (!existsSync11(claudishDir)) {
       const { mkdirSync: mkdirSync6 } = __require("fs");
       mkdirSync6(claudishDir, { recursive: true });
     }
-    if (existsSync10(deviceIdPath)) {
+    if (existsSync11(deviceIdPath)) {
       try {
         const deviceId2 = readFileSync9(deviceIdPath, "utf-8").trim();
         if (deviceId2) {
@@ -29544,15 +30428,15 @@ Please authorize this device:`);
 Waiting for authorization...`);
     await this.openBrowser(deviceAuth.verification_uri_complete);
     const tokens = await this.pollForToken(deviceAuth.device_code, deviceAuth.interval, deviceAuth.expires_in);
-    const credentials = {
+    const credentials2 = {
       access_token: tokens.access_token,
       refresh_token: tokens.refresh_token,
       expires_at: Date.now() + tokens.expires_in * 1000,
       scope: tokens.scope,
       token_type: tokens.token_type
     };
-    this.saveCredentials(credentials);
-    this.credentials = credentials;
+    this.saveCredentials(credentials2);
+    this.credentials = credentials2;
     log("[KimiOAuth] Login successful");
   }
   async requestDeviceAuthorization() {
@@ -29665,7 +30549,7 @@ Waiting for authorization...`);
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync10(credPath)) {
+    if (existsSync11(credPath)) {
       unlinkSync4(credPath);
       log("[KimiOAuth] Credentials deleted");
     }
@@ -29732,7 +30616,7 @@ Waiting for authorization...`);
     } catch (e) {
       log(`[KimiOAuth] Refresh failed: ${e.message}`);
       const credPath = this.getCredentialsPath();
-      if (existsSync10(credPath)) {
+      if (existsSync11(credPath)) {
         unlinkSync4(credPath);
       }
       this.credentials = null;
@@ -29749,33 +30633,33 @@ Details: ${e.message}`);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync10(credPath)) {
+    if (!existsSync11(credPath)) {
       return null;
     }
     try {
       const data = readFileSync9(credPath, "utf-8");
-      const credentials = JSON.parse(data);
-      if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at || !credentials.scope || !credentials.token_type) {
+      const credentials2 = JSON.parse(data);
+      if (!credentials2.access_token || !credentials2.refresh_token || !credentials2.expires_at || !credentials2.scope || !credentials2.token_type) {
         log("[KimiOAuth] Invalid credentials file structure");
         return null;
       }
       log("[KimiOAuth] Loaded credentials from file");
-      return credentials;
+      return credentials2;
     } catch (e) {
       log(`[KimiOAuth] Failed to load credentials: ${e.message}`);
       return null;
     }
   }
-  saveCredentials(credentials) {
+  saveCredentials(credentials2) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join12(homedir12(), ".claudish");
-    if (!existsSync10(claudishDir)) {
+    const claudishDir = join13(homedir13(), ".claudish");
+    if (!existsSync11(claudishDir)) {
       const { mkdirSync: mkdirSync6 } = __require("fs");
       mkdirSync6(claudishDir, { recursive: true });
     }
     const fd = openSync4(credPath, "w", 384);
     try {
-      const data = JSON.stringify(credentials, null, 2);
+      const data = JSON.stringify(credentials2, null, 2);
       writeSync4(fd, data, 0, "utf-8");
     } finally {
       closeSync4(fd);
@@ -29943,9 +30827,9 @@ var init_native_anthropic_credential = __esm(() => {
 
 // src/auth/vertex-auth.ts
 import { exec as exec4 } from "child_process";
-import { existsSync as existsSync11 } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join13 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join14 } from "path";
 import { promisify as promisify4 } from "util";
 
 class VertexAuthManager {
@@ -30000,8 +30884,8 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join13(homedir13(), ".config/gcloud/application_default_credentials.json");
-      if (!existsSync11(adcPath)) {
+      const adcPath = join14(homedir14(), ".config/gcloud/application_default_credentials.json");
+      if (!existsSync12(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
       }
@@ -30025,7 +30909,7 @@ class VertexAuthManager {
     if (!credPath) {
       return null;
     }
-    if (!existsSync11(credPath)) {
+    if (!existsSync12(credPath)) {
       throw new Error(`Service account file not found: ${credPath}
 
 Check GOOGLE_APPLICATION_CREDENTIALS path.`);
@@ -30064,8 +30948,8 @@ function validateVertexOAuthConfig() {
 ` + `  export VERTEX_PROJECT='your-gcp-project-id'
 ` + "  export VERTEX_LOCATION='us-central1'  # optional";
   }
-  const adcPath = join13(homedir13(), ".config/gcloud/application_default_credentials.json");
-  const hasADC = existsSync11(adcPath);
+  const adcPath = join14(homedir14(), ".config/gcloud/application_default_credentials.json");
+  const hasADC = existsSync12(adcPath);
   const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
   if (!hasADC && !hasServiceAccount) {
     return `No Vertex AI credentials found.
@@ -30184,6 +31068,7 @@ class CredentialAuthority {
     const authority = new CredentialAuthority;
     authority.register(makeCodexCredential(), ["openai-codex"]);
     authority.register(new GeminiCodeAssistCredentialProvider, ["gemini-codeassist"]);
+    authority.register(new AntigravityCredentialProvider, ["antigravity"]);
     authority.register(makeKimiCredential(), ["kimi"]);
     authority.register(makeKimiCodingCredential(), ["kimi-coding"]);
     authority.register(new VertexCredentialProvider, ["vertex"]);
@@ -30194,6 +31079,7 @@ class CredentialAuthority {
     const alreadyRegistered = new Set([
       "openai-codex",
       "gemini-codeassist",
+      "antigravity",
       "kimi",
       "kimi-coding",
       "vertex",
@@ -30222,6 +31108,7 @@ class CredentialAuthority {
 var LOCAL_PROVIDER_NAMES, RUNTIME_NAME_ALIASES, credentials;
 var init_authority = __esm(() => {
   init_provider_definitions();
+  init_antigravity_credential();
   init_api_key_credential();
   init_codex_credential();
   init_gemini_credential();
@@ -30237,6 +31124,13 @@ var init_authority = __esm(() => {
 });
 
 // src/providers/model-parser.ts
+function warnGoAliasDeprecatedOnce() {
+  if (_goDeprecationWarned)
+    return;
+  _goDeprecationWarned = true;
+  process.stderr.write(`[claudish] go@ is deprecated \u2014 use ag@<model> (Antigravity). Routing there.
+`);
+}
 function parseModelSpec(modelSpec) {
   const original = modelSpec;
   if (modelSpec.startsWith("http://") || modelSpec.startsWith("https://")) {
@@ -30259,6 +31153,8 @@ function parseModelSpec(modelSpec) {
       concurrency = Number.parseInt(concurrencyMatch[2], 10);
     }
     const provider = PROVIDER_SHORTCUTS[providerPart] || providerPart;
+    if (providerPart === "go")
+      warnGoAliasDeprecatedOnce();
     return {
       provider,
       model: modelPart,
@@ -30272,6 +31168,8 @@ function parseModelSpec(modelSpec) {
   for (const { prefix, provider, stripPrefix } of LEGACY_PREFIX_PATTERNS) {
     if (lowerSpec.startsWith(prefix)) {
       const model = stripPrefix ? modelSpec.slice(prefix.length) : modelSpec;
+      if (prefix === "go/")
+        warnGoAliasDeprecatedOnce();
       let concurrency;
       let modelName = model;
       if (LOCAL_PROVIDERS.has(provider)) {
@@ -30332,7 +31230,7 @@ function getLegacySyntaxWarning(parsed) {
   return `Deprecation warning: "${parsed.original}" uses legacy prefix syntax.
 ` + `  Consider using: ${newSyntax}`;
 }
-var PROVIDER_SHORTCUTS, LOCAL_PROVIDERS, NATIVE_MODEL_PATTERNS, LEGACY_PREFIX_PATTERNS;
+var PROVIDER_SHORTCUTS, _goDeprecationWarned = false, LOCAL_PROVIDERS, NATIVE_MODEL_PATTERNS, LEGACY_PREFIX_PATTERNS;
 var init_model_parser = __esm(() => {
   init_provider_definitions();
   PROVIDER_SHORTCUTS = getShortcuts();
@@ -30612,11 +31510,11 @@ var init_routing_hints = __esm(() => {
 });
 
 // src/providers/all-models-cache.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir14 } from "os";
-import { dirname as dirname5, join as join14 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir15 } from "os";
+import { dirname as dirname5, join as join15 } from "path";
 function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
-  if (!existsSync12(path))
+  if (!existsSync13(path))
     return null;
   let raw;
   try {
@@ -30650,7 +31548,7 @@ function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
 }
 var ALL_MODELS_CACHE_PATH;
 var init_all_models_cache = __esm(() => {
-  ALL_MODELS_CACHE_PATH = join14(homedir14(), ".claudish", "all-models.json");
+  ALL_MODELS_CACHE_PATH = join15(homedir15(), ".claudish", "all-models.json");
 });
 
 // src/adapters/model-catalog.ts
@@ -31745,10 +32643,10 @@ var init_signal_watcher = __esm(() => {
 
 // src/channel/session-manager.ts
 import { spawn } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { createWriteStream, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join15 } from "path";
+import { homedir as homedir16 } from "os";
+import { join as join16 } from "path";
 
 class SessionManager {
   sessions = new Map;
@@ -31765,13 +32663,13 @@ class SessionManager {
     if (this.activeSessions >= this.maxSessions) {
       throw new Error(`Max sessions (${this.maxSessions}) reached`);
     }
-    const sessionId = randomUUID2().slice(0, 8);
+    const sessionId = randomUUID4().slice(0, 8);
     const timeout = Math.min(opts.timeoutSeconds ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     const startedAt = new Date().toISOString();
-    const sessionDir = join15(homedir15(), ".claudish", "sessions", sessionId);
+    const sessionDir = join16(homedir16(), ".claudish", "sessions", sessionId);
     mkdirSync7(sessionDir, { recursive: true });
     if (opts.prompt) {
-      writeFileSync7(join15(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync7(join16(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     }
     const args = ["--model", opts.model, "-y", "--stdin", "--quiet", ...opts.claudishFlags ?? []];
     const proc = spawn("claudish", args, {
@@ -31798,7 +32696,7 @@ class SessionManager {
         });
       }
     });
-    const outputLogStream = createWriteStream(join15(sessionDir, "output.log"));
+    const outputLogStream = createWriteStream(join16(sessionDir, "output.log"));
     const entry = {
       info: {
         sessionId,
@@ -31845,9 +32743,9 @@ class SessionManager {
       watcher.processExited(code);
       outputLogStream.end();
       if (entry.stderr) {
-        writeFileSync7(join15(sessionDir, "stderr.log"), entry.stderr, "utf-8");
+        writeFileSync7(join16(sessionDir, "stderr.log"), entry.stderr, "utf-8");
       }
-      writeFileSync7(join15(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
+      writeFileSync7(join16(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
       this.cleanupSigint();
     });
     proc.on("error", (err) => {
@@ -32020,9 +32918,9 @@ var init_cache_ttl = __esm(() => {
 });
 
 // src/model-loader.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir16 } from "os";
-import { join as join16 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
+import { homedir as homedir17 } from "os";
+import { join as join17 } from "path";
 function groupRecommendedModels(entries) {
   const byId = new Map;
   for (const entry of entries) {
@@ -32118,7 +33016,7 @@ async function getRecommendedModels(opts = {}) {
   if (!forceRefresh && _cachedRecommendedModels) {
     return _cachedRecommendedModels;
   }
-  if (!forceRefresh && existsSync13(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (!forceRefresh && existsSync14(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
       const cacheData = JSON.parse(readFileSync11(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
@@ -32136,7 +33034,7 @@ async function getRecommendedModels(opts = {}) {
       if (data.models && data.models.length > 0) {
         _cachedRecommendedModels = data;
         try {
-          const cacheDir = join16(homedir16(), ".claudish");
+          const cacheDir = join17(homedir17(), ".claudish");
           mkdirSync8(cacheDir, { recursive: true });
           writeFileSync8(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
         } catch {}
@@ -32149,7 +33047,7 @@ async function getRecommendedModels(opts = {}) {
 function getRecommendedModelsSync() {
   if (_cachedRecommendedModels)
     return _cachedRecommendedModels;
-  if (existsSync13(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (existsSync14(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
       const cacheData = JSON.parse(readFileSync11(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
@@ -32275,7 +33173,7 @@ var _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels =
 var init_model_loader = __esm(() => {
   init_cache_ttl();
   FIREBASE_RECOMMENDED_URL = `${FIREBASE_BASE_URL}?catalog=recommended`;
-  RECOMMENDED_MODELS_CACHE_PATH = join16(homedir16(), ".claudish", "recommended-models-cache.json");
+  RECOMMENDED_MODELS_CACHE_PATH = join17(homedir17(), ".claudish", "recommended-models-cache.json");
   FIREBASE_SLUG_TO_PROVIDER_NAME = {
     openai: "openai",
     google: "google",
@@ -37176,8 +38074,8 @@ var init_harness = __esm(() => {
 
 // src/behavior/journal.ts
 import { appendFile as appendFile2, mkdir, stat } from "fs/promises";
-import { homedir as homedir17 } from "os";
-import { dirname as dirname6, join as join17 } from "path";
+import { homedir as homedir18 } from "os";
+import { dirname as dirname6, join as join18 } from "path";
 function classifyPath(observed, expected) {
   if (!observed)
     return "not_applicable";
@@ -37189,7 +38087,7 @@ function classifyPath(observed, expected) {
   return dirOf(observed) === dirOf(expected) ? "same_dir_wrong_name" : "outside_expected_dir";
 }
 function journalPath() {
-  return join17(homedir17(), ".claudish", "behavior-journal.jsonl");
+  return join18(homedir18(), ".claudish", "behavior-journal.jsonl");
 }
 async function recordDecision(entry, path = journalPath()) {
   try {
@@ -37406,10 +38304,10 @@ __export(exports_live_log, {
   recordLiveDivergence: () => recordLiveDivergence
 });
 import { appendFile as appendFile3 } from "fs/promises";
-import { homedir as homedir18 } from "os";
-import { join as join18 } from "path";
+import { homedir as homedir19 } from "os";
+import { join as join19 } from "path";
 function defaultPath() {
-  return join18(homedir18(), ".claudish", "behavior-divergences.jsonl");
+  return join19(homedir19(), ".claudish", "behavior-divergences.jsonl");
 }
 async function recordLiveDivergence(entry, path = defaultPath()) {
   try {
@@ -37830,8 +38728,8 @@ var init_hooks = __esm(() => {
 
 // src/behavior/observer/corpus.ts
 import { appendFileSync as appendFileSync3, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { homedir as homedir19 } from "os";
-import { join as join19 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join20 } from "path";
 function directoryOf2(filePath) {
   const slash = filePath.lastIndexOf("/");
   return slash > 0 ? filePath.slice(0, slash) : undefined;
@@ -37910,26 +38808,26 @@ function listTranscripts(root) {
     return files;
   }
   for (const project of projects) {
-    const dir = join19(root, project);
+    const dir = join20(root, project);
     try {
       if (!statSync2(dir).isDirectory())
         continue;
       for (const f of readdirSync2(dir)) {
         if (f.endsWith(".jsonl"))
-          files.push(join19(dir, f));
+          files.push(join20(dir, f));
       }
     } catch {}
   }
   return files;
 }
 function buildCorpus(options = {}) {
-  const root = options.projectsRoot ?? join19(homedir19(), ".claude", "projects");
+  const root = options.projectsRoot ?? join20(homedir20(), ".claude", "projects");
   const files = listTranscripts(root);
   const records = [];
   for (const f of files)
     records.push(...replayTranscript(f));
   if (options.write && records.length > 0) {
-    const outputPath = options.outputPath ?? join19(homedir19(), ".claudish", "behavior-divergences.jsonl");
+    const outputPath = options.outputPath ?? join20(homedir20(), ".claudish", "behavior-divergences.jsonl");
     try {
       appendFileSync3(outputPath, `${records.map((r) => JSON.stringify(r)).join(`
 `)}
@@ -38540,23 +39438,23 @@ var init_vision_proxy = __esm(() => {
 
 // src/stats-buffer.ts
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync13,
   renameSync,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync9
 } from "fs";
-import { homedir as homedir20 } from "os";
-import { join as join20 } from "path";
+import { homedir as homedir21 } from "os";
+import { join as join21 } from "path";
 function ensureDir() {
-  if (!existsSync14(CLAUDISH_DIR)) {
+  if (!existsSync15(CLAUDISH_DIR)) {
     mkdirSync9(CLAUDISH_DIR, { recursive: true });
   }
 }
 function readFromDisk() {
   try {
-    if (!existsSync14(BUFFER_FILE))
+    if (!existsSync15(BUFFER_FILE))
       return [];
     const raw2 = readFileSync13(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw2);
@@ -38583,7 +39481,7 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed };
-    const tmpFile = join20(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    const tmpFile = join21(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
     writeFileSync9(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync(tmpFile, BUFFER_FILE);
     memoryCache = trimmed;
@@ -38627,7 +39525,7 @@ function clearBuffer() {
   try {
     memoryCache = [];
     eventsSinceLastFlush = 0;
-    if (existsSync14(BUFFER_FILE)) {
+    if (existsSync15(BUFFER_FILE)) {
       unlinkSync5(BUFFER_FILE);
     }
   } catch {}
@@ -38656,8 +39554,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, flushScheduled = false;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join20(homedir20(), ".claudish");
-  BUFFER_FILE = join20(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join21(homedir21(), ".claudish");
+  BUFFER_FILE = join21(CLAUDISH_DIR, "stats-buffer.json");
   process.on("exit", syncFlushOnExit);
   process.on("SIGTERM", () => {
     try {
@@ -40938,8 +41836,8 @@ var init_openai_responses_sse = __esm(() => {
 
 // src/handlers/shared/token-tracker.ts
 import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir21 } from "os";
-import { dirname as dirname7, join as join21 } from "path";
+import { homedir as homedir22 } from "os";
+import { dirname as dirname7, join as join22 } from "path";
 
 class TokenTracker {
   port;
@@ -41083,7 +41981,7 @@ class TokenTracker {
         data.quota_remaining = this.quotaRemaining;
       }
       const override = process.env.CLAUDISH_TOKEN_FILE;
-      const outPath = override || join21(homedir21(), ".claudish", `tokens-${this.port}.json`);
+      const outPath = override || join22(homedir22(), ".claudish", `tokens-${this.port}.json`);
       mkdirSync10(dirname7(outPath), { recursive: true });
       writeFileSync10(outPath, JSON.stringify(data), "utf-8");
     } catch (e) {
@@ -41304,6 +42202,9 @@ class ComposedHandler {
           isInteractive: this.isInteractive,
           authType: "oauth"
         });
+        if (err?.terminal) {
+          return c.json(wrapAnthropicError(400, err.message, "invalid_request_error"), 400);
+        }
         return c.json(wrapAnthropicError(401, err.message, "authentication_error"), 401);
       }
     }
@@ -41898,7 +42799,7 @@ function isRetryableError(status, errorBody) {
     }
   }
   if (status === 400) {
-    if (lower.includes("model not found") || lower.includes("not registered") || lower.includes("does not exist") || lower.includes("unknown model") || lower.includes("unsupported model") || lower.includes("no healthy deployment")) {
+    if (lower.includes("model not found") || lower.includes("not registered") || lower.includes("does not exist") || lower.includes("unknown model") || lower.includes("unsupported model") || lower.includes("no healthy deployment") || lower.includes("requires a google cloud project") || lower.includes("unsupported_client")) {
       return true;
     }
   }
@@ -43582,11 +44483,11 @@ var init_ollama_api_format = __esm(() => {
 });
 
 // src/providers/api-key-provenance.ts
-import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
-import { homedir as homedir22 } from "os";
-import { join as join22, resolve as resolve2 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
+import { homedir as homedir23 } from "os";
+import { join as join23, resolve as resolve2 } from "path";
 function activeConfigPath() {
-  return activeGlobalConfigFile(join22(homedir22(), ".claudish", "config.json"));
+  return activeGlobalConfigFile(join23(homedir23(), ".claudish", "config.json"));
 }
 function configLayerLabel() {
   return getConfigFileOverride() ? activeConfigPath() : "~/.claudish/config.json";
@@ -43663,7 +44564,7 @@ function formatProvenanceLog(p) {
 function readDotenvKey(envVars) {
   try {
     const dotenvPath = resolve2(".env");
-    if (!existsSync15(dotenvPath))
+    if (!existsSync16(dotenvPath))
       return null;
     const parsed = import_dotenv.parse(readFileSync14(dotenvPath, "utf-8"));
     for (const v of envVars) {
@@ -43678,7 +44579,7 @@ function readDotenvKey(envVars) {
 function readConfigKey(envVar) {
   try {
     const configPath = activeConfigPath();
-    if (!existsSync15(configPath))
+    if (!existsSync16(configPath))
       return null;
     const cfg = JSON.parse(readFileSync14(configPath, "utf-8"));
     return cfg.apiKeys?.[envVar] || null;
@@ -43692,142 +44593,6 @@ var init_api_key_provenance = __esm(() => {
   import_dotenv = __toESM(require_main(), 1);
 });
 
-// src/handlers/shared/gemini-queue.ts
-class GeminiRequestQueue {
-  static instance = null;
-  queue = [];
-  processing = false;
-  minDelayMs = 1000;
-  lastRequestTime = 0;
-  consecutiveErrors = 0;
-  totalProcessed = 0;
-  totalErrors = 0;
-  baseDelayMs = 1000;
-  maxDelayMs = 1e4;
-  maxQueueSize = 100;
-  constructor() {
-    log("[GeminiQueue] Queue initialized with minDelay=1000ms, maxQueueSize=100");
-  }
-  static getInstance() {
-    if (!GeminiRequestQueue.instance) {
-      GeminiRequestQueue.instance = new GeminiRequestQueue;
-    }
-    return GeminiRequestQueue.instance;
-  }
-  async enqueue(fetchFn) {
-    if (this.queue.length >= this.maxQueueSize) {
-      log(`[GeminiQueue] Queue full (${this.queue.length}/${this.maxQueueSize}), rejecting request`);
-      throw new Error("Gemini request queue full. Please retry later.");
-    }
-    return new Promise((resolve3, reject) => {
-      const queuedRequest = {
-        fetchFn,
-        resolve: resolve3,
-        reject
-      };
-      this.queue.push(queuedRequest);
-      log(`[GeminiQueue] Request enqueued (queue length: ${this.queue.length})`);
-      if (!this.processing) {
-        this.processQueue();
-      }
-    });
-  }
-  async processQueue() {
-    if (this.processing) {
-      return;
-    }
-    this.processing = true;
-    log("[GeminiQueue] Worker started");
-    while (this.queue.length > 0) {
-      const request = this.queue.shift();
-      if (!request)
-        break;
-      log(`[GeminiQueue] Processing request (${this.queue.length} remaining in queue)`);
-      try {
-        await this.waitForNextSlot();
-        const response = await request.fetchFn();
-        this.lastRequestTime = Date.now();
-        if (response.status === 429) {
-          this.totalErrors++;
-          const errorText = await response.clone().text();
-          this.handleRateLimitResponse(errorText);
-          log(`[GeminiQueue] Rate limit hit (429), adjusted delay to ${this.minDelayMs}ms`);
-        } else {
-          this.handleSuccessResponse();
-        }
-        this.totalProcessed++;
-        request.resolve(response);
-      } catch (error46) {
-        this.totalErrors++;
-        log(`[GeminiQueue] Request failed with error: ${error46}`);
-        request.reject(error46 instanceof Error ? error46 : new Error(String(error46)));
-      }
-    }
-    this.processing = false;
-    log("[GeminiQueue] Worker stopped (queue empty)");
-  }
-  async waitForNextSlot() {
-    const now = Date.now();
-    const timeSinceLastRequest = now - this.lastRequestTime;
-    let delayMs = this.minDelayMs;
-    if (this.consecutiveErrors > 0) {
-      const backoffMultiplier = 1 + this.consecutiveErrors * 0.5;
-      delayMs = Math.min(this.minDelayMs * backoffMultiplier, this.maxDelayMs);
-      log(`[GeminiQueue] Applying backoff (${this.consecutiveErrors} errors): ${delayMs}ms`);
-    }
-    if (timeSinceLastRequest < delayMs) {
-      const waitMs = delayMs - timeSinceLastRequest;
-      log(`[GeminiQueue] Waiting ${waitMs}ms before next request`);
-      await new Promise((resolve3) => setTimeout(resolve3, waitMs));
-    }
-  }
-  handleRateLimitResponse(errorText) {
-    this.consecutiveErrors++;
-    try {
-      const errorData = JSON.parse(errorText);
-      const quotaDetail = errorData?.error?.details?.find((d) => d.quotaResetDelay);
-      if (quotaDetail?.quotaResetDelay) {
-        const delayStr = quotaDetail.quotaResetDelay;
-        const match2 = delayStr.match(/(\d+(?:\.\d+)?)/);
-        if (match2) {
-          const delaySeconds = Number.parseFloat(match2[1]);
-          const suggestedDelayMs = Math.ceil(delaySeconds * 1000);
-          this.minDelayMs = Math.max(suggestedDelayMs, this.minDelayMs, this.baseDelayMs);
-          this.minDelayMs = Math.min(this.minDelayMs, this.maxDelayMs);
-          log(`[GeminiQueue] Parsed quotaResetDelay: ${delayStr} (${suggestedDelayMs}ms), ` + `new minDelay: ${this.minDelayMs}ms`);
-        }
-      }
-    } catch {
-      log("[GeminiQueue] Failed to parse rate limit response, using backoff");
-    }
-    const backoffMultiplier = 1 + this.consecutiveErrors * 0.5;
-    this.minDelayMs = Math.min(this.baseDelayMs * backoffMultiplier, this.maxDelayMs);
-  }
-  handleSuccessResponse() {
-    if (this.consecutiveErrors > 0) {
-      log(`[GeminiQueue] Success after ${this.consecutiveErrors} errors, resetting counter`);
-      this.consecutiveErrors = 0;
-    }
-    if (this.minDelayMs > this.baseDelayMs) {
-      this.minDelayMs = Math.max(this.baseDelayMs, this.minDelayMs * 0.9);
-      log(`[GeminiQueue] Reducing delay to ${this.minDelayMs}ms`);
-    }
-  }
-  getStats() {
-    return {
-      queueLength: this.queue.length,
-      processing: this.processing,
-      consecutiveErrors: this.consecutiveErrors,
-      currentDelayMs: this.minDelayMs,
-      totalProcessed: this.totalProcessed,
-      totalErrors: this.totalErrors
-    };
-  }
-}
-var init_gemini_queue = __esm(() => {
-  init_logger();
-});
-
 // src/providers/transport/gemini-apikey.ts
 class GeminiProviderTransport {
   name = "gemini";
@@ -43860,22 +44625,17 @@ var init_gemini_apikey = __esm(() => {
 });
 
 // src/providers/transport/gemini-codeassist.ts
-import { randomUUID as randomUUID3 } from "crypto";
-function buildGeminiCliUserAgent2(model) {
-  const version2 = "0.5.6";
-  const modelSegment = model || "gemini-code-assist";
-  return `GeminiCLI/${version2}/${modelSegment} (${process.platform}; ${process.arch})`;
-}
-function createActivityRequestId2() {
+import { randomUUID as randomUUID5 } from "crypto";
+function createActivityRequestId4() {
   return Math.random().toString(36).substring(7);
 }
-function classify429(responseBody) {
+function classify4292(responseBody) {
   try {
     const raw2 = JSON.parse(responseBody);
     const error46 = Array.isArray(raw2) ? raw2[0]?.error : raw2?.error;
     const details = Array.isArray(error46?.details) ? error46.details : [];
     const retryInfo = details.find((d) => d["@type"] === "type.googleapis.com/google.rpc.RetryInfo");
-    let retryDelayMs = parseRetryDelay(retryInfo?.retryDelay);
+    let retryDelayMs = parseRetryDelay2(retryInfo?.retryDelay);
     if (retryDelayMs === undefined && typeof error46?.message === "string") {
       const match2 = error46.message.match(/retry in ([\d.]+)(ms|s)/i);
       if (match2) {
@@ -43889,7 +44649,7 @@ function classify429(responseBody) {
       return { terminal: true, retryDelayMs, reason };
     }
     if (reason === "RATE_LIMIT_EXCEEDED") {
-      return { terminal: false, retryDelayMs: retryDelayMs ?? DEFAULT_RATE_LIMIT_DELAY_MS, reason };
+      return { terminal: false, retryDelayMs: retryDelayMs ?? DEFAULT_RATE_LIMIT_DELAY_MS2, reason };
     }
     if (reason === "MODEL_CAPACITY_EXHAUSTED") {
       return { terminal: true, retryDelayMs, reason };
@@ -43909,7 +44669,7 @@ function classify429(responseBody) {
     return null;
   }
 }
-function parseRetryDelay(value) {
+function parseRetryDelay2(value) {
   if (!value)
     return;
   if (typeof value === "string") {
@@ -43927,7 +44687,7 @@ function parseRetryDelay(value) {
 
 class GeminiCodeAssistProviderTransport {
   name = "gemini-codeassist";
-  _displayName = "Gemini Free";
+  _displayName = "GeminiCA";
   get displayName() {
     return this._displayName;
   }
@@ -43937,19 +44697,17 @@ class GeminiCodeAssistProviderTransport {
   projectId = null;
   tierId = null;
   cachedAuth = null;
-  fallbackStartIndex;
   lastEnvelope = null;
   _activeModelName;
+  servedModels = [];
   constructor(modelName) {
     this.modelName = modelName;
-    const idx = CODE_ASSIST_FALLBACK_CHAIN.indexOf(modelName);
-    this.fallbackStartIndex = idx >= 0 ? idx : CODE_ASSIST_FALLBACK_CHAIN.length;
   }
   getActiveModelName() {
     return this._activeModelName;
   }
   getEndpoint() {
-    return CODE_ASSIST_ENDPOINT;
+    return CODE_ASSIST_ENDPOINT2;
   }
   async getHeaders() {
     if (this.cachedAuth)
@@ -43959,8 +44717,8 @@ class GeminiCodeAssistProviderTransport {
   buildLocalHeaders() {
     return {
       Authorization: `Bearer ${this.accessToken}`,
-      "User-Agent": buildGeminiCliUserAgent2(this.modelName),
-      "x-activity-request-id": createActivityRequestId2()
+      "User-Agent": buildCodeAssistUserAgent(this.modelName),
+      "x-activity-request-id": createActivityRequestId4()
     };
   }
   async refreshAuth() {
@@ -43972,7 +44730,8 @@ class GeminiCodeAssistProviderTransport {
     this.projectId = projectId;
     this.tierId = tierId;
     this._displayName = getGeminiTierDisplayName();
-    log(`[GeminiCodeAssist] Auth refreshed, project: ${this.projectId}, tier: ${this._displayName}`);
+    this.servedModels = await getServedCodeAssistModels(this.accessToken, this.projectId);
+    log(`[GeminiCodeAssist] Auth refreshed, project: ${this.projectId}, tier: ${this._displayName}, served: ${this.servedModels.join(",") || "(none)"}`);
   }
   transformPayload(payload) {
     const envelope = this.cachedAuth?.transformPayload ? this.cachedAuth.transformPayload(payload) : this.buildEnvelope(payload, this.modelName);
@@ -43983,7 +44742,7 @@ class GeminiCodeAssistProviderTransport {
     const envelope = {
       model,
       project: this.projectId,
-      user_prompt_id: randomUUID3(),
+      user_prompt_id: randomUUID5(),
       request: innerPayload
     };
     if (this.tierId && this.tierId !== "free-tier") {
@@ -43994,13 +44753,16 @@ class GeminiCodeAssistProviderTransport {
   async enqueueRequest(fetchFn) {
     const queue = GeminiRequestQueue.getInstance();
     let lastResponse = null;
-    for (let attempt = 1;attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
+    for (let attempt = 1;attempt <= MAX_RETRY_ATTEMPTS2; attempt++) {
       const response = attempt === 1 ? await queue.enqueue(fetchFn) : await queue.enqueue(fetchFn);
       if (response.status !== 429) {
+        if (response.status === 404) {
+          return this.rewriteModelNotFound(response);
+        }
         return response;
       }
       const bodyText = await response.clone().text();
-      const classification = classify429(bodyText);
+      const classification = classify4292(bodyText);
       lastResponse = response;
       if (!classification) {
         log("[GeminiCodeAssist] 429 response could not be classified, returning to caller");
@@ -44014,20 +44776,21 @@ class GeminiCodeAssistProviderTransport {
         logStderr(`[GeminiCodeAssist] Quota exhausted (${classification.reason || "daily limit"}). Check plan limits.`);
         return response;
       }
-      if (attempt < MAX_RETRY_ATTEMPTS) {
-        const delay = classification.retryDelayMs ?? DEFAULT_RATE_LIMIT_DELAY_MS;
-        logStderr(`[GeminiCodeAssist] Rate limited (${classification.reason || "unknown"}), retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt}/${MAX_RETRY_ATTEMPTS})`);
+      if (attempt < MAX_RETRY_ATTEMPTS2) {
+        const delay = classification.retryDelayMs ?? DEFAULT_RATE_LIMIT_DELAY_MS2;
+        logStderr(`[GeminiCodeAssist] Rate limited (${classification.reason || "unknown"}), retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt}/${MAX_RETRY_ATTEMPTS2})`);
         if (attempt === 1) {
           await this.logQuotaInfo();
         }
         await new Promise((r) => setTimeout(r, delay));
       }
     }
-    logStderr(`[GeminiCodeAssist] Rate limit persisted after ${MAX_RETRY_ATTEMPTS} retries`);
+    logStderr(`[GeminiCodeAssist] Rate limit persisted after ${MAX_RETRY_ATTEMPTS2} retries`);
     return lastResponse;
   }
   async handleCapacityExhausted(originalResponse, queue) {
-    if (this.fallbackStartIndex >= CODE_ASSIST_FALLBACK_CHAIN.length - 1) {
+    const candidates = this.servedModels.filter((m) => m !== this.modelName);
+    if (candidates.length === 0) {
       log(`[GeminiCodeAssist] ${this.modelName} capacity exhausted, no fallback models available`);
       return originalResponse;
     }
@@ -44039,11 +44802,12 @@ class GeminiCodeAssistProviderTransport {
     logStderr(`[GeminiCodeAssist] ${this.modelName} capacity exhausted, trying fallback models...`);
     let lastResponse = originalResponse;
     const innerPayload = this.lastEnvelope.request;
-    for (let i = this.fallbackStartIndex + 1;i < CODE_ASSIST_FALLBACK_CHAIN.length; i++) {
-      const fallbackModel = CODE_ASSIST_FALLBACK_CHAIN[i];
+    const endpoint = this.getEndpoint();
+    const tried = [this.modelName];
+    for (const fallbackModel of candidates) {
       log(`[GeminiCodeAssist] Trying fallback model: ${fallbackModel}`);
+      tried.push(fallbackModel);
       const fallbackEnvelope = this.buildEnvelope(innerPayload, fallbackModel);
-      const endpoint = this.getEndpoint();
       const headers = this.buildLocalHeaders();
       headers["Content-Type"] = "application/json";
       const fallbackResponse = await queue.enqueue(() => fetch(endpoint, {
@@ -44051,23 +44815,59 @@ class GeminiCodeAssistProviderTransport {
         headers,
         body: JSON.stringify(fallbackEnvelope)
       }));
-      if (fallbackResponse.status !== 429) {
+      if (fallbackResponse.status === 200) {
         this._activeModelName = fallbackModel;
         logStderr(`[GeminiCodeAssist] Using fallback model: ${fallbackModel} (${this.modelName} had no capacity)`);
         return fallbackResponse;
       }
-      const fallbackBodyText = await fallbackResponse.clone().text();
-      const classification = classify429(fallbackBodyText);
-      if (classification?.reason !== "MODEL_CAPACITY_EXHAUSTED") {
+      if (fallbackResponse.status === 404) {
+        log(`[GeminiCodeAssist] ${fallbackModel} returned 404, skipping to next fallback`);
+        lastResponse = fallbackResponse;
+        continue;
+      }
+      if (fallbackResponse.status === 429) {
+        const fallbackBodyText = await fallbackResponse.clone().text();
+        const classification = classify4292(fallbackBodyText);
+        if (classification?.reason === "MODEL_CAPACITY_EXHAUSTED") {
+          log(`[GeminiCodeAssist] ${fallbackModel} also capacity exhausted, trying next...`);
+          lastResponse = fallbackResponse;
+          continue;
+        }
         return fallbackResponse;
       }
-      log(`[GeminiCodeAssist] ${fallbackModel} also capacity exhausted, trying next...`);
-      lastResponse = fallbackResponse;
+      return fallbackResponse;
     }
     log("[GeminiCodeAssist] All fallback models exhausted");
-    logStderr(`[GeminiCodeAssist] All models capacity exhausted (tried: ${CODE_ASSIST_FALLBACK_CHAIN.slice(this.fallbackStartIndex).join(" -> ")})`);
+    logStderr(`[GeminiCodeAssist] All models capacity exhausted (tried: ${tried.join(" -> ")})`);
+    if (lastResponse.status === 404) {
+      return this.rewriteModelNotFound(lastResponse, true);
+    }
     return lastResponse;
   }
+  rewriteModelNotFound(response, capacityFallbacksExhausted = false) {
+    const served = this.servedModels.length > 0 ? this.servedModels : CODE_ASSIST_FALLBACK_CHAIN.slice();
+    if (!capacityFallbacksExhausted && served.includes(this.modelName)) {
+      log(`[GeminiCodeAssist] 404 for ${this.modelName}, which IS in the served set \u2014 passing through unmodified`);
+      return response;
+    }
+    response.text().catch(() => {});
+    const list = served.join(", ");
+    const tier = this._displayName || "Gemini Code Assist";
+    const reason = capacityFallbacksExhausted ? `${this.modelName} could not be served after every Gemini Code Assist capacity fallback failed (${tier}, via go@). ` + `That tier currently reports: ${list}. ` : `${this.modelName} is not served by your Gemini Code Assist tier (${tier}, via go@). ` + `That tier currently serves: ${list}. `;
+    const message = reason + `To use ${this.modelName}, go through the direct Gemini API instead \u2014 ` + `set GEMINI_API_KEY (get one at https://aistudio.google.com/app/apikey) and run ` + `google@${this.modelName}.`;
+    const body = JSON.stringify({
+      error: { code: 404, status: "NOT_FOUND", message }
+    });
+    if (capacityFallbacksExhausted) {
+      logStderr(`[GeminiCodeAssist] ${this.modelName} capacity fallbacks exhausted (404). Reported models: ${list}`);
+    } else {
+      logStderr(`[GeminiCodeAssist] ${this.modelName} not served by ${tier} (404). Serves: ${list}`);
+    }
+    return new Response(body, {
+      status: 404,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
   async logQuotaInfo() {
     if (!this.accessToken || !this.projectId)
       return;
@@ -44107,13 +44907,13 @@ ${lines.join(`
     }
   }
 }
-var CODE_ASSIST_BASE = "https://cloudcode-pa.googleapis.com", CODE_ASSIST_ENDPOINT, MAX_RETRY_ATTEMPTS = 3, DEFAULT_RATE_LIMIT_DELAY_MS = 1e4;
+var CODE_ASSIST_BASE2 = "https://cloudcode-pa.googleapis.com", CODE_ASSIST_ENDPOINT2, MAX_RETRY_ATTEMPTS2 = 3, DEFAULT_RATE_LIMIT_DELAY_MS2 = 1e4;
 var init_gemini_codeassist = __esm(() => {
   init_authority();
   init_gemini_oauth();
   init_gemini_queue();
   init_logger();
-  CODE_ASSIST_ENDPOINT = `${CODE_ASSIST_BASE}/v1internal:streamGenerateContent?alt=sse`;
+  CODE_ASSIST_ENDPOINT2 = `${CODE_ASSIST_BASE2}/v1internal:streamGenerateContent?alt=sse`;
 });
 
 // src/providers/transport/ollamacloud.ts
@@ -44275,7 +45075,7 @@ function createHandlerForProvider(ctx) {
   log(`[Proxy] Handler: provider=${ctx.provider.name}, model=${ctx.modelName}`);
   return profile.createHandler(ctx);
 }
-var geminiProfile, geminiCodeAssistProfile, openaiProfile, openaiCodexProfile, anthropicCompatProfile, glmProfile, openCodeZenProfile, ollamaCloudProfile, litellmProfile, vertexProfile, PROVIDER_PROFILES;
+var geminiProfile, geminiCodeAssistProfile, antigravityProfile, openaiProfile, openaiCodexProfile, anthropicCompatProfile, glmProfile, openCodeZenProfile, ollamaCloudProfile, litellmProfile, vertexProfile, PROVIDER_PROFILES;
 var init_provider_profiles = __esm(() => {
   init_anthropic_api_format();
   init_base_api_format();
@@ -44291,6 +45091,7 @@ var init_provider_profiles = __esm(() => {
   init_remote_provider_registry();
   init_runtime_providers();
   init_anthropic_compat();
+  init_antigravity();
   init_gemini_apikey();
   init_gemini_codeassist();
   init_litellm();
@@ -44323,6 +45124,19 @@ var init_provider_profiles = __esm(() => {
       return handler;
     }
   };
+  antigravityProfile = {
+    createHandler(ctx) {
+      const transport = new AntigravityProviderTransport(ctx.modelName);
+      const adapter = new GeminiAPIFormat(ctx.modelName);
+      const handler = new ComposedHandler(transport, ctx.targetModel, ctx.modelName, ctx.port, {
+        adapter,
+        unwrapGeminiResponse: true,
+        ...ctx.sharedOpts
+      });
+      log(`[Proxy] Created Antigravity handler (composed): ${ctx.modelName}`);
+      return handler;
+    }
+  };
   openaiProfile = {
     createHandler(ctx) {
       if (requiresResponsesApi(ctx.modelName)) {
@@ -44501,6 +45315,7 @@ var init_provider_profiles = __esm(() => {
   PROVIDER_PROFILES = {
     gemini: geminiProfile,
     "gemini-codeassist": geminiCodeAssistProfile,
+    antigravity: antigravityProfile,
     openai: openaiProfile,
     "openai-codex": openaiCodexProfile,
     "x-ai": openaiProfile,
@@ -45238,9 +46053,9 @@ var init_poe = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { existsSync as existsSync16, readFileSync as readFileSync15, statSync as statSync4 } from "fs";
-import { homedir as homedir23 } from "os";
-import { join as join23 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync15, statSync as statSync4 } from "fs";
+import { homedir as homedir24 } from "os";
+import { join as join24 } from "path";
 function prefixMatch(modelName) {
   for (const [key, pricing] of pricingMap) {
     if (modelName.startsWith(key))
@@ -45278,7 +46093,7 @@ async function warmPricingCache() {
 }
 function loadDiskCache() {
   try {
-    if (!existsSync16(CACHE_FILE))
+    if (!existsSync17(CACHE_FILE))
       return false;
     const stat2 = statSync4(CACHE_FILE);
     const age = Date.now() - stat2.mtimeMs;
@@ -45299,8 +46114,8 @@ var init_pricing_cache = __esm(() => {
   init_logger();
   init_catalog_query();
   pricingMap = new Map;
-  CACHE_DIR = join23(homedir23(), ".claudish");
-  CACHE_FILE = join23(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join24(homedir24(), ".claudish");
+  CACHE_FILE = join24(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS2 = 24 * 60 * 60 * 1000;
 });
 
@@ -45757,17 +46572,17 @@ var init_proxy_server = __esm(() => {
 });
 
 // src/team-stats.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "fs";
+import { join as join25 } from "path";
 function statsDir(sessionPath) {
-  return join24(sessionPath, "stats");
+  return join25(sessionPath, "stats");
 }
 function tokenFileFor(sessionPath, anonId) {
-  return join24(statsDir(sessionPath), `${anonId}.json`);
+  return join25(statsDir(sessionPath), `${anonId}.json`);
 }
 function readTokenStats(sessionPath, anonId) {
   const path = tokenFileFor(sessionPath, anonId);
-  if (!existsSync17(path))
+  if (!existsSync18(path))
     return null;
   try {
     return JSON.parse(readFileSync16(path, "utf-8"));
@@ -45918,7 +46733,7 @@ ${segs.join(" \xB7 ")}`;
 }
 function writeStatusFile(sessionPath, manifest, status, opts) {
   try {
-    writeFileSync11(join24(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
+    writeFileSync11(join25(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
 `, "utf-8");
   } catch {}
 }
@@ -45944,13 +46759,13 @@ __export(exports_team_orchestrator, {
 import { spawn as spawn2 } from "child_process";
 import {
   createWriteStream as createWriteStream2,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync11,
   readFileSync as readFileSync17,
   readdirSync as readdirSync3,
   writeFileSync as writeFileSync12
 } from "fs";
-import { join as join25, resolve as resolve3 } from "path";
+import { join as join26, resolve as resolve3 } from "path";
 function classifyRunOutput(opts) {
   const { outputSize, stdoutTail, stderr, minOutputBytes } = opts;
   const apiError = API_ERROR_RE.exec(stdoutTail);
@@ -46011,18 +46826,18 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync18(join25(sessionPath, "manifest.json"))) {
+  if (existsSync19(join26(sessionPath, "manifest.json"))) {
     throw new Error(`Session already exists at ${sessionPath}. Use a new directory path or delete the existing session first.`);
   }
   const sentinels = models.filter(isSentinelModel);
   if (sentinels.length > 0) {
     throw new Error(`Invalid model(s) for team run: ${sentinels.join(", ")}. These are Claude Code agent selectors, not external model IDs. Use real external models (e.g., "gemini-2.0-flash", "gpt-4o", "or@deepseek/deepseek-r1"). For Claude models, use a Task agent instead of the team tool.`);
   }
-  mkdirSync11(join25(sessionPath, "work"), { recursive: true });
-  mkdirSync11(join25(sessionPath, "errors"), { recursive: true });
+  mkdirSync11(join26(sessionPath, "work"), { recursive: true });
+  mkdirSync11(join26(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync12(join25(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync18(join25(sessionPath, "input.md"))) {
+    writeFileSync12(join26(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync19(join26(sessionPath, "input.md"))) {
     throw new Error(`No input.md found at ${sessionPath} and no input provided`);
   }
   const ids = models.map((_, i) => String(i + 1).padStart(2, "0"));
@@ -46039,9 +46854,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync11(join25(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync11(join26(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync12(join25(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync12(join26(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -46055,14 +46870,14 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync12(join25(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync12(join26(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
 async function runModels(sessionPath, opts = {}) {
   const timeoutMs = (opts.timeout ?? 300) * 1000;
-  const manifest = JSON.parse(readFileSync17(join25(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join25(sessionPath, "status.json");
-  const inputPath = join25(sessionPath, "input.md");
+  const manifest = JSON.parse(readFileSync17(join26(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join26(sessionPath, "status.json");
+  const inputPath = join26(sessionPath, "input.md");
   const inputContent = readFileSync17(inputPath, "utf-8");
   await prehydrateCredentialsForSpawn(Object.values(manifest.models).map((m) => m.model));
   const statusCache = JSON.parse(readFileSync17(statusPath, "utf-8"));
@@ -46084,8 +46899,8 @@ async function runModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join25(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join25(sessionPath, "errors", `${anonId}.log`);
+    const outputPath = join26(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join26(sessionPath, "errors", `${anonId}.log`);
     const args = ["--model", entry.model, "-y", "--stdin", "--quiet", ...opts.claudeFlags ?? []];
     updateModelStatus(anonId, {
       state: "RUNNING",
@@ -46274,23 +47089,23 @@ async function judgeResponses(sessionPath, opts = {}) {
   const responses = {};
   for (const file2 of responseFiles) {
     const id = file2.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync17(join25(sessionPath, file2), "utf-8");
+    responses[id] = readFileSync17(join26(sessionPath, file2), "utf-8");
   }
-  const input = readFileSync17(join25(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync17(join26(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync12(join25(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync12(join26(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join25(sessionPath, "judging");
+  const judgePath = join26(sessionPath, "judging");
   mkdirSync11(judgePath, { recursive: true });
   setupSession(judgePath, judgeModels, judgePrompt);
   await runModels(judgePath, { claudeFlags: opts.claudeFlags });
   const votes = parseJudgeVotes(judgePath, Object.keys(responses));
   const verdict = aggregateVerdict(votes, Object.keys(responses));
-  writeFileSync12(join25(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync12(join26(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync17(join25(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync17(join26(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -46300,7 +47115,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync17(join25(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync17(join26(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -46363,7 +47178,7 @@ function parseJudgeVotes(judgePath, responseIds) {
     const judgeId = file2.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync17(join25(judgePath, file2), "utf-8");
+      content = readFileSync17(join26(judgePath, file2), "utf-8");
     } catch {
       continue;
     }
@@ -46415,7 +47230,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync17(join25(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync17(join26(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -46470,12 +47285,12 @@ __export(exports_mcp_server, {
   parseAnthropicSse: () => parseAnthropicSse,
   formatTeamResult: () => formatTeamResult
 });
-import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync18, readdirSync as readdirSync4, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir24 } from "os";
-import { dirname as dirname8, join as join26 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync18, readdirSync as readdirSync4, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir25 } from "os";
+import { dirname as dirname8, join as join27 } from "path";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
-  if (!forceRefresh && existsSync19(ALL_MODELS_CACHE_PATH2)) {
+  if (!forceRefresh && existsSync20(ALL_MODELS_CACHE_PATH2)) {
     try {
       const cacheData = JSON.parse(readFileSync18(ALL_MODELS_CACHE_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
@@ -46495,7 +47310,7 @@ async function loadAllModels(forceRefresh = false) {
     writeFileSync13(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
-    if (existsSync19(ALL_MODELS_CACHE_PATH2)) {
+    if (existsSync20(ALL_MODELS_CACHE_PATH2)) {
       const cacheData = JSON.parse(readFileSync18(ALL_MODELS_CACHE_PATH2, "utf-8"));
       return cacheData.models || [];
     }
@@ -47071,16 +47886,16 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
         const sp = session_path;
         for (const file2 of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file2] = readFileSync18(join26(sp, file2), "utf-8");
+            sessionData[file2] = readFileSync18(join27(sp, file2), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join26(sp, "errors");
-          if (existsSync19(errorDir)) {
+          const errorDir = join27(sp, "errors");
+          if (existsSync20(errorDir)) {
             for (const f of readdirSync4(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync18(join26(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync18(join27(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -47090,7 +47905,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
           for (const f of readdirSync4(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync18(join26(sp, f), "utf-8");
+                const content = readFileSync18(join27(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -47099,8 +47914,8 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       }
       let version2 = "unknown";
       try {
-        const pkgPath = join26(__dirname2, "../package.json");
-        if (existsSync19(pkgPath)) {
+        const pkgPath = join27(__dirname2, "../package.json");
+        if (existsSync20(pkgPath)) {
           version2 = JSON.parse(readFileSync18(pkgPath, "utf-8")).version;
         }
       } catch {}
@@ -47499,8 +48314,8 @@ var init_mcp_server = __esm(() => {
   import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
   __dirname2 = dirname8(__filename2);
-  CLAUDISH_CACHE_DIR = join26(homedir24(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join26(CLAUDISH_CACHE_DIR, "all-models.json");
+  CLAUDISH_CACHE_DIR = join27(homedir25(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join27(CLAUDISH_CACHE_DIR, "all-models.json");
   NEXT_STEP = {
     nonzero_exit: "read the evidence log, then retry or drop the model",
     timeout: "raise `timeout`, or pick a faster model",
@@ -47525,7 +48340,7 @@ var exports_serve_command = {};
 __export(exports_serve_command, {
   serveCommand: () => serveCommand
 });
-import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
 function parseServeArgs(args) {
   const out = {};
   for (let i = 0;i < args.length; i++) {
@@ -47544,7 +48359,7 @@ function parseServeArgs(args) {
   return out;
 }
 function loadModelMap(path) {
-  if (!existsSync20(path)) {
+  if (!existsSync21(path)) {
     throw new Error(`--models file not found: ${path}`);
   }
   let raw2;
@@ -47748,6 +48563,8 @@ function describeSourceSync(p, config3) {
     return isLocalProviderEnabled(p.catalogName, config3) ? "local" : null;
   if (p.oauthSlug && hasOAuthCredentials(p.catalogName))
     return "oauth";
+  if (p.catalogName === "antigravity" && hasSharedAntigravityToken())
+    return "oauth";
   const hasCfg = !!p.apiKeyEnvVar && !!realValue(config3.apiKeys?.[p.apiKeyEnvVar]);
   const hasEnv = !!p.apiKeyEnvVar && !!realValue(process.env[p.apiKeyEnvVar]);
   if (hasEnv && hasCfg)
@@ -47768,6 +48585,7 @@ async function describeSource(p, config3) {
 }
 var init_source = __esm(() => {
   init_profile_config();
+  init_antigravity_token();
   init_oauth_registry();
   init_api_key_credential();
   init_authority();
@@ -47815,7 +48633,7 @@ function providerAuthCapabilities(p, config3) {
   const apiKeySupported = !!p.apiKeyEnvVar;
   const apiKeySet = apiKeySupported && (!!process.env[p.apiKeyEnvVar] || !!config3.apiKeys?.[p.apiKeyEnvVar]);
   const oauthSupported = !!p.oauthSlug;
-  const oauthSet = oauthSupported && hasOAuthCredentials(p.catalogName);
+  const oauthSet = oauthSupported && (hasOAuthCredentials(p.catalogName) || p.catalogName === "antigravity" && hasSharedAntigravityToken());
   return {
     apiKey: { supported: apiKeySupported, set: apiKeySet },
     oauth: { supported: oauthSupported, set: oauthSet }
@@ -47831,6 +48649,7 @@ function maskKey2(key) {
 var SKIP, PROVIDERS;
 var init_providers = __esm(() => {
   init_source();
+  init_antigravity_token();
   init_oauth_registry();
   init_provider_definitions();
   SKIP = new Set(["qwen", "native-anthropic"]);
@@ -59145,7 +59964,7 @@ import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
 import { readFileSync as readFileSync20, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
 import path from "path";
 import os from "os";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function editAsync(text = "", callback, fileOptions) {
   const editor = new ExternalEditor(text, fileOptions);
   editor.runAsync((err, result) => {
@@ -59237,7 +60056,7 @@ class ExternalEditor {
   createTemporaryFile() {
     try {
       const baseDir = this.fileOptions.dir ?? os.tmpdir();
-      const id = randomUUID4();
+      const id = randomUUID6();
       const prefix = sanitizeAffix(this.fileOptions.prefix);
       const postfix = sanitizeAffix(this.fileOptions.postfix);
       const filename = `${prefix}${id}${postfix}`;
@@ -60413,13 +61232,14 @@ async function geminiQuotaHandler() {
       }
       console.log("");
     }
+    const fallbackChain = quota.buckets.map((b) => b.modelId).filter((m) => typeof m === "string" && m.length > 0).sort((a, b) => rankCodeAssistModel(a) - rankCodeAssistModel(b));
     console.log(`  ${B}${CYN}Fallback Chain${R} ${D}(on capacity exhaustion)${R}`);
-    for (let i = 0;i < CODE_ASSIST_FALLBACK_CHAIN.length; i++) {
-      const model = CODE_ASSIST_FALLBACK_CHAIN[i];
+    for (let i = 0;i < fallbackChain.length; i++) {
+      const model = fallbackChain[i];
       const rem = remainingByModel.get(model);
       const pct = rem !== undefined ? `${((1 - rem) * 100).toFixed(0)}%` : "?";
       const color = rem === undefined ? GRY : rem > 0.5 ? GRN : rem > 0.2 ? YEL : RED;
-      const arrow = i < CODE_ASSIST_FALLBACK_CHAIN.length - 1 ? ` ${GRY}\u2192${R}` : "";
+      const arrow = i < fallbackChain.length - 1 ? ` ${GRY}\u2192${R}` : "";
       const marker = i === 0 ? `${CYN}\u25B8${R} ` : "  ";
       console.log(`  ${marker}${WHT}${model}${R} ${color}${pct}${R}${arrow}`);
     }
@@ -60453,11 +61273,11 @@ async function geminiQuotaHandler() {
   }
 }
 async function codexQuotaHandler() {
-  const { readFileSync: readFileSync21, existsSync: existsSync21 } = await import("fs");
-  const { join: join27 } = await import("path");
-  const { homedir: homedir25 } = await import("os");
-  const credPath = join27(homedir25(), ".claudish", "codex-oauth.json");
-  if (!existsSync21(credPath)) {
+  const { readFileSync: readFileSync21, existsSync: existsSync22 } = await import("fs");
+  const { join: join28 } = await import("path");
+  const { homedir: homedir26 } = await import("os");
+  const credPath = join28(homedir26(), ".claudish", "codex-oauth.json");
+  if (!existsSync22(credPath)) {
     console.error(`${RED}No Codex credentials found.${R} Run: ${B}claudish login codex${R}`);
     process.exit(1);
   }
@@ -60513,8 +61333,8 @@ async function codexQuotaHandler() {
   }
   let modelSlugs = [];
   try {
-    const modelsPath = join27(homedir25(), ".codex", "models_cache.json");
-    if (existsSync21(modelsPath)) {
+    const modelsPath = join28(homedir26(), ".codex", "models_cache.json");
+    if (existsSync22(modelsPath)) {
       const cache2 = JSON.parse(readFileSync21(modelsPath, "utf-8"));
       modelSlugs = (cache2.models || []).map((m) => m.slug || m.id).filter(Boolean);
     }
@@ -64485,22 +65305,22 @@ __export(exports_cli, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync13,
   readFileSync as readFileSync21,
   readdirSync as readdirSync5,
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync15
 } from "fs";
-import { homedir as homedir25 } from "os";
-import { dirname as dirname9, join as join27 } from "path";
+import { homedir as homedir26 } from "os";
+import { dirname as dirname9, join as join28 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join27(homedir25(), ".claudish");
-  if (!existsSync21(cacheDir))
+  const cacheDir = join28(homedir26(), ".claudish");
+  if (!existsSync22(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
@@ -64508,7 +65328,7 @@ function clearAllModelCaches() {
     const files = readdirSync5(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync7(join27(cacheDir, file2));
+        unlinkSync7(join28(cacheDir, file2));
         cleared++;
       }
     }
@@ -64918,8 +65738,8 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join27(homedir25(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync21(markerFile)) {
+      const markerFile = join28(homedir26(), ".claudish", ".legacy-litellm-hint-shown");
+      if (!existsSync22(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
@@ -65986,7 +66806,7 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join27(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guidePath = join28(__dirname3, "../AI_AGENT_GUIDE.md");
     const guideContent = readFileSync21(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
@@ -66003,19 +66823,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join27(cwd, ".claude");
-  const skillsDir = join27(claudeDir, "skills");
-  const claudishSkillDir = join27(skillsDir, "claudish-usage");
-  const skillFile = join27(claudishSkillDir, "SKILL.md");
-  if (existsSync21(skillFile)) {
+  const claudeDir = join28(cwd, ".claude");
+  const skillsDir = join28(claudeDir, "skills");
+  const claudishSkillDir = join28(skillsDir, "claudish-usage");
+  const skillFile = join28(claudishSkillDir, "SKILL.md");
+  if (existsSync22(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join27(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync21(sourceSkillPath)) {
+  const sourceSkillPath = join28(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync22(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -66024,15 +66844,15 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync21(claudeDir)) {
+    if (!existsSync22(claudeDir)) {
       mkdirSync13(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync21(skillsDir)) {
+    if (!existsSync22(skillsDir)) {
       mkdirSync13(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync21(claudishSkillDir)) {
+    if (!existsSync22(claudishSkillDir)) {
       mkdirSync13(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
@@ -66117,30 +66937,30 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync22, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "fs";
-import { homedir as homedir26, platform as platform2, tmpdir } from "os";
-import { join as join28 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync14, readFileSync as readFileSync22, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "fs";
+import { homedir as homedir27, platform as platform2, tmpdir } from "os";
+import { join as join29 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join28(homedir26(), "AppData", "Local");
-    cacheDir = join28(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join29(homedir27(), "AppData", "Local");
+    cacheDir = join29(localAppData, "claudish");
   } else {
-    cacheDir = join28(homedir26(), ".cache", "claudish");
+    cacheDir = join29(homedir27(), ".cache", "claudish");
   }
   try {
-    if (!existsSync22(cacheDir)) {
+    if (!existsSync23(cacheDir)) {
       mkdirSync14(cacheDir, { recursive: true });
     }
-    return join28(cacheDir, "update-check.json");
+    return join29(cacheDir, "update-check.json");
   } catch {
-    return join28(tmpdir(), "claudish-update-check.json");
+    return join29(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync22(cachePath)) {
+    if (!existsSync23(cachePath)) {
       return null;
     }
     const data = JSON.parse(readFileSync22(cachePath, "utf-8"));
@@ -66166,7 +66986,7 @@ function isCacheValid(cache2) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync22(cachePath)) {
+    if (existsSync23(cachePath)) {
       unlinkSync8(cachePath);
     }
   } catch {}
@@ -67051,11 +67871,11 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "fs";
-import { homedir as homedir27 } from "os";
-import { dirname as dirname10, join as join29 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync15, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "fs";
+import { homedir as homedir28 } from "os";
+import { dirname as dirname10, join as join30 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
-  if (!existsSync23(path2))
+  if (!existsSync24(path2))
     return null;
   let raw2;
   try {
@@ -67188,7 +68008,7 @@ function isValidResponse(raw2) {
 var PROBE_MODELS_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/probeModels", CACHE_TTL_MS4, FETCH_TIMEOUT_MS3 = 15000, PROBE_MODELS_CACHE_PATH, _inFlight = null;
 var init_probe_catalog = __esm(() => {
   CACHE_TTL_MS4 = 60 * 60 * 1000;
-  PROBE_MODELS_CACHE_PATH = join29(homedir27(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join30(homedir28(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -73525,15 +74345,15 @@ __export(exports_claude_runner, {
 import { spawn as spawn4 } from "child_process";
 import {
   closeSync as closeSync5,
-  existsSync as existsSync24,
+  existsSync as existsSync25,
   mkdirSync as mkdirSync16,
   openSync as openSync5,
   readFileSync as readFileSync24,
   unlinkSync as unlinkSync9,
   writeFileSync as writeFileSync18
 } from "fs";
-import { homedir as homedir28, tmpdir as tmpdir2 } from "os";
-import { join as join30 } from "path";
+import { homedir as homedir29, tmpdir as tmpdir2 } from "os";
+import { join as join31 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -73568,7 +74388,7 @@ function isProxyAuthMode(config3) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join30(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join31(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
@@ -73589,9 +74409,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join30(homeDir, ".claudish");
+  const claudishDir = join31(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join30(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join31(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -73714,13 +74534,13 @@ process.stdin.on('end', () => {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join30(homeDir, ".claudish");
+  const claudishDir = join31(homeDir, ".claudish");
   try {
     mkdirSync16(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join30(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join30(claudishDir, `tokens-${port}.json`);
+  const tempPath = join31(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join31(claudishDir, `tokens-${port}.json`);
   let statusCommand;
   if (isWindows2()) {
     const scriptPath = createStatusLineScript(tokenFilePath);
@@ -73935,8 +74755,8 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     console.error("Install it from: https://claude.com/claude-code");
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
-    const home = homedir28();
-    const localPath = isWindows2() ? join30(home, ".claude", "local", "claude.exe") : join30(home, ".claude", "local", "claude");
+    const home = homedir29();
+    const localPath = isWindows2() ? join31(home, ".claude", "local", "claude.exe") : join31(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -74016,23 +74836,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync24(process.env.CLAUDE_PATH)) {
+    if (existsSync25(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir28();
-  const localPath = isWindows3 ? join30(home, ".claude", "local", "claude.exe") : join30(home, ".claude", "local", "claude");
-  if (existsSync24(localPath)) {
+  const home = homedir29();
+  const localPath = isWindows3 ? join31(home, ".claude", "local", "claude.exe") : join31(home, ".claude", "local", "claude");
+  if (existsSync25(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join30(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join30(home, ".npm-global", "claude.cmd"),
-      join30(home, "node_modules", ".bin", "claude.cmd")
+      join31(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join31(home, ".npm-global", "claude.cmd"),
+      join31(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
-      if (existsSync24(path2)) {
+      if (existsSync25(path2)) {
         return path2;
       }
     }
@@ -74040,14 +74860,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join30(home, ".npm-global/bin/claude"),
-      join30(home, ".local/bin/claude"),
-      join30(home, "node_modules/.bin/claude"),
+      join31(home, ".npm-global/bin/claude"),
+      join31(home, ".local/bin/claude"),
+      join31(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join30(home, "../usr/bin/claude")
+      join31(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync24(path2)) {
+      if (existsSync25(path2)) {
         return path2;
       }
     }
@@ -74105,17 +74925,17 @@ __export(exports_diag_output, {
   LogFileDiagOutput: () => LogFileDiagOutput
 });
 import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync17, unlinkSync as unlinkSync10, writeFileSync as writeFileSync19 } from "fs";
-import { homedir as homedir29 } from "os";
-import { join as join31 } from "path";
+import { homedir as homedir30 } from "os";
+import { join as join32 } from "path";
 function getClaudishDir() {
-  const dir = join31(homedir29(), ".claudish");
+  const dir = join32(homedir30(), ".claudish");
   try {
     mkdirSync17(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join31(getClaudishDir(), `diag-${process.pid}.log`);
+  return join32(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -74326,9 +75146,9 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn5 } from "child_process";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync25, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync25, writeFileSync as writeFileSync20 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname11, join as join32 } from "path";
+import { dirname as dirname11, join as join33 } from "path";
 import { setTimeout as wait } from "timers/promises";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveRouteInfo(modelId) {
@@ -74422,18 +75242,18 @@ function buildPaneHeader(model, prompt, bg) {
 function findMagmuxBinary() {
   const thisFile = fileURLToPath3(import.meta.url);
   const thisDir = dirname11(thisFile);
-  const pkgRoot = join32(thisDir, "..");
+  const pkgRoot = join33(thisDir, "..");
   const platform3 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join32(pkgRoot, "native", `magmux-${platform3}-${arch}`);
-  if (existsSync25(bundledMagmux))
+  const bundledMagmux = join33(pkgRoot, "native", `magmux-${platform3}-${arch}`);
+  if (existsSync26(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform3}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join32(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync25(candidate))
+      const candidate = join33(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync26(candidate))
         return candidate;
       const parent = dirname11(searchDir);
       if (parent === searchDir)
@@ -74452,7 +75272,7 @@ function findMagmuxBinary() {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync25(sockPath)) {
+    if (existsSync26(sockPath)) {
       try {
         client = await new Promise((resolve4, reject) => {
           const s = netConnect(sockPath);
@@ -74539,9 +75359,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join32(sessionPath, "gridfile.txt");
-  const prompt = readFileSync25(join32(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync25(join32(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join33(sessionPath, "gridfile.txt");
+  const prompt = readFileSync25(join33(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync25(join33(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -74572,7 +75392,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join32(sessionPath, "status.json");
+  const statusPath = join33(sessionPath, "status.json");
   writeFileSync20(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
@@ -74596,8 +75416,8 @@ var init_team_grid = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync26, readFileSync as readFileSync26 } from "fs";
-import { join as join33, resolve as resolve4 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync26 } from "fs";
+import { join as join34, resolve as resolve4 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -74696,7 +75516,7 @@ async function applyConfigOverride() {
   const { planConfigOverride: planConfigOverride2, setConfigFileOverride: setConfigFileOverride2 } = await Promise.resolve().then(() => exports_config_override);
   const plan = planConfigOverride2(process.argv.slice(2), process.env, {
     resolve: resolve4,
-    exists: existsSync26
+    exists: existsSync27
   });
   if (plan.kind === "none")
     return;
@@ -74845,7 +75665,7 @@ async function runCli() {
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join33(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join34(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         const { setupSession: setupSession2, runModels: runModels2 } = await Promise.resolve().then(() => (init_team_orchestrator(), exports_team_orchestrator));
         setupSession2(sessionPath, cliConfig.team, prompt);
@@ -74855,7 +75675,7 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join33(sessionPath, `response-${anonId}.md`);
+          const responsePath = join34(sessionPath, `response-${anonId}.md`);
           try {
             const raw2 = readFileSync26(responsePath, "utf-8").trim();
             try {