claudish 7.52.0 → 7.54.0

package/dist/index.js

@@ -729,7 +729,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.52.0";
+var VERSION = "7.54.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -28161,6 +28161,26 @@ var init_provider_definitions = __esm(() => {
       nativeModelPatterns: [{ pattern: /^x-ai\//i }, { pattern: /^grok-/i }],
       isDirectApi: true
     },
+    {
+      name: "grok-subscription",
+      displayName: "Grok Build (subscription)",
+      transport: "grok-subscription",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://cli-chat-proxy.grok.com",
+      baseUrlEnvVars: ["GROK_PROXY_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Grok subscription OAuth (`claudish login grok`, or an existing `grok login`)",
+      apiKeyUrl: "https://x.ai/cli",
+      oauthLoginSlug: "grok",
+      oauthFallback: "grok-oauth.json",
+      shortcuts: ["gk", "grok-subscription"],
+      shortestPrefix: "gk",
+      legacyPrefixes: [{ prefix: "gk/", stripPrefix: true }],
+      modelDiscovery: { path: "/v1/models", format: "openai-models-list" },
+      isDirectApi: true,
+      description: "Grok on your SuperGrok or X Premium+ plan (gk@)"
+    },
     {
       name: "minimax",
       displayName: "MiniMax",
@@ -28934,7 +28954,8 @@ var init_remote_provider_types = __esm(() => {
     "qwen-cloud",
     "devin",
     "antigravity",
-    "sakana-subscription"
+    "sakana-subscription",
+    "grok-subscription"
   ]);
   PROVIDER_ALIAS = {
     google: "gemini",
@@ -30167,6 +30188,9 @@ function parseRecord(raw) {
     return null;
   }
 }
+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;
@@ -30184,6 +30208,15 @@ function hasSharedAntigravityToken(deps = defaultDeps) {
   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 deleteSharedAntigravityToken(deps = defaultDeps) {
   (deps.deleteStore ?? defaultDeleteStore)();
   _resetAntigravityTokenState();
@@ -30222,6 +30255,31 @@ function getValidAntigravityAccessToken(deps = defaultDeps) {
   });
   return inFlight;
 }
+async function forceRefreshAntigravityToken(deps = defaultDeps) {
+  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.");
+  }
+  _resetAntigravityTokenState();
+  const rec = parseRecord(deps.readStore());
+  if (!rec) {
+    throw new Error("[Antigravity] No Antigravity session found. Sign in with `claudish login antigravity`, " + "or use g@<model> with GEMINI_API_KEY " + "(get one at https://aistudio.google.com/app/apikey).");
+  }
+  const original = rec.token;
+  log("[Antigravity] Upstream rejected the current token \u2014 asking the Antigravity CLI to re-mint.");
+  writeSharedAntigravityToken({ ...original, expiry: new Date(deps.now() - 1000).toISOString() }, deps);
+  deps.runAgyRefresh();
+  const refreshed = parseRecord(deps.readStore());
+  const token = refreshed?.token;
+  if (token && token.access_token !== original.access_token && !needsRefresh(token, deps.now())) {
+    log("[Antigravity] Shared token re-minted by the Antigravity CLI.");
+    return token.access_token;
+  }
+  if (!refreshed || refreshed.token.access_token === original.access_token) {
+    writeSharedAntigravityToken(original, deps);
+  }
+  _resetAntigravityTokenState();
+  throw new Error("[Antigravity] The Antigravity session was rejected upstream and could not be re-minted. " + "Run `claudish login antigravity` to sign in again.");
+}
 function _resetAntigravityTokenState() {
   inFlight = null;
   cachedHasToken = null;
@@ -30248,6 +30306,13 @@ function makeTerminalSetupError(message) {
 function buildAntigravityUserAgent() {
   return `antigravity/cli/1.1.9 (aidev_client; os_type=${process.platform}; arch=${process.arch}; auth_method=consumer)`;
 }
+function resetAntigravityUserCache() {
+  cachedAgProjectId = null;
+  cachedAgTierId = null;
+  cachedAgTierName = null;
+  agServedCache = null;
+  agServedCacheAt = 0;
+}
 async function callLoadCodeAssistAntigravity(accessToken) {
   const res = await fetch(`${ANTIGRAVITY_API_BASE}:loadCodeAssist`, {
     method: "POST",
@@ -30632,6 +30697,22 @@ class AntigravityProviderTransport {
     this.servedModelName = resolveAntigravityModelId(this.modelName, this.servedModels, this.defaultServedModel, lookupFamilyDefaultVariant(this.modelName, "antigravity"));
     log(`[Antigravity] Auth refreshed, project: ${this.projectId}, tier: ${this._displayName}, ` + `model: ${this.modelName} -> ${this.servedModelName}, served: ${this.servedModels.join(",") || "(none)"}`);
   }
+  async forceRefreshAuth() {
+    await forceRefreshAntigravityToken();
+    resetAntigravityUserCache();
+    this.cachedAuth = null;
+    await this.refreshAuth();
+  }
+  classifyTerminalError(status, bodyText) {
+    if (status !== 429)
+      return;
+    const classification = classify429(bodyText);
+    if (!classification)
+      return;
+    if (classification.reason === "MODEL_CAPACITY_EXHAUSTED")
+      return false;
+    return classification.terminal;
+  }
   transformPayload(payload) {
     const envelope = this.cachedAuth?.transformPayload ? this.cachedAuth.transformPayload(payload) : this.buildEnvelope(payload, this.servedModelName);
     this.lastEnvelope = envelope;
@@ -30672,8 +30753,7 @@ class AntigravityProviderTransport {
         return this.handleCapacityExhausted(response, queue);
       }
       if (classification.terminal) {
-        logStderr(`[Antigravity] Quota exhausted (${classification.reason || "daily limit"}). Check plan limits.`);
-        return response;
+        return await this.explainTerminalQuota(response, bodyText, classification.reason);
       }
       if (attempt < MAX_RETRY_ATTEMPTS) {
         const delay = classification.retryDelayMs ?? DEFAULT_RATE_LIMIT_DELAY_MS;
@@ -30768,6 +30848,53 @@ class AntigravityProviderTransport {
       headers: { "Content-Type": "application/json" }
     });
   }
+  async quotaRemainingForServedModel() {
+    if (!this.accessToken || !this.projectId)
+      return;
+    let timer;
+    const data = await Promise.race([
+      retrieveUserQuota(this.accessToken, this.projectId).catch(() => null),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), QUOTA_CHECK_TIMEOUT_MS);
+      })
+    ]).finally(() => {
+      if (timer)
+        clearTimeout(timer);
+    });
+    const buckets = data?.buckets;
+    if (!buckets?.length)
+      return;
+    const bucket = buckets.find((b) => b.modelId === this.servedModelName) ?? buckets.find((b) => b.modelId === this.modelName);
+    return typeof bucket?.remainingFraction === "number" ? bucket.remainingFraction : undefined;
+  }
+  async explainTerminalQuota(response, bodyText, reason) {
+    const remaining = await this.quotaRemainingForServedModel();
+    const model = this.servedModelName;
+    let advice;
+    if (remaining !== undefined && remaining > 0) {
+      advice = `your Antigravity plan still reports ${(remaining * 100).toFixed(1)}% of the ${model} ` + "allowance available, so this is probably NOT an exhausted plan. The usual cause is an " + "Antigravity session Google invalidated server-side; run `claudish login antigravity`.";
+    } else if (remaining === undefined) {
+      advice = "claudish could not read your Antigravity quota to confirm this. If your plan is not " + "actually spent, the session may be stale \u2014 run `claudish login antigravity`.";
+    } else {
+      advice = `your Antigravity plan reports no remaining ${model} allowance; it refills on Google's own schedule.`;
+    }
+    logStderr(`[Antigravity] Terminal 429 (${reason || "daily limit"}) \u2014 ${advice}`);
+    let parsed;
+    try {
+      parsed = JSON.parse(bodyText);
+    } catch {
+      return response;
+    }
+    const target = Array.isArray(parsed) ? parsed[0]?.error : parsed?.error;
+    if (!target || typeof target !== "object")
+      return response;
+    const upstream = typeof target.message === "string" && target.message.length > 0 ? target.message : "Resource has been exhausted";
+    target.message = `${upstream} \u2014 ${advice}`;
+    return new Response(JSON.stringify(parsed), {
+      status: 429,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
   async logQuotaInfo() {
     if (!this.accessToken || !this.projectId)
       return;
@@ -30817,7 +30944,7 @@ ${lines.join(`
     }
   }
 }
-var ANTIGRAVITY_BASE = "https://cloudcode-pa.googleapis.com", ANTIGRAVITY_ENDPOINT, MAX_RETRY_ATTEMPTS = 3, DEFAULT_RATE_LIMIT_DELAY_MS = 1e4, REASONING_TIER_RANK;
+var ANTIGRAVITY_BASE = "https://cloudcode-pa.googleapis.com", ANTIGRAVITY_ENDPOINT, MAX_RETRY_ATTEMPTS = 3, DEFAULT_RATE_LIMIT_DELAY_MS = 1e4, QUOTA_CHECK_TIMEOUT_MS = 3000, REASONING_TIER_RANK;
 var init_antigravity = __esm(() => {
   init_model_catalog();
   init_antigravity_token();
@@ -31557,14 +31684,613 @@ var init_devin_credential = __esm(() => {
   init_devin_credentials();
 });
 
-// src/auth/kimi-oauth.ts
+// src/auth/oauth-manager.ts
 import { exec as exec2 } from "child_process";
-import { randomBytes as randomBytes2 } from "crypto";
-import { closeSync as closeSync3, existsSync as existsSync10, openSync as openSync3, readFileSync as readFileSync9, unlinkSync as unlinkSync3, writeSync as writeSync3 } from "fs";
-import { homedir as homedir13, hostname as hostname3, platform, release as release2 } from "os";
+import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
+import {
+  closeSync as closeSync3,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync7,
+  openSync as openSync3,
+  readFileSync as readFileSync9,
+  unlinkSync as unlinkSync3,
+  writeSync as writeSync3
+} from "fs";
+import { homedir as homedir13 } from "os";
 import { join as join13 } from "path";
 import { promisify as promisify2 } from "util";
 
+class OAuthManager {
+  credentials = null;
+  refreshPromise = null;
+  tokenRefreshMargin = 5 * 60 * 1000;
+  static ensureClaudishDir() {
+    const dir = join13(homedir13(), ".claudish");
+    if (!existsSync10(dir)) {
+      mkdirSync7(dir, { recursive: true });
+    }
+    return dir;
+  }
+  getCredentialsPath() {
+    return join13(homedir13(), ".claudish", this.credentialFile);
+  }
+  loadCredentials() {
+    const credPath = this.getCredentialsPath();
+    if (!existsSync10(credPath))
+      return null;
+    try {
+      const data = JSON.parse(readFileSync9(credPath, "utf-8"));
+      if (!this.validateCredentials(data)) {
+        log(`[${this.providerName}] Invalid credentials file structure`);
+        return null;
+      }
+      log(`[${this.providerName}] Loaded credentials from file`);
+      return data;
+    } catch (e) {
+      log(`[${this.providerName}] Failed to load credentials: ${e.message}`);
+      return null;
+    }
+  }
+  saveCredentials(credentials2) {
+    OAuthManager.ensureClaudishDir();
+    const credPath = this.getCredentialsPath();
+    const fd = openSync3(credPath, "w", 384);
+    try {
+      writeSync3(fd, JSON.stringify(credentials2, null, 2), 0, "utf-8");
+    } finally {
+      closeSync3(fd);
+    }
+    log(`[${this.providerName}] Credentials saved to ${credPath}`);
+  }
+  deleteCredentials() {
+    const credPath = this.getCredentialsPath();
+    if (existsSync10(credPath)) {
+      unlinkSync3(credPath);
+      log(`[${this.providerName}] Credentials deleted`);
+    }
+  }
+  hasCredentials() {
+    return this.credentials !== null && !!this.credentials.refresh_token;
+  }
+  async getAccessToken() {
+    if (this.refreshPromise) {
+      log(`[${this.providerName}] Waiting for in-progress refresh`);
+      return this.refreshPromise;
+    }
+    if (!this.credentials) {
+      throw new Error(`No ${this.providerName} credentials found. Please run \`${this.loginHint}\` first.`);
+    }
+    if (this.isTokenValid()) {
+      return this.credentials.access_token;
+    }
+    this.refreshPromise = this.doRefreshToken().finally(() => {
+      this.refreshPromise = null;
+    });
+    return this.refreshPromise;
+  }
+  async refreshToken() {
+    if (!this.credentials) {
+      throw new Error(`No ${this.providerName} credentials found. Please run \`${this.loginHint}\` first.`);
+    }
+    await this.doRefreshToken();
+  }
+  isTokenValid() {
+    if (!this.credentials)
+      return false;
+    return Date.now() < this.credentials.expires_at - this.tokenRefreshMargin;
+  }
+  generateCodeVerifier() {
+    return randomBytes2(64).toString("base64url");
+  }
+  generateCodeChallenge(verifier) {
+    return createHash3("sha256").update(verifier).digest("base64url");
+  }
+  async openBrowser(url2, message) {
+    try {
+      if (process.platform === "darwin") {
+        await execAsync2(`open "${url2}"`);
+      } else if (process.platform === "win32") {
+        await execAsync2(`start "${url2}"`);
+      } else {
+        await execAsync2(`xdg-open "${url2}"`);
+      }
+      if (message !== undefined) {
+        console.log(message);
+      } else {
+        console.log(`
+Opening browser for authentication...`);
+        console.log(`If the browser doesn't open, visit this URL:
+${url2}
+`);
+      }
+    } catch {
+      console.log(`
+Please open this URL in your browser to authenticate:`);
+      console.log(url2);
+      console.log("");
+    }
+  }
+  async copyToClipboard(text) {
+    const commands = process.platform === "darwin" ? ["pbcopy"] : process.platform === "win32" ? ["clip"] : ["wl-copy", "xclip -selection clipboard", "xsel --clipboard --input"];
+    for (const command of commands) {
+      try {
+        const child = (await import("child_process")).spawn(command, {
+          shell: true,
+          stdio: ["pipe", "ignore", "ignore"]
+        });
+        child.stdin.write(text);
+        child.stdin.end();
+        const ok = await new Promise((resolve) => {
+          child.on("close", (code) => resolve(code === 0));
+          child.on("error", () => resolve(false));
+        });
+        if (ok)
+          return true;
+      } catch {}
+    }
+    return false;
+  }
+  presentAuthUrl(url2) {
+    const stdin = process.stdin;
+    const interactive = Boolean(stdin.isTTY && typeof stdin.setRawMode === "function");
+    if (!interactive) {
+      console.log(`  URL:  ${url2}
+`);
+      return () => {};
+    }
+    console.log(`  URL:  ${url2}`);
+    console.log(`  (press c to copy the URL, or open it manually)
+`);
+    const onKey = (chunk) => {
+      const key = chunk.toString();
+      if (key === "\x03") {
+        cleanup();
+        process.exit(130);
+      }
+      if (key.toLowerCase() === "c") {
+        this.copyToClipboard(url2).then((ok) => {
+          console.log(ok ? "  \u2713 URL copied to clipboard" : "  \u2717 No clipboard tool available");
+        });
+      }
+    };
+    let disposed = false;
+    const cleanup = () => {
+      if (disposed)
+        return;
+      disposed = true;
+      stdin.off("data", onKey);
+      try {
+        stdin.setRawMode(false);
+      } catch {}
+      stdin.pause();
+    };
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.on("data", onKey);
+    return cleanup;
+  }
+  async logout() {
+    this.deleteCredentials();
+    this.credentials = null;
+  }
+}
+var execAsync2;
+var init_oauth_manager = __esm(() => {
+  init_logger();
+  execAsync2 = promisify2(exec2);
+});
+
+// src/auth/grok-oauth.ts
+var GROK_ISSUER = "https://auth.x.ai", DEVICE_CODE_ENDPOINT, TOKEN_ENDPOINT, REVOKE_ENDPOINT, GROK_PUBLIC_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828", GROK_SCOPES, DEVICE_CODE_GRANT = "urn:ietf:params:oauth:grant-type:device_code", DEFAULT_POLL_INTERVAL_S = 5, GrokOAuth;
+var init_grok_oauth = __esm(() => {
+  init_logger();
+  init_oauth_manager();
+  DEVICE_CODE_ENDPOINT = `${GROK_ISSUER}/oauth2/device/code`;
+  TOKEN_ENDPOINT = `${GROK_ISSUER}/oauth2/token`;
+  REVOKE_ENDPOINT = `${GROK_ISSUER}/oauth2/revoke`;
+  GROK_SCOPES = [
+    "openid",
+    "profile",
+    "email",
+    "offline_access",
+    "grok-cli:access",
+    "api:access",
+    "conversations:read",
+    "conversations:write",
+    "workspaces:read",
+    "workspaces:write"
+  ].join(" ");
+  GrokOAuth = class GrokOAuth extends OAuthManager {
+    credentialFile = "grok-oauth.json";
+    providerName = "GrokOAuth";
+    loginHint = "claudish login grok";
+    static instance = null;
+    static getInstance() {
+      if (!GrokOAuth.instance) {
+        GrokOAuth.instance = new GrokOAuth;
+      }
+      return GrokOAuth.instance;
+    }
+    constructor() {
+      super();
+      this.credentials = this.loadCredentials();
+    }
+    validateCredentials(data) {
+      if (!data || typeof data !== "object")
+        return false;
+      const d = data;
+      return typeof d.access_token === "string" && typeof d.refresh_token === "string" && typeof d.expires_at === "number";
+    }
+    async getToken() {
+      return this.getAccessToken();
+    }
+    async doRefreshToken() {
+      const current = this.credentials;
+      if (!current) {
+        throw new Error(`No Grok credentials found. Please run \`${this.loginHint}\` first.`);
+      }
+      const body = new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: current.refresh_token,
+        client_id: current.client_id || GROK_PUBLIC_CLIENT_ID
+      });
+      const response = await fetch(TOKEN_ENDPOINT, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body
+      });
+      const parsed = await response.json().catch(() => ({}));
+      if (!response.ok || !parsed.access_token) {
+        const detail = parsed.error_description ?? parsed.error ?? `HTTP ${response.status}`;
+        throw new Error(`Grok token refresh failed: ${detail}. Run \`${this.loginHint}\` to sign in.`);
+      }
+      const next = {
+        access_token: parsed.access_token,
+        refresh_token: parsed.refresh_token ?? current.refresh_token,
+        expires_at: Date.now() + (parsed.expires_in ?? 6 * 60 * 60) * 1000,
+        client_id: current.client_id || GROK_PUBLIC_CLIENT_ID,
+        scope: parsed.scope ?? current.scope
+      };
+      this.credentials = next;
+      this.saveCredentials(next);
+      return next.access_token;
+    }
+    async login(clientId = GROK_PUBLIC_CLIENT_ID) {
+      const auth = await this.requestDeviceCode(clientId);
+      const url2 = auth.verification_uri_complete ?? auth.verification_uri;
+      console.log(`
+Sign in to Grok (SuperGrok or X Premium+ subscription required).`);
+      console.log(`
+  Code: ${auth.user_code}`);
+      const disposeUrlPrompt = this.presentAuthUrl(url2);
+      await this.openBrowser(url2, "Opening your browser\u2026 (approve the request there)");
+      try {
+        const credentials2 = await this.pollForToken(auth, clientId);
+        this.credentials = credentials2;
+        this.saveCredentials(credentials2);
+      } finally {
+        disposeUrlPrompt();
+      }
+      console.log(`
+Signed in to Grok. Try it with: claudish --model gk@grok-4.6 "hello"
+`);
+    }
+    async requestDeviceCode(clientId) {
+      const response = await fetch(DEVICE_CODE_ENDPOINT, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ client_id: clientId, scope: GROK_SCOPES })
+      });
+      const parsed = await response.json().catch(() => ({}));
+      if (!response.ok || !parsed.device_code || !parsed.user_code) {
+        const detail = parsed.error_description ?? parsed.error ?? `HTTP ${response.status}`;
+        throw new Error(`Could not start Grok device authorization: ${detail}`);
+      }
+      return parsed;
+    }
+    async pollForToken(auth, clientId) {
+      let intervalMs = (auth.interval ?? DEFAULT_POLL_INTERVAL_S) * 1000;
+      const deadline = Date.now() + auth.expires_in * 1000;
+      while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        let parsed;
+        try {
+          const response = await fetch(TOKEN_ENDPOINT, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+              grant_type: DEVICE_CODE_GRANT,
+              device_code: auth.device_code,
+              client_id: clientId
+            })
+          });
+          parsed = await response.json().catch(() => ({}));
+        } catch (error46) {
+          log(`[${this.providerName}] Poll failed, retrying: ${error46.message}`);
+          continue;
+        }
+        if (parsed.access_token) {
+          return {
+            access_token: parsed.access_token,
+            refresh_token: parsed.refresh_token ?? "",
+            expires_at: Date.now() + (parsed.expires_in ?? 6 * 60 * 60) * 1000,
+            client_id: clientId,
+            scope: parsed.scope
+          };
+        }
+        if (parsed.error === "authorization_pending")
+          continue;
+        if (parsed.error === "slow_down") {
+          intervalMs += 5000;
+          continue;
+        }
+        throw new Error(`Grok sign-in failed: ${parsed.error_description ?? parsed.error ?? "unknown error"}`);
+      }
+      throw new Error("Grok sign-in timed out \u2014 the device code expired. Please try again.");
+    }
+    async logout() {
+      const current = this.credentials;
+      if (current?.refresh_token) {
+        try {
+          await fetch(REVOKE_ENDPOINT, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+              token: current.refresh_token,
+              token_type_hint: "refresh_token",
+              client_id: current.client_id || GROK_PUBLIC_CLIENT_ID
+            })
+          });
+        } catch (error46) {
+          log(`[${this.providerName}] Revocation failed (deleting locally anyway): ${error46}`);
+        }
+      }
+      await super.logout();
+    }
+  };
+});
+
+// src/providers/grok/grok-credentials.ts
+import { existsSync as existsSync11, readFileSync as readFileSync10, renameSync, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join14 } from "path";
+function grokHome() {
+  return grokHomeOverride ?? join14(homedir14(), ".grok");
+}
+function grokAuthPath() {
+  return join14(grokHome(), "auth.json");
+}
+function str(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readGrokCredential() {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync10(grokAuthPath(), "utf8"));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return;
+  const entries = Object.entries(parsed).filter(([, v]) => v && typeof v === "object" && str(v.key));
+  if (entries.length === 0)
+    return;
+  const chosen = entries.find(([, v]) => str(v.auth_mode)?.toLowerCase() === "oidc") ?? entries.find(([scope2]) => scope2 === LEGACY_SCOPE) ?? entries[0];
+  const [scope, raw] = chosen;
+  const key = str(raw.key);
+  if (!key)
+    return;
+  return {
+    scope,
+    key,
+    refreshToken: str(raw.refresh_token),
+    expiresAt: str(raw.expires_at),
+    clientId: str(raw.oidc_client_id),
+    issuer: str(raw.oidc_issuer),
+    authMode: str(raw.auth_mode)
+  };
+}
+function claudishGrokOAuthPath() {
+  return claudishOAuthPathOverride ?? join14(homedir14(), ".claudish", "grok-oauth.json");
+}
+function hasClaudishGrokOAuth() {
+  return existsSync11(claudishGrokOAuthPath());
+}
+function hasGrokCredentials() {
+  return hasClaudishGrokOAuth() || readGrokCredential() !== undefined;
+}
+function isGrokCredentialExpired(cred, now = Date.now()) {
+  if (!cred.expiresAt)
+    return false;
+  const expiry = Date.parse(cred.expiresAt);
+  if (Number.isNaN(expiry))
+    return false;
+  return expiry - EXPIRY_SKEW_MS2 <= now;
+}
+function readGrokClientVersion() {
+  return readLocalGrokVersion() ?? FALLBACK_GROK_CLIENT_VERSION;
+}
+function readLocalGrokVersion() {
+  for (const [file2, field] of [
+    ["version.json", "version"],
+    ["models_cache.json", "grok_version"]
+  ]) {
+    try {
+      const parsed = JSON.parse(readFileSync10(join14(grokHome(), file2), "utf8"));
+      const version2 = str(parsed[field]);
+      if (version2)
+        return version2;
+    } catch {}
+  }
+  return;
+}
+async function resolveGrokClientVersion() {
+  const local = readLocalGrokVersion();
+  if (local)
+    return local;
+  if (liveClientVersion)
+    return liveClientVersion;
+  try {
+    const response = await fetch(GROK_CHANNEL_URL, { signal: AbortSignal.timeout(5000) });
+    if (response.ok) {
+      const version2 = (await response.text()).trim().split(/\s+/)[0];
+      if (/^\d+\.\d+\.\d+(-[A-Za-z0-9._]+)?$/.test(version2)) {
+        liveClientVersion = version2;
+        return version2;
+      }
+    }
+  } catch {}
+  return FALLBACK_GROK_CLIENT_VERSION;
+}
+function grokAuthHeaders(token, version2 = readGrokClientVersion()) {
+  return {
+    Authorization: `Bearer ${token}`,
+    "x-grok-client-version": version2,
+    "x-grok-client-identifier": GROK_CLIENT_IDENTIFIER
+  };
+}
+function terminal(message) {
+  const err = new Error(message);
+  err.terminal = true;
+  return err;
+}
+function persistRefreshedToken(scope, next) {
+  const path = grokAuthPath();
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync10(path, "utf8"));
+  } catch {
+    return;
+  }
+  const entry = parsed[scope];
+  if (!entry || typeof entry !== "object")
+    return;
+  entry.key = next.key;
+  if (next.refreshToken)
+    entry.refresh_token = next.refreshToken;
+  if (next.expiresAt)
+    entry.expires_at = next.expiresAt;
+  const tmp = `${path}.claudish.tmp`;
+  writeFileSync7(tmp, `${JSON.stringify(parsed, null, 2)}
+`, { mode: 384 });
+  renameSync(tmp, path);
+}
+async function performRefresh(cred) {
+  if (!cred.refreshToken || !cred.clientId) {
+    throw terminal(`Grok credential is expired and cannot be refreshed. ${SIGN_IN_HINT}`);
+  }
+  const tokenEndpoint = `${(cred.issuer ?? "https://auth.x.ai").replace(/\/+$/, "")}/oauth2/token`;
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: cred.refreshToken,
+    client_id: cred.clientId
+  });
+  let response;
+  try {
+    response = await fetch(tokenEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body
+    });
+  } catch (error46) {
+    throw new Error(`Could not reach ${tokenEndpoint} to refresh the Grok token: ${error46.message}`);
+  }
+  const text = await response.text();
+  if (!response.ok) {
+    let detail = text.slice(0, 300);
+    try {
+      const parsed2 = JSON.parse(text);
+      detail = parsed2.error_description ?? parsed2.error ?? detail;
+    } catch {}
+    throw terminal(`Grok token refresh failed (${response.status}): ${detail}. ${SIGN_IN_HINT}`);
+  }
+  const parsed = JSON.parse(text);
+  const accessToken = str(parsed.access_token);
+  if (!accessToken) {
+    throw terminal(`Grok token refresh returned no access_token. ${SIGN_IN_HINT}`);
+  }
+  const expiresAt = typeof parsed.expires_in === "number" ? new Date(Date.now() + parsed.expires_in * 1000).toISOString() : undefined;
+  try {
+    persistRefreshedToken(cred.scope, {
+      key: accessToken,
+      refreshToken: str(parsed.refresh_token),
+      expiresAt
+    });
+  } catch {}
+  return accessToken;
+}
+async function resolveGrokAccessToken() {
+  if (hasClaudishGrokOAuth()) {
+    try {
+      return await GrokOAuth.getInstance().getToken();
+    } catch (error46) {
+      if (!readGrokCredential())
+        throw terminal(`${error46.message}`);
+    }
+  }
+  const cred = readGrokCredential();
+  if (!cred)
+    throw terminal(`No Grok subscription credential. ${SIGN_IN_HINT}`);
+  if (!isGrokCredentialExpired(cred))
+    return cred.key;
+  return refreshShared(cred);
+}
+async function forceRefreshGrokAccessToken() {
+  if (hasClaudishGrokOAuth()) {
+    const oauth = GrokOAuth.getInstance();
+    await oauth.refreshToken();
+    return oauth.getToken();
+  }
+  const cred = readGrokCredential();
+  if (!cred)
+    throw terminal(`No Grok subscription credential. ${SIGN_IN_HINT}`);
+  return refreshShared(cred);
+}
+function refreshShared(cred) {
+  if (!refreshInFlight) {
+    refreshInFlight = performRefresh(cred).finally(() => {
+      refreshInFlight = null;
+    });
+  }
+  return refreshInFlight;
+}
+var GROK_CLIENT_IDENTIFIER = "grok-shell", FALLBACK_GROK_CLIENT_VERSION = "1.0.4", LEGACY_SCOPE = "https://accounts.x.ai/sign-in", EXPIRY_SKEW_MS2, grokHomeOverride = null, claudishOAuthPathOverride = null, GROK_CHANNEL_URL = "https://x.ai/cli/stable", liveClientVersion = null, SIGN_IN_HINT, refreshInFlight = null;
+var init_grok_credentials = __esm(() => {
+  init_grok_oauth();
+  EXPIRY_SKEW_MS2 = 5 * 60 * 1000;
+  SIGN_IN_HINT = "Run `claudish login grok` (no Grok CLI required \u2014 SuperGrok or X Premium+ subscription). " + "An existing `grok login` (~/.grok/auth.json) is also picked up automatically.";
+});
+
+// src/auth/credentials/grok-credential.ts
+class GrokSubscriptionCredentialProvider {
+  catalogName = "grok-subscription";
+  async isAvailable() {
+    try {
+      return hasGrokCredentials();
+    } catch {
+      return false;
+    }
+  }
+  async getRequestAuth() {
+    const [token, version2] = await Promise.all([
+      resolveGrokAccessToken(),
+      resolveGrokClientVersion()
+    ]);
+    return { headers: grokAuthHeaders(token, version2) };
+  }
+}
+var init_grok_credential = __esm(() => {
+  init_grok_credentials();
+});
+
+// src/auth/kimi-oauth.ts
+import { exec as exec3 } from "child_process";
+import { randomBytes as randomBytes3 } from "crypto";
+import { closeSync as closeSync4, existsSync as existsSync12, openSync as openSync4, readFileSync as readFileSync11, unlinkSync as unlinkSync4, writeSync as writeSync4 } from "fs";
+import { homedir as homedir15, hostname as hostname3, platform, release as release2 } from "os";
+import { join as join15 } from "path";
+import { promisify as promisify3 } from "util";
+
 class KimiOAuth {
   static instance = null;
   credentials = null;
@@ -31590,23 +32316,23 @@ class KimiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join13(homedir13(), ".claudish");
-    return join13(claudishDir, "kimi-oauth.json");
+    const claudishDir = join15(homedir15(), ".claudish");
+    return join15(claudishDir, "kimi-oauth.json");
   }
   getDeviceIdPath() {
-    const claudishDir = join13(homedir13(), ".claudish");
-    return join13(claudishDir, "kimi-device-id");
+    const claudishDir = join15(homedir15(), ".claudish");
+    return join15(claudishDir, "kimi-device-id");
   }
   loadOrCreateDeviceId() {
     const deviceIdPath = this.getDeviceIdPath();
-    const claudishDir = join13(homedir13(), ".claudish");
-    if (!existsSync10(claudishDir)) {
-      const { mkdirSync: mkdirSync7 } = __require("fs");
-      mkdirSync7(claudishDir, { recursive: true });
+    const claudishDir = join15(homedir15(), ".claudish");
+    if (!existsSync12(claudishDir)) {
+      const { mkdirSync: mkdirSync8 } = __require("fs");
+      mkdirSync8(claudishDir, { recursive: true });
     }
-    if (existsSync10(deviceIdPath)) {
+    if (existsSync12(deviceIdPath)) {
       try {
-        const deviceId2 = readFileSync9(deviceIdPath, "utf-8").trim();
+        const deviceId2 = readFileSync11(deviceIdPath, "utf-8").trim();
         if (deviceId2) {
           return deviceId2;
         }
@@ -31614,13 +32340,13 @@ class KimiOAuth {
         log(`[KimiOAuth] Failed to load device ID: ${e.message}`);
       }
     }
-    const deviceId = randomBytes2(16).toString("hex").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
+    const deviceId = randomBytes3(16).toString("hex").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
     try {
-      const fd = openSync3(deviceIdPath, "w", 384);
+      const fd = openSync4(deviceIdPath, "w", 384);
       try {
-        writeSync3(fd, deviceId, 0, "utf-8");
+        writeSync4(fd, deviceId, 0, "utf-8");
       } finally {
-        closeSync3(fd);
+        closeSync4(fd);
       }
       log(`[KimiOAuth] New device ID created: ${deviceId}`);
     } catch (e) {
@@ -31765,11 +32491,11 @@ Waiting for authorization...`);
     const currentPlatform = platform();
     try {
       if (currentPlatform === "darwin") {
-        await execAsync2(`open "${url2}"`);
+        await execAsync3(`open "${url2}"`);
       } else if (currentPlatform === "win32") {
-        await execAsync2(`start "${url2}"`);
+        await execAsync3(`start "${url2}"`);
       } else {
-        await execAsync2(`xdg-open "${url2}"`);
+        await execAsync3(`xdg-open "${url2}"`);
       }
     } catch (e) {
       log(`[KimiOAuth] Failed to open browser: ${e.message}`);
@@ -31777,8 +32503,8 @@ Waiting for authorization...`);
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync10(credPath)) {
-      unlinkSync3(credPath);
+    if (existsSync12(credPath)) {
+      unlinkSync4(credPath);
       log("[KimiOAuth] Credentials deleted");
     }
     this.credentials = null;
@@ -31844,8 +32570,8 @@ Waiting for authorization...`);
     } catch (e) {
       log(`[KimiOAuth] Refresh failed: ${e.message}`);
       const credPath = this.getCredentialsPath();
-      if (existsSync10(credPath)) {
-        unlinkSync3(credPath);
+      if (existsSync12(credPath)) {
+        unlinkSync4(credPath);
       }
       this.credentials = null;
       if (process.env.MOONSHOT_API_KEY || process.env.KIMI_API_KEY) {
@@ -31861,11 +32587,11 @@ Details: ${e.message}`);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync10(credPath)) {
+    if (!existsSync12(credPath)) {
       return null;
     }
     try {
-      const data = readFileSync9(credPath, "utf-8");
+      const data = readFileSync11(credPath, "utf-8");
       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");
@@ -31880,17 +32606,17 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials2) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join13(homedir13(), ".claudish");
-    if (!existsSync10(claudishDir)) {
-      const { mkdirSync: mkdirSync7 } = __require("fs");
-      mkdirSync7(claudishDir, { recursive: true });
+    const claudishDir = join15(homedir15(), ".claudish");
+    if (!existsSync12(claudishDir)) {
+      const { mkdirSync: mkdirSync8 } = __require("fs");
+      mkdirSync8(claudishDir, { recursive: true });
     }
-    const fd = openSync3(credPath, "w", 384);
+    const fd = openSync4(credPath, "w", 384);
     try {
       const data = JSON.stringify(credentials2, null, 2);
-      writeSync3(fd, data, 0, "utf-8");
+      writeSync4(fd, data, 0, "utf-8");
     } finally {
-      closeSync3(fd);
+      closeSync4(fd);
     }
     log(`[KimiOAuth] Credentials saved to ${credPath}`);
   }
@@ -31898,10 +32624,10 @@ Details: ${e.message}`);
 function getKimiOAuth() {
   return KimiOAuth.getInstance();
 }
-var execAsync2, OAUTH_CONFIG2;
+var execAsync3, OAUTH_CONFIG2;
 var init_kimi_oauth = __esm(() => {
   init_logger();
-  execAsync2 = promisify2(exec2);
+  execAsync3 = promisify3(exec3);
   OAUTH_CONFIG2 = {
     clientId: "17e5f671-d194-4dfb-9706-5516cb48c098",
     authHost: "https://auth.kimi.com",
@@ -31911,18 +32637,18 @@ var init_kimi_oauth = __esm(() => {
 });
 
 // src/auth/oauth-registry.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join14 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync12 } from "fs";
+import { homedir as homedir16 } from "os";
+import { join as join16 } from "path";
 function hasValidOAuthCredentials(descriptor) {
-  const credPath = join14(homedir14(), ".claudish", descriptor.credentialFile);
-  if (!existsSync11(credPath))
+  const credPath = join16(homedir16(), ".claudish", descriptor.credentialFile);
+  if (!existsSync13(credPath))
     return false;
   if (descriptor.validationMode === "file-exists") {
     return true;
   }
   try {
-    const data = JSON.parse(readFileSync10(credPath, "utf-8"));
+    const data = JSON.parse(readFileSync12(credPath, "utf-8"));
     if (!data.access_token)
       return false;
     if (data.refresh_token)
@@ -31962,6 +32688,12 @@ var init_oauth_registry = __esm(() => {
       validationMode: "check-expiry",
       expiresAtField: "expires_at",
       expiryBufferMs: 5 * 60 * 1000
+    },
+    "grok-subscription": {
+      credentialFile: "grok-oauth.json",
+      validationMode: "check-expiry",
+      expiresAtField: "expires_at",
+      expiryBufferMs: 5 * 60 * 1000
     }
   };
 });
@@ -32110,11 +32842,11 @@ var init_native_anthropic_credential = __esm(() => {
 });
 
 // src/auth/vertex-auth.ts
-import { exec as exec3 } from "child_process";
-import { existsSync as existsSync12 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join15 } from "path";
-import { promisify as promisify3 } from "util";
+import { exec as exec4 } from "child_process";
+import { existsSync as existsSync14 } from "fs";
+import { homedir as homedir17 } from "os";
+import { join as join17 } from "path";
+import { promisify as promisify4 } from "util";
 
 class VertexAuthManager {
   cachedToken = null;
@@ -32168,12 +32900,12 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join15(homedir15(), ".config/gcloud/application_default_credentials.json");
-      if (!existsSync12(adcPath)) {
+      const adcPath = join17(homedir17(), ".config/gcloud/application_default_credentials.json");
+      if (!existsSync14(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
       }
-      const { stdout } = await execAsync3("gcloud auth application-default print-access-token", {
+      const { stdout } = await execAsync4("gcloud auth application-default print-access-token", {
         timeout: 1e4
       });
       const token = stdout.trim();
@@ -32193,13 +32925,13 @@ class VertexAuthManager {
     if (!credPath) {
       return null;
     }
-    if (!existsSync12(credPath)) {
+    if (!existsSync14(credPath)) {
       throw new Error(`Service account file not found: ${credPath}
 
 Check GOOGLE_APPLICATION_CREDENTIALS path.`);
     }
     try {
-      const { stdout } = await execAsync3(`gcloud auth print-access-token --credential-file-override="${credPath}"`, { timeout: 1e4 });
+      const { stdout } = await execAsync4(`gcloud auth print-access-token --credential-file-override="${credPath}"`, { timeout: 1e4 });
       const token = stdout.trim();
       if (!token) {
         log("[VertexAuth] Service account returned empty token");
@@ -32232,8 +32964,8 @@ function validateVertexOAuthConfig() {
 ` + `  export VERTEX_PROJECT='your-gcp-project-id'
 ` + "  export VERTEX_LOCATION='us-central1'  # optional";
   }
-  const adcPath = join15(homedir15(), ".config/gcloud/application_default_credentials.json");
-  const hasADC = existsSync12(adcPath);
+  const adcPath = join17(homedir17(), ".config/gcloud/application_default_credentials.json");
+  const hasADC = existsSync14(adcPath);
   const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
   if (!hasADC && !hasServiceAccount) {
     return `No Vertex AI credentials found.
@@ -32262,10 +32994,10 @@ function getVertexAuthManager() {
   }
   return authManagerInstance;
 }
-var execAsync3, authManagerInstance = null;
+var execAsync4, authManagerInstance = null;
 var init_vertex_auth = __esm(() => {
   init_logger();
-  execAsync3 = promisify3(exec3);
+  execAsync4 = promisify4(exec4);
 });
 
 // src/auth/credentials/vertex-credential.ts
@@ -32353,6 +33085,7 @@ class CredentialAuthority {
     authority.register(makeCodexCredential(), ["openai-codex"]);
     authority.register(new AntigravityCredentialProvider, ["antigravity"]);
     authority.register(new DevinCredentialProvider, ["devin"]);
+    authority.register(new GrokSubscriptionCredentialProvider, ["grok-subscription"]);
     authority.register(makeKimiCredential(), ["kimi"]);
     authority.register(makeKimiCodingCredential(), ["kimi-coding"]);
     authority.register(new VertexCredentialProvider, ["vertex"]);
@@ -32396,6 +33129,7 @@ var init_authority = __esm(() => {
   init_api_key_credential();
   init_codex_credential();
   init_devin_credential();
+  init_grok_credential();
   init_kimi_credential();
   init_local_credential();
   init_native_anthropic_credential();
@@ -34713,9 +35447,9 @@ var init_antigravity2 = __esm(() => {
 });
 
 // src/auth/quota/sources/codex.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
-import { homedir as homedir16 } from "os";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
+import { homedir as homedir18 } from "os";
+import { join as join18 } from "path";
 function formatWindowMinutes(minutes) {
   if (!Number.isFinite(minutes) || minutes <= 0)
     return "";
@@ -34729,7 +35463,7 @@ function formatWindowMinutes(minutes) {
   return `${hours}h${minutes % 60}m`;
 }
 function credentialsPath() {
-  return join16(homedir16(), ".claudish", "codex-oauth.json");
+  return join18(homedir18(), ".claudish", "codex-oauth.json");
 }
 function planLabel(planType) {
   if (!planType)
@@ -34781,10 +35515,10 @@ function scrapeCodexHeaders(headers) {
 }
 function resolveProbeModel() {
   try {
-    const cachePath = join16(homedir16(), ".codex", "models_cache.json");
-    if (!existsSync13(cachePath))
+    const cachePath = join18(homedir18(), ".codex", "models_cache.json");
+    if (!existsSync15(cachePath))
       return;
-    const cache2 = JSON.parse(readFileSync11(cachePath, "utf-8"));
+    const cache2 = JSON.parse(readFileSync13(cachePath, "utf-8"));
     for (const m of cache2.models ?? []) {
       const slug = m?.slug ?? m?.id;
       if (typeof slug === "string" && slug.length > 0)
@@ -34796,9 +35530,9 @@ function resolveProbeModel() {
 function readCodexCredentials() {
   try {
     const path = credentialsPath();
-    if (!existsSync13(path))
+    if (!existsSync15(path))
       return;
-    return JSON.parse(readFileSync11(path, "utf-8"));
+    return JSON.parse(readFileSync13(path, "utf-8"));
   } catch {
     return;
   }
@@ -34829,7 +35563,7 @@ var init_codex = __esm(() => {
     },
     isAvailable() {
       try {
-        return existsSync13(credentialsPath());
+        return existsSync15(credentialsPath());
       } catch {
         return false;
       }
@@ -35210,8 +35944,8 @@ var init_harness = __esm(() => {
 
 // src/behavior/journal.ts
 import { appendFile as appendFile2, mkdir, readFile, rename, stat, writeFile } from "fs/promises";
-import { homedir as homedir17 } from "os";
-import { dirname as dirname6, join as join17 } from "path";
+import { homedir as homedir19 } from "os";
+import { dirname as dirname6, join as join19 } from "path";
 function classifyPath(observed, expected) {
   if (!observed)
     return "not_applicable";
@@ -35223,7 +35957,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 join19(homedir19(), ".claudish", "behavior-journal.jsonl");
 }
 async function prune(path) {
   const content = await readFile(path, "utf8");
@@ -35282,10 +36016,10 @@ __export(exports_aggregate, {
   contextBucket: () => contextBucket,
   TELEMETRY_SCHEMA_VERSION: () => TELEMETRY_SCHEMA_VERSION
 });
-import { createHash as createHash3, randomBytes as randomBytes3 } from "crypto";
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync7 } from "fs";
-import { homedir as homedir18 } from "os";
-import { dirname as dirname7, join as join18 } from "path";
+import { createHash as createHash4, randomBytes as randomBytes4 } from "crypto";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8 } from "fs";
+import { homedir as homedir20 } from "os";
+import { dirname as dirname7, join as join20 } from "path";
 function contextBucket(inputTokens) {
   if (inputTokens < 50000)
     return "0-50k";
@@ -35306,7 +36040,7 @@ function contextFillPct(peakTokens, window2 = enforcedContextWindow) {
   return Math.min(100, Math.max(0, Math.round(peakTokens / window2 * 100)));
 }
 function hashSessionId(rawSessionId, model) {
-  return createHash3("sha256").update(`${SESSION_SALT}:${rawSessionId}:${model}`).digest("hex");
+  return createHash4("sha256").update(`${SESSION_SALT}:${rawSessionId}:${model}`).digest("hex");
 }
 function setTelemetryConsent(value) {
   consent = value;
@@ -35403,7 +36137,7 @@ function pendingReports() {
   return [...sessions.values()].map(toReport);
 }
 function outboxPath() {
-  return join18(homedir18(), ".claudish", "behavior-outbox.jsonl");
+  return join20(homedir20(), ".claudish", "behavior-outbox.jsonl");
 }
 function spoolPendingSync(path = outboxPath()) {
   if (sessions.size === 0)
@@ -35413,7 +36147,7 @@ function spoolPendingSync(path = outboxPath()) {
   if (reports.length === 0)
     return 0;
   try {
-    mkdirSync7(dirname7(path), { recursive: true });
+    mkdirSync8(dirname7(path), { recursive: true });
     appendFileSync2(path, `${reports.map((r) => JSON.stringify(r)).join(`
 `)}
 `);
@@ -35426,7 +36160,7 @@ function spoolPendingSync(path = outboxPath()) {
 var TELEMETRY_SCHEMA_VERSION = 1, enforcedContextWindow = 0, SESSION_SALT, MAX_TRACKED_SESSIONS = 32, MAX_DECISION_KEYS = 200, sessions, consent = false;
 var init_aggregate = __esm(() => {
   init_logger();
-  SESSION_SALT = randomBytes3(32).toString("hex");
+  SESSION_SALT = randomBytes4(32).toString("hex");
   sessions = new Map;
   process.on("exit", () => {
     try {
@@ -35631,10 +36365,10 @@ __export(exports_live_log, {
   recordLiveDivergence: () => recordLiveDivergence
 });
 import { appendFile as appendFile3 } from "fs/promises";
-import { homedir as homedir19 } from "os";
-import { join as join19 } from "path";
+import { homedir as homedir21 } from "os";
+import { join as join21 } from "path";
 function defaultPath() {
-  return join19(homedir19(), ".claudish", "behavior-divergences.jsonl");
+  return join21(homedir21(), ".claudish", "behavior-divergences.jsonl");
 }
 async function recordLiveDivergence(entry, path = defaultPath()) {
   try {
@@ -36330,9 +37064,9 @@ 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 homedir20 } from "os";
-import { join as join20 } from "path";
+import { appendFileSync as appendFileSync3, readFileSync as readFileSync14, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir22 } from "os";
+import { join as join22 } from "path";
 function directoryOf2(filePath) {
   const slash = filePath.lastIndexOf("/");
   return slash > 0 ? filePath.slice(0, slash) : undefined;
@@ -36354,7 +37088,7 @@ function writeTargetsOf(row) {
 function replayTranscript(file2) {
   let text;
   try {
-    text = readFileSync12(file2, "utf8");
+    text = readFileSync14(file2, "utf8");
   } catch {
     return [];
   }
@@ -36411,26 +37145,26 @@ function listTranscripts(root) {
     return files;
   }
   for (const project of projects) {
-    const dir = join20(root, project);
+    const dir = join22(root, project);
     try {
       if (!statSync2(dir).isDirectory())
         continue;
       for (const f of readdirSync2(dir)) {
         if (f.endsWith(".jsonl"))
-          files.push(join20(dir, f));
+          files.push(join22(dir, f));
       }
     } catch {}
   }
   return files;
 }
 function buildCorpus(options = {}) {
-  const root = options.projectsRoot ?? join20(homedir20(), ".claude", "projects");
+  const root = options.projectsRoot ?? join22(homedir22(), ".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 ?? join20(homedir20(), ".claudish", "behavior-divergences.jsonl");
+    const outputPath = options.outputPath ?? join22(homedir22(), ".claudish", "behavior-divergences.jsonl");
     try {
       appendFileSync3(outputPath, `${records.map((r) => JSON.stringify(r)).join(`
 `)}
@@ -37205,25 +37939,25 @@ var init_model_parser = __esm(() => {
 
 // src/stats-buffer.ts
 import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync13,
-  renameSync,
-  unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync7
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync15,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { homedir as homedir21 } from "os";
-import { join as join21 } from "path";
+import { homedir as homedir23 } from "os";
+import { join as join23 } from "path";
 function ensureDir() {
-  if (!existsSync14(CLAUDISH_DIR)) {
-    mkdirSync8(CLAUDISH_DIR, { recursive: true });
+  if (!existsSync16(CLAUDISH_DIR)) {
+    mkdirSync9(CLAUDISH_DIR, { recursive: true });
   }
 }
 function readFromDisk() {
   try {
-    if (!existsSync14(BUFFER_FILE))
+    if (!existsSync16(BUFFER_FILE))
       return [];
-    const raw = readFileSync13(BUFFER_FILE, "utf-8");
+    const raw = readFileSync15(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.events))
       return [];
@@ -37248,9 +37982,9 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed2 = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed2 };
-    const tmpFile = join21(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
-    writeFileSync7(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
-    renameSync(tmpFile, BUFFER_FILE);
+    const tmpFile = join23(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    writeFileSync8(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
+    renameSync2(tmpFile, BUFFER_FILE);
     memoryCache = trimmed2;
   } catch {}
 }
@@ -37292,8 +38026,8 @@ function clearBuffer() {
   try {
     memoryCache = [];
     eventsSinceLastFlush = 0;
-    if (existsSync14(BUFFER_FILE)) {
-      unlinkSync4(BUFFER_FILE);
+    if (existsSync16(BUFFER_FILE)) {
+      unlinkSync5(BUFFER_FILE);
     }
   } catch {}
 }
@@ -37321,8 +38055,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 = join21(homedir21(), ".claudish");
-  BUFFER_FILE = join21(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join23(homedir23(), ".claudish");
+  BUFFER_FILE = join23(CLAUDISH_DIR, "stats-buffer.json");
   process.on("exit", syncFlushOnExit);
   process.on("SIGTERM", () => {
     try {
@@ -37459,7 +38193,7 @@ __export(exports_telemetry, {
   classifyError: () => classifyError,
   buildReport: () => buildReport
 });
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 function getVersion() {
   return VERSION;
 }
@@ -37727,7 +38461,7 @@ function initTelemetry(_config) {
   } catch {
     consentEnabled = false;
   }
-  sessionId = randomBytes4(8).toString("hex");
+  sessionId = randomBytes5(8).toString("hex");
   claudishVersion = getVersion();
   installMethod = detectInstallMethod();
 }
@@ -38250,6 +38984,8 @@ function extractProviderMessage(body) {
 function isTerminalError(status, bodyText, terminal429) {
   if (status === 401 || status === 403)
     return true;
+  if (status === 426)
+    return true;
   if (status === 429 && terminal429)
     return true;
   const lower = (bodyText || "").toLowerCase();
@@ -40533,9 +41269,9 @@ var init_openai_responses_sse = __esm(() => {
 });
 
 // src/handlers/shared/token-tracker.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir22 } from "os";
-import { dirname as dirname8, join as join22 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir24 } from "os";
+import { dirname as dirname8, join as join24 } from "path";
 function stripProviderPrefix(name) {
   const at = name.indexOf("@");
   return at === -1 ? name : name.slice(at + 1);
@@ -40723,9 +41459,9 @@ class TokenTracker {
         };
       }
       const override = process.env.CLAUDISH_TOKEN_FILE;
-      const outPath = override || join22(homedir22(), ".claudish", `tokens-${this.port}.json`);
-      mkdirSync9(dirname8(outPath), { recursive: true });
-      writeFileSync8(outPath, JSON.stringify(data), "utf-8");
+      const outPath = override || join24(homedir24(), ".claudish", `tokens-${this.port}.json`);
+      mkdirSync10(dirname8(outPath), { recursive: true });
+      writeFileSync9(outPath, JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
     }
@@ -41136,7 +41872,8 @@ class ComposedHandler {
       } else {
         const errorText = await response.text();
         log(`[${this.provider.displayName}] Error: ${errorText}`);
-        const hint = getRecoveryHint(response.status, errorText, this.provider.displayName);
+        const transportTerminal = this.provider.classifyTerminalError?.(response.status, errorText);
+        const hint = getRecoveryHint(response.status, errorText, this.provider.displayName, transportTerminal);
         let parsedErrorBody;
         try {
           parsedErrorBody = JSON.parse(errorText);
@@ -41189,7 +41926,7 @@ class ComposedHandler {
         const errorBody = parsedErrorBody ?? {
           error: { type: "api_error", message: errorText }
         };
-        if (isTerminalError(response.status, errorText, isTerminal429(errorText))) {
+        if (isTerminalError(response.status, errorText, transportTerminal ?? isTerminal429(errorText))) {
           const surfaced = buildSurfacedErrorMessage({
             providerDisplayName: this.provider.displayName,
             status: response.status,
@@ -41565,14 +42302,17 @@ class ComposedHandler {
     }
   }
 }
-function getRecoveryHint(status, errorText, providerName) {
+function getRecoveryHint(status, errorText, providerName, transportTerminal429) {
   const lower = errorText.toLowerCase();
   if (status === 503 || lower.includes("overloaded")) {
     return "Provider overloaded. Retry or use a different model.";
   }
-  if (status === 429 && isTerminal429(errorText)) {
+  if (status === 429 && (transportTerminal429 ?? isTerminal429(errorText))) {
     return "Out of quota \u2014 check your plan & billing details. This won't recover on retry.";
   }
+  if (status === 429 && transportTerminal429 === false) {
+    return "Rate limited. Wait, reduce concurrency, or check plan limits.";
+  }
   if (isQuotaExhaustionError(status, errorText)) {
     return "Subscription allowance spent \u2014 this refills on the provider's own schedule (see the message below). Reducing concurrency won't help; switch model/provider or wait.";
   }
@@ -43979,7 +44719,7 @@ var init_default_routing_rules = __esm(() => {
     "o1-*": ["openai-codex", "openai", "openrouter"],
     "o3-*": ["openai-codex", "openai", "openrouter"],
     "gemini-*": ["antigravity", "google", "openrouter"],
-    "grok-*": ["x-ai", "openrouter"],
+    "grok-*": ["grok-subscription", "x-ai", "openrouter"],
     "kimi-*": ["kimi-coding", "opencode-zen-go", "kimi", "openrouter"],
     "k3*": ["kimi-coding", "opencode-zen-go", "kimi", "openrouter"],
     "minimax-*": ["minimax-coding", "opencode-zen-go", "minimax", "openrouter"],
@@ -44902,9 +45642,9 @@ var CLAUDISH_BIN_ENV = "CLAUDISH_BIN";
 // src/channel/session-manager.ts
 import { spawn } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
-import { createWriteStream, mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir23 } from "os";
-import { join as join23 } from "path";
+import { createWriteStream, mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir25 } from "os";
+import { join as join25 } from "path";
 
 class SessionManager {
   sessions = new Map;
@@ -44916,7 +45656,7 @@ class SessionManager {
   constructor(options) {
     this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.scrollbackCapacity = options?.scrollbackCapacity ?? DEFAULT_SCROLLBACK;
-    this.sessionsDir = options?.sessionsDir ?? process.env.CLAUDISH_SESSIONS_DIR ?? join23(homedir23(), ".claudish", "sessions");
+    this.sessionsDir = options?.sessionsDir ?? process.env.CLAUDISH_SESSIONS_DIR ?? join25(homedir25(), ".claudish", "sessions");
     this.onStateChange = options?.onStateChange;
   }
   createSession(opts) {
@@ -44926,10 +45666,10 @@ class SessionManager {
     const sessionId2 = randomUUID4().slice(0, 8);
     const timeout = Math.min(opts.timeoutSeconds ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     const startedAt = new Date().toISOString();
-    const sessionDir = join23(this.sessionsDir, sessionId2);
-    mkdirSync10(sessionDir, { recursive: true });
+    const sessionDir = join25(this.sessionsDir, sessionId2);
+    mkdirSync11(sessionDir, { recursive: true });
     if (opts.prompt) {
-      writeFileSync9(join23(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync10(join25(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     }
     const args = [
       "--model",
@@ -44965,7 +45705,7 @@ class SessionManager {
         });
       }
     });
-    const outputLogStream = createWriteStream(join23(sessionDir, "output.log"));
+    const outputLogStream = createWriteStream(join25(sessionDir, "output.log"));
     const entry = {
       info: {
         sessionId: sessionId2,
@@ -45012,9 +45752,9 @@ class SessionManager {
       watcher.processExited(code);
       outputLogStream.end();
       if (entry.stderr) {
-        writeFileSync9(join23(sessionDir, "stderr.log"), entry.stderr, "utf-8");
+        writeFileSync10(join25(sessionDir, "stderr.log"), entry.stderr, "utf-8");
       }
-      writeFileSync9(join23(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
+      writeFileSync10(join25(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
       this.cleanupSigint();
     });
     proc.on("error", (err) => {
@@ -45324,9 +46064,9 @@ function compareByReleaseDateDesc(a, b) {
 }
 
 // src/model-loader.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir24 } from "os";
-import { join as join24 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir26 } from "os";
+import { join as join26 } from "path";
 function groupRecommendedModels(entries) {
   const byId = new Map;
   const categoryOrder = new Map;
@@ -45436,9 +46176,9 @@ async function getRecommendedModels(opts = {}) {
   if (!forceRefresh && _cachedRecommendedModels) {
     return _cachedRecommendedModels;
   }
-  if (!forceRefresh && existsSync15(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (!forceRefresh && existsSync17(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync14(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync16(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -45454,9 +46194,9 @@ async function getRecommendedModels(opts = {}) {
       if (data.models && data.models.length > 0) {
         _cachedRecommendedModels = data;
         try {
-          const cacheDir = join24(homedir24(), ".claudish");
-          mkdirSync11(cacheDir, { recursive: true });
-          writeFileSync10(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
+          const cacheDir = join26(homedir26(), ".claudish");
+          mkdirSync12(cacheDir, { recursive: true });
+          writeFileSync11(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
         } catch {}
         return data;
       }
@@ -45467,9 +46207,9 @@ async function getRecommendedModels(opts = {}) {
 function getRecommendedModelsSync() {
   if (_cachedRecommendedModels)
     return _cachedRecommendedModels;
-  if (existsSync15(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (existsSync17(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync14(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync16(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -45593,7 +46333,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 = join24(homedir24(), ".claudish", "recommended-models-cache.json");
+  RECOMMENDED_MODELS_CACHE_PATH = join26(homedir26(), ".claudish", "recommended-models-cache.json");
   FIREBASE_SLUG_TO_PROVIDER_NAME = {
     openai: "openai",
     google: "google",
@@ -45812,11 +46552,11 @@ var splitPath = (path) => {
     return patternCache[cacheKey];
   }
   return null;
-}, tryDecode = (str, decoder) => {
+}, tryDecode = (str2, decoder) => {
   try {
-    return decoder(str);
+    return decoder(str2);
   } catch {
-    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+    return str2.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
       try {
         return decoder(match);
       } catch {
@@ -45824,7 +46564,7 @@ var splitPath = (path) => {
       }
     });
   }
-}, tryDecodeURI = (str) => tryDecode(str, decodeURI), getPath = (request) => {
+}, tryDecodeURI = (str2) => tryDecode(str2, decodeURI), getPath = (request) => {
   const url2 = request.url;
   const start = url2.indexOf("/", url2.indexOf(":") + 4);
   let i = start;
@@ -45953,7 +46693,7 @@ var init_url = __esm(() => {
 });
 
 // ../../node_modules/.bun/hono@4.10.6/node_modules/hono/dist/request.js
-var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_), HonoRequest;
+var tryDecodeURIComponent = (str2) => tryDecode(str2, decodeURIComponent_), HonoRequest;
 var init_request = __esm(() => {
   init_http_exception();
   init_constants();
@@ -46075,25 +46815,25 @@ var HtmlEscapedCallbackPhase, raw = (value, callbacks) => {
   escapedString.isEscaped = true;
   escapedString.callbacks = callbacks;
   return escapedString;
-}, resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
-  if (typeof str === "object" && !(str instanceof String)) {
-    if (!(str instanceof Promise)) {
-      str = str.toString();
+}, resolveCallback = async (str2, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str2 === "object" && !(str2 instanceof String)) {
+    if (!(str2 instanceof Promise)) {
+      str2 = str2.toString();
     }
-    if (str instanceof Promise) {
-      str = await str;
+    if (str2 instanceof Promise) {
+      str2 = await str2;
     }
   }
-  const callbacks = str.callbacks;
+  const callbacks = str2.callbacks;
   if (!callbacks?.length) {
-    return Promise.resolve(str);
+    return Promise.resolve(str2);
   }
   if (buffer) {
-    buffer[0] += str;
+    buffer[0] += str2;
   } else {
-    buffer = [str];
+    buffer = [str2];
   }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) => Promise.all(res.filter(Boolean).map((str22) => resolveCallback(str22, phase, false, context, buffer))).then(() => buffer[0]));
   if (preserveCallbacks) {
     return raw(await resStr, callbacks);
   } else {
@@ -48758,11 +49498,11 @@ var init_ollama_api_format = __esm(() => {
 });
 
 // src/providers/api-key-provenance.ts
-import { existsSync as existsSync16, readFileSync as readFileSync15 } from "fs";
-import { homedir as homedir25 } from "os";
-import { join as join25, resolve as resolve2 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync17 } from "fs";
+import { homedir as homedir27 } from "os";
+import { join as join27, resolve as resolve2 } from "path";
 function activeConfigPath() {
-  return activeGlobalConfigFile(join25(homedir25(), ".claudish", "config.json"));
+  return activeGlobalConfigFile(join27(homedir27(), ".claudish", "config.json"));
 }
 function configLayerLabel() {
   return getConfigFileOverride() ? activeConfigPath() : "~/.claudish/config.json";
@@ -48839,9 +49579,9 @@ function formatProvenanceLog(p) {
 function readDotenvKey(envVars) {
   try {
     const dotenvPath = resolve2(".env");
-    if (!existsSync16(dotenvPath))
+    if (!existsSync18(dotenvPath))
       return null;
-    const parsed = import_dotenv.parse(readFileSync15(dotenvPath, "utf-8"));
+    const parsed = import_dotenv.parse(readFileSync17(dotenvPath, "utf-8"));
     for (const v of envVars) {
       if (parsed[v])
         return parsed[v];
@@ -48854,9 +49594,9 @@ function readDotenvKey(envVars) {
 function readConfigKey(envVar) {
   try {
     const configPath = activeConfigPath();
-    if (!existsSync16(configPath))
+    if (!existsSync18(configPath))
       return null;
-    const cfg = JSON.parse(readFileSync15(configPath, "utf-8"));
+    const cfg = JSON.parse(readFileSync17(configPath, "utf-8"));
     return cfg.apiKeys?.[envVar] || null;
   } catch {
     return null;
@@ -49042,6 +49782,29 @@ var init_gemini_apikey = __esm(() => {
   init_gemini_queue();
 });
 
+// src/providers/transport/grok-subscription.ts
+var GrokSubscriptionProviderTransport;
+var init_grok_subscription = __esm(() => {
+  init_authority();
+  init_grok_credentials();
+  init_openai();
+  GrokSubscriptionProviderTransport = class GrokSubscriptionProviderTransport extends OpenAIProviderTransport {
+    async getHeaders() {
+      const auth = await credentials.getRequestAuth("grok-subscription", {
+        model: this.modelName
+      });
+      const headers = { ...auth.headers };
+      if (this.provider.headers) {
+        Object.assign(headers, this.provider.headers);
+      }
+      return headers;
+    }
+    async forceRefreshAuth() {
+      await forceRefreshGrokAccessToken();
+    }
+  };
+});
+
 // src/providers/transport/ollamacloud.ts
 class OllamaProviderTransport {
   name = "ollamacloud";
@@ -49202,7 +49965,7 @@ function createHandlerForProvider(ctx) {
   log(`[Proxy] Handler: provider=${ctx.provider.name}, model=${ctx.modelName}`);
   return profile.createHandler(ctx);
 }
-var geminiProfile, antigravityProfile, devinProfile, openaiProfile, openaiCodexProfile, anthropicCompatProfile, glmProfile, openCodeZenProfile, ollamaCloudProfile, litellmProfile, vertexProfile, PROVIDER_PROFILES;
+var geminiProfile, antigravityProfile, devinProfile, grokSubscriptionProfile, openaiProfile, openaiCodexProfile, anthropicCompatProfile, glmProfile, openCodeZenProfile, ollamaCloudProfile, litellmProfile, vertexProfile, PROVIDER_PROFILES;
 var init_provider_profiles = __esm(() => {
   init_anthropic_api_format();
   init_base_api_format();
@@ -49222,6 +49985,7 @@ var init_provider_profiles = __esm(() => {
   init_antigravity();
   init_devin2();
   init_gemini_apikey();
+  init_grok_subscription();
   init_litellm();
   init_ollamacloud();
   init_openai_codex();
@@ -49265,6 +50029,19 @@ var init_provider_profiles = __esm(() => {
       return handler;
     }
   };
+  grokSubscriptionProfile = {
+    createHandler(ctx) {
+      const transport = new GrokSubscriptionProviderTransport(ctx.provider, ctx.modelName, "");
+      const adapter = new OpenAIAPIFormat(ctx.modelName);
+      const handler = new ComposedHandler(transport, ctx.targetModel, ctx.modelName, ctx.port, {
+        adapter,
+        tokenStrategy: "delta-aware",
+        ...ctx.sharedOpts
+      });
+      log(`[Proxy] Created Grok subscription handler (composed): ${ctx.modelName}`);
+      return handler;
+    }
+  };
   openaiProfile = {
     createHandler(ctx) {
       if (requiresResponsesApi(ctx.modelName)) {
@@ -49437,6 +50214,7 @@ var init_provider_profiles = __esm(() => {
     openai: openaiProfile,
     "openai-codex": openaiCodexProfile,
     "x-ai": openaiProfile,
+    "grok-subscription": grokSubscriptionProfile,
     qwen: openaiProfile,
     minimax: anthropicCompatProfile,
     "minimax-coding": anthropicCompatProfile,
@@ -50174,9 +50952,9 @@ var init_poe = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16, statSync as statSync4 } from "fs";
-import { homedir as homedir26 } from "os";
-import { join as join26 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync18, statSync as statSync4 } from "fs";
+import { homedir as homedir28 } from "os";
+import { join as join28 } from "path";
 function prefixMatch(modelName) {
   for (const [key, pricing] of pricingMap) {
     if (modelName.startsWith(key))
@@ -50214,12 +50992,12 @@ async function warmPricingCache() {
 }
 function loadDiskCache() {
   try {
-    if (!existsSync17(CACHE_FILE))
+    if (!existsSync19(CACHE_FILE))
       return false;
     const stat2 = statSync4(CACHE_FILE);
     const age = Date.now() - stat2.mtimeMs;
     const isFresh = age < CACHE_TTL_MS3;
-    const raw2 = readFileSync16(CACHE_FILE, "utf-8");
+    const raw2 = readFileSync18(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw2);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -50235,8 +51013,8 @@ var init_pricing_cache = __esm(() => {
   init_logger();
   init_catalog_query();
   pricingMap = new Map;
-  CACHE_DIR = join26(homedir26(), ".claudish");
-  CACHE_FILE = join26(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join28(homedir28(), ".claudish");
+  CACHE_FILE = join28(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
 });
 
@@ -50761,20 +51539,20 @@ var init_redact = __esm(() => {
 });
 
 // src/team-stats.ts
-import { existsSync as existsSync18, readFileSync as readFileSync17, writeFileSync as writeFileSync11 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync19, writeFileSync as writeFileSync12 } from "fs";
+import { join as join29 } from "path";
 function statsDir(sessionPath) {
-  return join27(sessionPath, "stats");
+  return join29(sessionPath, "stats");
 }
 function tokenFileFor(sessionPath, anonId) {
-  return join27(statsDir(sessionPath), `${anonId}.json`);
+  return join29(statsDir(sessionPath), `${anonId}.json`);
 }
 function readTokenStats(sessionPath, anonId) {
   const path = tokenFileFor(sessionPath, anonId);
-  if (!existsSync18(path))
+  if (!existsSync20(path))
     return null;
   try {
-    return JSON.parse(readFileSync17(path, "utf-8"));
+    return JSON.parse(readFileSync19(path, "utf-8"));
   } catch {
     return null;
   }
@@ -50922,7 +51700,7 @@ ${segs.join(" \xB7 ")}`;
 }
 function writeStatusFile(sessionPath, manifest, status, opts) {
   try {
-    writeFileSync11(join27(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
+    writeFileSync12(join29(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
 `, "utf-8");
   } catch {}
 }
@@ -51073,13 +51851,13 @@ __export(exports_team_orchestrator, {
 import { spawn as spawn2 } from "child_process";
 import {
   createWriteStream as createWriteStream2,
-  existsSync as existsSync19,
-  mkdirSync as mkdirSync12,
-  readFileSync as readFileSync18,
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync20,
   readdirSync as readdirSync3,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "fs";
-import { join as join28, resolve as resolve3 } from "path";
+import { join as join30, resolve as resolve3 } from "path";
 function resolveCaptureMode(explicit, env = process.env) {
   if (explicit)
     return explicit;
@@ -51152,7 +51930,7 @@ function persistErrorLog(errorLogPath, header, stderr, stdoutTail) {
   parts.push("--- stderr ---", stderr.trim() ? redactSecrets(stderr) : "(empty)", "");
   parts.push("--- stdout (tail) ---", stdoutTail.trim() ? redactSecrets(stdoutTail) : "(empty)", "");
   try {
-    writeFileSync12(errorLogPath, parts.join(`
+    writeFileSync13(errorLogPath, parts.join(`
 `), "utf-8");
   } catch {}
 }
@@ -51176,18 +51954,18 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync19(join28(sessionPath, "manifest.json"))) {
+  if (existsSync21(join30(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.`);
   }
-  mkdirSync12(join28(sessionPath, "work"), { recursive: true });
-  mkdirSync12(join28(sessionPath, "errors"), { recursive: true });
+  mkdirSync13(join30(sessionPath, "work"), { recursive: true });
+  mkdirSync13(join30(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync12(join28(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync19(join28(sessionPath, "input.md"))) {
+    writeFileSync13(join30(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync21(join30(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"));
@@ -51204,9 +51982,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync12(join28(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync13(join30(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync12(join28(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync13(join30(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -51220,7 +51998,7 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync12(join28(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync13(join30(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
 function assertValidRequirePattern(pattern) {
@@ -51237,7 +52015,7 @@ function readFullOutputIfNeeded(opts) {
   if (crashed || !requirePattern || outputSize <= STDOUT_TAIL_LIMIT)
     return;
   try {
-    return readFileSync18(outputPath, "utf-8");
+    return readFileSync20(outputPath, "utf-8");
   } catch {
     return;
   }
@@ -51245,15 +52023,15 @@ function readFullOutputIfNeeded(opts) {
 async function runModels(sessionPath, opts = {}) {
   const timeoutMs = (opts.timeout ?? 300) * 1000;
   assertValidRequirePattern(opts.requirePattern);
-  const manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join28(sessionPath, "status.json");
-  const inputPath = join28(sessionPath, "input.md");
-  const inputContent = readFileSync18(inputPath, "utf-8");
+  const manifest = JSON.parse(readFileSync20(join30(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join30(sessionPath, "status.json");
+  const inputPath = join30(sessionPath, "input.md");
+  const inputContent = readFileSync20(inputPath, "utf-8");
   const spawnPlan = await (opts.spawnPlanner ?? prehydrateCredentialsForSpawn)(Object.values(manifest.models).map((m) => m.model));
-  const statusCache = JSON.parse(readFileSync18(statusPath, "utf-8"));
+  const statusCache = JSON.parse(readFileSync20(statusPath, "utf-8"));
   function updateModelStatus(id, update) {
     statusCache.models[id] = { ...statusCache.models[id], ...update };
-    writeFileSync12(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
+    writeFileSync13(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
   }
   const minOutputBytes = opts.minOutputBytes ?? DEFAULT_MIN_OUTPUT_BYTES;
   const requirePattern = opts.requirePattern;
@@ -51286,7 +52064,7 @@ async function runModels(sessionPath, opts = {}) {
       persistErrorLog(rt.errorLogPath, `RECOVERED: ${note}`, stderr, stdoutTail);
     opts.onStatusChange?.(id, statusCache.models[id]);
   }
-  mkdirSync12(statsDir(sessionPath), { recursive: true });
+  mkdirSync13(statsDir(sessionPath), { recursive: true });
   const processes = new Map;
   const runtimes = new Map;
   const sigintHandler = () => {
@@ -51298,8 +52076,8 @@ async function runModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join28(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join28(sessionPath, "errors", `${anonId}.log`);
+    const outputPath = join30(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join30(sessionPath, "errors", `${anonId}.log`);
     const spawnModel = spawnPlan.pinned.get(entry.model) ?? entry.model;
     const args = [
       "--model",
@@ -51438,7 +52216,7 @@ async function runModels(sessionPath, opts = {}) {
       proc.on("exit", (code) => {
         const timedOut = statusCache.models[anonId]?.state === "TIMEOUT";
         if (!timedOut && meaningfulStderr(stderr)) {
-          writeFileSync12(errorLogPath, redactSecrets(stderr), "utf-8");
+          writeFileSync13(errorLogPath, redactSecrets(stderr), "utf-8");
         }
         exitCode = code;
         if (outputStream.destroyed) {
@@ -51525,7 +52303,7 @@ async function runModels(sessionPath, opts = {}) {
     opts.onStatusChange?.(id, statusCache.models[id]);
     const stopped = await terminateChildTree(proc);
     if (!stopped) {
-      persistErrorLog(rt?.errorLogPath ?? join28(sessionPath, "errors", `${id}.log`), "TIMEOUT: child survived SIGKILL \u2014 it may still be running and billing", stderr, stdoutTail);
+      persistErrorLog(rt?.errorLogPath ?? join30(sessionPath, "errors", `${id}.log`), "TIMEOUT: child survived SIGKILL \u2014 it may still be running and billing", stderr, stdoutTail);
     }
   };
   const allDone = Promise.all(completionPromises);
@@ -51584,23 +52362,23 @@ async function judgeResponses(sessionPath, opts = {}) {
   const responses = {};
   for (const file2 of responseFiles) {
     const id = file2.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync18(join28(sessionPath, file2), "utf-8");
+    responses[id] = readFileSync20(join30(sessionPath, file2), "utf-8");
   }
-  const input = readFileSync18(join28(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync20(join30(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync12(join28(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync13(join30(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join28(sessionPath, "judging");
-  mkdirSync12(judgePath, { recursive: true });
+  const judgePath = join30(sessionPath, "judging");
+  mkdirSync13(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(join28(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync13(join30(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync18(join28(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync20(join30(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -51610,7 +52388,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync20(join30(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -51673,7 +52451,7 @@ function parseJudgeVotes(judgePath, responseIds) {
     const judgeId = file2.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync18(join28(judgePath, file2), "utf-8");
+      content = readFileSync20(join30(judgePath, file2), "utf-8");
     } catch {
       continue;
     }
@@ -51725,7 +52503,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync20(join30(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -51786,14 +52564,14 @@ __export(exports_mcp_server, {
   parseAnthropicSse: () => parseAnthropicSse,
   formatTeamResult: () => formatTeamResult
 });
-import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync19, readdirSync as readdirSync4, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir27 } from "os";
-import { dirname as dirname9, join as join29, resolve as resolve4 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync21, readdirSync as readdirSync4, writeFileSync as writeFileSync14 } from "fs";
+import { homedir as homedir29 } from "os";
+import { dirname as dirname9, join as join31, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
-  if (!forceRefresh && existsSync20(ALL_MODELS_CACHE_PATH2)) {
+  if (!forceRefresh && existsSync22(ALL_MODELS_CACHE_PATH2)) {
     try {
-      const cacheData = JSON.parse(readFileSync19(ALL_MODELS_CACHE_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync21(ALL_MODELS_CACHE_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const ageInDays = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
       if (ageInDays <= CACHE_MAX_AGE_DAYS) {
@@ -51807,12 +52585,12 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync13(CLAUDISH_CACHE_DIR, { recursive: true });
-    writeFileSync13(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
+    mkdirSync14(CLAUDISH_CACHE_DIR, { recursive: true });
+    writeFileSync14(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
-    if (existsSync20(ALL_MODELS_CACHE_PATH2)) {
-      const cacheData = JSON.parse(readFileSync19(ALL_MODELS_CACHE_PATH2, "utf-8"));
+    if (existsSync22(ALL_MODELS_CACHE_PATH2)) {
+      const cacheData = JSON.parse(readFileSync21(ALL_MODELS_CACHE_PATH2, "utf-8"));
       return cacheData.models || [];
     }
     return [];
@@ -52413,7 +53191,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       let stderrFull = stderr_snippet || "";
       if (error_log_path) {
         try {
-          stderrFull = readFileSync19(error_log_path, "utf-8");
+          stderrFull = readFileSync21(error_log_path, "utf-8");
         } catch {}
       }
       const sessionData = {};
@@ -52421,16 +53199,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] = readFileSync19(join29(sp, file2), "utf-8");
+            sessionData[file2] = readFileSync21(join31(sp, file2), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join29(sp, "errors");
-          if (existsSync20(errorDir)) {
+          const errorDir = join31(sp, "errors");
+          if (existsSync22(errorDir)) {
             for (const f of readdirSync4(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync19(join29(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync21(join31(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -52440,7 +53218,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 = readFileSync19(join29(sp, f), "utf-8");
+                const content = readFileSync21(join31(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -52449,9 +53227,9 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       }
       let version2 = "unknown";
       try {
-        const pkgPath = join29(__dirname2, "../package.json");
-        if (existsSync20(pkgPath)) {
-          version2 = JSON.parse(readFileSync19(pkgPath, "utf-8")).version;
+        const pkgPath = join31(__dirname2, "../package.json");
+        if (existsSync22(pkgPath)) {
+          version2 = JSON.parse(readFileSync21(pkgPath, "utf-8")).version;
         }
       } catch {}
       const report = {
@@ -52866,8 +53644,8 @@ var init_mcp_server = __esm(() => {
   import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
   __dirname2 = dirname9(__filename2);
-  CLAUDISH_CACHE_DIR = join29(homedir27(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join29(CLAUDISH_CACHE_DIR, "all-models.json");
+  CLAUDISH_CACHE_DIR = join31(homedir29(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join31(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",
@@ -52893,7 +53671,7 @@ var exports_serve_command = {};
 __export(exports_serve_command, {
   serveCommand: () => serveCommand
 });
-import { existsSync as existsSync21, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync22 } from "fs";
 function parseServeArgs(args) {
   const out = {};
   for (let i = 0;i < args.length; i++) {
@@ -52912,12 +53690,12 @@ function parseServeArgs(args) {
   return out;
 }
 function loadModelMap(path) {
-  if (!existsSync21(path)) {
+  if (!existsSync23(path)) {
     throw new Error(`--models file not found: ${path}`);
   }
   let raw2;
   try {
-    raw2 = readFileSync20(path, "utf-8");
+    raw2 = readFileSync22(path, "utf-8");
   } catch (e) {
     throw new Error(`failed to read --models file ${path}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -52996,7 +53774,7 @@ var exports_behavior_command = {};
 __export(exports_behavior_command, {
   behaviorCommand: () => behaviorCommand
 });
-import { existsSync as existsSync22, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync23, writeFileSync as writeFileSync15 } from "fs";
 function severityColor(sev) {
   if (sev === "fix")
     return green(sev);
@@ -53094,8 +53872,8 @@ function setTelemetryEnabled(value) {
   const path = getConfigPath();
   let cfg = {};
   try {
-    if (existsSync22(path)) {
-      const parsed = JSON.parse(readFileSync21(path, "utf-8"));
+    if (existsSync24(path)) {
+      const parsed = JSON.parse(readFileSync23(path, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         cfg = parsed;
       }
@@ -53104,7 +53882,7 @@ function setTelemetryEnabled(value) {
   const behavior = cfg.behavior && typeof cfg.behavior === "object" && !Array.isArray(cfg.behavior) ? { ...cfg.behavior } : {};
   behavior.telemetry = { enabled: value };
   cfg.behavior = behavior;
-  writeFileSync14(path, `${JSON.stringify(cfg, null, 2)}
+  writeFileSync15(path, `${JSON.stringify(cfg, null, 2)}
 `, "utf-8");
 }
 function showTelemetry(action, json2) {
@@ -53116,8 +53894,8 @@ function showTelemetry(action, json2) {
   let pending = 0;
   try {
     const path = outboxPath();
-    if (existsSync22(path)) {
-      pending = readFileSync21(path, "utf8").split(`
+    if (existsSync24(path)) {
+      pending = readFileSync23(path, "utf8").split(`
 `).filter(Boolean).length;
     }
   } catch {}
@@ -53189,9 +53967,9 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn3 } from "child_process";
 import { execSync } from "child_process";
-import { existsSync as existsSync23, readFileSync as readFileSync22, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync24, writeFileSync as writeFileSync16 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname10, join as join30 } from "path";
+import { dirname as dirname10, join as join32 } from "path";
 import { setTimeout as wait } from "timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveRouteInfo(modelId) {
@@ -53285,18 +54063,18 @@ function buildPaneHeader(model, prompt, bg) {
 function findMagmuxBinary() {
   const thisFile = fileURLToPath2(import.meta.url);
   const thisDir = dirname10(thisFile);
-  const pkgRoot = join30(thisDir, "..");
+  const pkgRoot = join32(thisDir, "..");
   const platform2 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join30(pkgRoot, "native", `magmux-${platform2}-${arch}`);
-  if (existsSync23(bundledMagmux))
+  const bundledMagmux = join32(pkgRoot, "native", `magmux-${platform2}-${arch}`);
+  if (existsSync25(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform2}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join30(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync23(candidate))
+      const candidate = join32(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync25(candidate))
         return candidate;
       const parent = dirname10(searchDir);
       if (parent === searchDir)
@@ -53320,7 +54098,7 @@ function withoutControlPanes(evt) {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync23(sockPath)) {
+    if (existsSync25(sockPath)) {
       try {
         client = await new Promise((resolve5, reject) => {
           const s = netConnect(sockPath);
@@ -53407,9 +54185,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 = join30(sessionPath, "gridfile.txt");
-  const prompt = readFileSync22(join30(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync22(join30(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join32(sessionPath, "gridfile.txt");
+  const prompt = readFileSync24(join32(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync24(join32(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -53420,7 +54198,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
     const header = buildPaneHeader(model, rawPrompt, bg);
     return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
   });
-  writeFileSync15(gridfilePath, `${gridLines.join(`
+  writeFileSync16(gridfilePath, `${gridLines.join(`
 `)}
 `, "utf-8");
   const magmuxPath = findMagmuxBinary();
@@ -53440,8 +54218,8 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join30(sessionPath, "status.json");
-  writeFileSync15(statusPath, JSON.stringify(status, null, 2), "utf-8");
+  const statusPath = join32(sessionPath, "status.json");
+  writeFileSync16(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
 var BANNER_BG_COLORS;
@@ -53465,8 +54243,8 @@ var exports_team_cli = {};
 __export(exports_team_cli, {
   teamCommand: () => teamCommand
 });
-import { readFileSync as readFileSync23 } from "fs";
-import { join as join31 } from "path";
+import { readFileSync as readFileSync25 } from "fs";
+import { join as join33 } from "path";
 function getFlag(args, flag) {
   const idx = args.indexOf(flag);
   if (idx === -1 || idx + 1 >= args.length)
@@ -53589,7 +54367,7 @@ async function teamCommand(args) {
     }
     case "judge": {
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync23(join31(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync25(join33(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
@@ -53607,7 +54385,7 @@ async function teamCommand(args) {
       });
       printStatus(status);
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync23(join31(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync25(join33(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "status": {
@@ -54699,7 +55477,7 @@ function wrapAnsi(string5, columns, options) {
   return String(string5).normalize().replaceAll(`\r
 `, `
 `).split(`
-`).map((line) => exec4(line, columns, options)).join(`
+`).map((line) => exec5(line, columns, options)).join(`
 `);
 }
 var ESCAPES, END_CODE = 39, ANSI_ESCAPE_BELL = "\x07", ANSI_CSI = "[", ANSI_OSC = "]", ANSI_SGR_TERMINATOR = "m", ANSI_ESCAPE_LINK, wrapAnsiCode = (code) => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`, wrapAnsiHyperlink = (url2) => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${url2}${ANSI_ESCAPE_BELL}`, wordLengths = (string5) => string5.split(" ").map((character) => stringWidth(character)), wrapWord = (rows, word, columns) => {
@@ -54753,7 +55531,7 @@ var ESCAPES, END_CODE = 39, ANSI_ESCAPE_BELL = "\x07", ANSI_CSI = "[", ANSI_OSC
     return string5;
   }
   return words.slice(0, last).join(" ") + words.slice(last).join("");
-}, exec4 = (string5, columns, options = {}) => {
+}, exec5 = (string5, columns, options = {}) => {
   if (options.trim !== false && string5.trim() === "") {
     return "";
   }
@@ -54855,7 +55633,7 @@ var init_wrap_ansi = __esm(() => {
 function breakLines(content, width) {
   return content.split(`
 `).flatMap((line) => wrapAnsi(line, width, { trim: false, hard: true }).split(`
-`).map((str) => str.trimEnd())).join(`
+`).map((str2) => str2.trimEnd())).join(`
 `);
 }
 function readlineWidth() {
@@ -61401,12 +62179,12 @@ var require_bom_handling = __commonJS((exports) => {
     this.encoder = encoder;
     this.addBOM = true;
   }
-  PrependBOMWrapper.prototype.write = function(str) {
+  PrependBOMWrapper.prototype.write = function(str2) {
     if (this.addBOM) {
-      str = BOMChar + str;
+      str2 = BOMChar + str2;
       this.addBOM = false;
     }
-    return this.encoder.write(str);
+    return this.encoder.write(str2);
   };
   PrependBOMWrapper.prototype.end = function() {
     return this.encoder.end();
@@ -61497,29 +62275,29 @@ var require_internal = __commonJS((exports, module) => {
   function InternalEncoder(options, codec2) {
     this.enc = codec2.enc;
   }
-  InternalEncoder.prototype.write = function(str) {
-    return Buffer2.from(str, this.enc);
+  InternalEncoder.prototype.write = function(str2) {
+    return Buffer2.from(str2, this.enc);
   };
   InternalEncoder.prototype.end = function() {};
   function InternalEncoderBase64(options, codec2) {
     this.prevStr = "";
   }
-  InternalEncoderBase64.prototype.write = function(str) {
-    str = this.prevStr + str;
-    var completeQuads = str.length - str.length % 4;
-    this.prevStr = str.slice(completeQuads);
-    str = str.slice(0, completeQuads);
-    return Buffer2.from(str, "base64");
+  InternalEncoderBase64.prototype.write = function(str2) {
+    str2 = this.prevStr + str2;
+    var completeQuads = str2.length - str2.length % 4;
+    this.prevStr = str2.slice(completeQuads);
+    str2 = str2.slice(0, completeQuads);
+    return Buffer2.from(str2, "base64");
   };
   InternalEncoderBase64.prototype.end = function() {
     return Buffer2.from(this.prevStr, "base64");
   };
   function InternalEncoderCesu8(options, codec2) {}
-  InternalEncoderCesu8.prototype.write = function(str) {
-    var buf = Buffer2.alloc(str.length * 3);
+  InternalEncoderCesu8.prototype.write = function(str2) {
+    var buf = Buffer2.alloc(str2.length * 3);
     var bufIdx = 0;
-    for (var i = 0;i < str.length; i++) {
-      var charCode = str.charCodeAt(i);
+    for (var i = 0;i < str2.length; i++) {
+      var charCode = str2.charCodeAt(i);
       if (charCode < 128) {
         buf[bufIdx++] = charCode;
       } else if (charCode < 2048) {
@@ -61599,25 +62377,25 @@ var require_internal = __commonJS((exports, module) => {
   function InternalEncoderUtf8(options, codec2) {
     this.highSurrogate = "";
   }
-  InternalEncoderUtf8.prototype.write = function(str) {
+  InternalEncoderUtf8.prototype.write = function(str2) {
     if (this.highSurrogate) {
-      str = this.highSurrogate + str;
+      str2 = this.highSurrogate + str2;
       this.highSurrogate = "";
     }
-    if (str.length > 0) {
-      var charCode = str.charCodeAt(str.length - 1);
+    if (str2.length > 0) {
+      var charCode = str2.charCodeAt(str2.length - 1);
       if (charCode >= 55296 && charCode < 56320) {
-        this.highSurrogate = str[str.length - 1];
-        str = str.slice(0, str.length - 1);
+        this.highSurrogate = str2[str2.length - 1];
+        str2 = str2.slice(0, str2.length - 1);
       }
     }
-    return Buffer2.from(str, this.enc);
+    return Buffer2.from(str2, this.enc);
   };
   InternalEncoderUtf8.prototype.end = function() {
     if (this.highSurrogate) {
-      var str = this.highSurrogate;
+      var str2 = this.highSurrogate;
       this.highSurrogate = "";
-      return Buffer2.from(str, this.enc);
+      return Buffer2.from(str2, this.enc);
     }
   };
 });
@@ -61641,8 +62419,8 @@ var require_utf32 = __commonJS((exports) => {
     this.isLE = codec2.isLE;
     this.highSurrogate = 0;
   }
-  Utf32Encoder.prototype.write = function(str) {
-    var src = Buffer2.from(str, "ucs2");
+  Utf32Encoder.prototype.write = function(str2) {
+    var src = Buffer2.from(str2, "ucs2");
     var dst = Buffer2.alloc(src.length * 2);
     var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;
     var offset = 0;
@@ -61763,8 +62541,8 @@ var require_utf32 = __commonJS((exports) => {
     }
     this.encoder = codec2.iconv.getEncoder(options.defaultEncoding || "utf-32le", options);
   }
-  Utf32AutoEncoder.prototype.write = function(str) {
-    return this.encoder.write(str);
+  Utf32AutoEncoder.prototype.write = function(str2) {
+    return this.encoder.write(str2);
   };
   Utf32AutoEncoder.prototype.end = function() {
     return this.encoder.end();
@@ -61865,8 +62643,8 @@ var require_utf16 = __commonJS((exports) => {
   Utf16BECodec.prototype.decoder = Utf16BEDecoder;
   Utf16BECodec.prototype.bomAware = true;
   function Utf16BEEncoder() {}
-  Utf16BEEncoder.prototype.write = function(str) {
-    var buf = Buffer2.from(str, "ucs2");
+  Utf16BEEncoder.prototype.write = function(str2) {
+    var buf = Buffer2.from(str2, "ucs2");
     for (var i = 0;i < buf.length; i += 2) {
       var tmp = buf[i];
       buf[i] = buf[i + 1];
@@ -61914,8 +62692,8 @@ var require_utf16 = __commonJS((exports) => {
     }
     this.encoder = codec2.iconv.getEncoder("utf-16le", options);
   }
-  Utf16Encoder.prototype.write = function(str) {
-    return this.encoder.write(str);
+  Utf16Encoder.prototype.write = function(str2) {
+    return this.encoder.write(str2);
   };
   Utf16Encoder.prototype.end = function() {
     return this.encoder.end();
@@ -62014,8 +62792,8 @@ var require_utf7 = __commonJS((exports) => {
   function Utf7Encoder(options, codec2) {
     this.iconv = codec2.iconv;
   }
-  Utf7Encoder.prototype.write = function(str) {
-    return Buffer2.from(str.replace(nonDirectChars, function(chunk) {
+  Utf7Encoder.prototype.write = function(str2) {
+    return Buffer2.from(str2.replace(nonDirectChars, function(chunk) {
       return "+" + (chunk === "+" ? "" : this.iconv.encode(chunk, "utf16-be").toString("base64").replace(/=+$/, "")) + "-";
     }.bind(this)));
   };
@@ -62098,14 +62876,14 @@ var require_utf7 = __commonJS((exports) => {
     this.base64Accum = Buffer2.alloc(6);
     this.base64AccumIdx = 0;
   }
-  Utf7IMAPEncoder.prototype.write = function(str) {
+  Utf7IMAPEncoder.prototype.write = function(str2) {
     var inBase64 = this.inBase64;
     var base64Accum = this.base64Accum;
     var base64AccumIdx = this.base64AccumIdx;
-    var buf = Buffer2.alloc(str.length * 5 + 10);
+    var buf = Buffer2.alloc(str2.length * 5 + 10);
     var bufIdx = 0;
-    for (var i2 = 0;i2 < str.length; i2++) {
-      var uChar = str.charCodeAt(i2);
+    for (var i2 = 0;i2 < str2.length; i2++) {
+      var uChar = str2.charCodeAt(i2);
       if (uChar >= 32 && uChar <= 126) {
         if (inBase64) {
           if (base64AccumIdx > 0) {
@@ -62243,10 +63021,10 @@ var require_sbcs_codec = __commonJS((exports) => {
   function SBCSEncoder(options, codec2) {
     this.encodeBuf = codec2.encodeBuf;
   }
-  SBCSEncoder.prototype.write = function(str) {
-    var buf = Buffer2.alloc(str.length);
-    for (var i = 0;i < str.length; i++) {
-      buf[i] = this.encodeBuf[str.charCodeAt(i)];
+  SBCSEncoder.prototype.write = function(str2) {
+    var buf = Buffer2.alloc(str2.length);
+    for (var i = 0;i < str2.length; i++) {
+      buf[i] = this.encodeBuf[str2.charCodeAt(i)];
     }
     return buf;
   };
@@ -63115,8 +63893,8 @@ var require_dbcs_codec = __commonJS((exports) => {
     this.defaultCharSingleByte = codec2.defCharSB;
     this.gb18030 = codec2.gb18030;
   }
-  DBCSEncoder.prototype.write = function(str) {
-    var newBuf = Buffer2.alloc(str.length * (this.gb18030 ? 4 : 3));
+  DBCSEncoder.prototype.write = function(str2) {
+    var newBuf = Buffer2.alloc(str2.length * (this.gb18030 ? 4 : 3));
     var leadSurrogate = this.leadSurrogate;
     var seqObj = this.seqObj;
     var nextChar = -1;
@@ -63124,9 +63902,9 @@ var require_dbcs_codec = __commonJS((exports) => {
     var j = 0;
     while (true) {
       if (nextChar === -1) {
-        if (i2 == str.length)
+        if (i2 == str2.length)
           break;
-        var uCode = str.charCodeAt(i2++);
+        var uCode = str2.charCodeAt(i2++);
       } else {
         var uCode = nextChar;
         nextChar = -1;
@@ -64865,10 +65643,10 @@ var require_lib3 = __commonJS((exports, module) => {
   iconv.encodings = null;
   iconv.defaultCharUnicode = "\uFFFD";
   iconv.defaultCharSingleByte = "?";
-  iconv.encode = function encode3(str, encoding, options) {
-    str = "" + (str || "");
+  iconv.encode = function encode3(str2, encoding, options) {
+    str2 = "" + (str2 || "");
     var encoder = iconv.getEncoder(encoding, options);
-    var res = encoder.write(str);
+    var res = encoder.write(str2);
     var trail = encoder.end();
     return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res;
   };
@@ -65033,7 +65811,7 @@ var init_RemoveFileError = __esm(() => {
 
 // ../../node_modules/.bun/@inquirer+external-editor@2.0.1+04f2146be16c61ef/node_modules/@inquirer/external-editor/dist/index.js
 import { spawn as spawn4, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync24, unlinkSync as unlinkSync5, writeFileSync as writeFileSync16 } from "fs";
+import { readFileSync as readFileSync26, unlinkSync as unlinkSync6, writeFileSync as writeFileSync17 } from "fs";
 import path from "path";
 import os from "os";
 import { randomUUID as randomUUID5 } from "crypto";
@@ -65057,12 +65835,12 @@ function sanitizeAffix(affix) {
     return "";
   return affix.replace(/[^a-zA-Z0-9_.-]/g, "_");
 }
-function splitStringBySpace(str) {
+function splitStringBySpace(str2) {
   const pieces = [];
   let currentString = "";
-  for (let strIndex = 0;strIndex < str.length; strIndex++) {
-    const currentLetter = str.charAt(strIndex);
-    if (strIndex > 0 && currentLetter === " " && str[strIndex - 1] !== "\\" && currentString.length > 0) {
+  for (let strIndex = 0;strIndex < str2.length; strIndex++) {
+    const currentLetter = str2.charAt(strIndex);
+    if (strIndex > 0 && currentLetter === " " && str2[strIndex - 1] !== "\\" && currentString.length > 0) {
       pieces.push(currentString);
       currentString = "";
     } else {
@@ -65142,14 +65920,14 @@ class ExternalEditor {
       if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
         opt.mode = this.fileOptions.mode;
       }
-      writeFileSync16(this.tempFile, this.text, opt);
+      writeFileSync17(this.tempFile, this.text, opt);
     } catch (createFileError) {
       throw new CreateFileError(createFileError);
     }
   }
   readTemporaryFile() {
     try {
-      const tempFileBuffer = readFileSync24(this.tempFile);
+      const tempFileBuffer = readFileSync26(this.tempFile);
       if (tempFileBuffer.length === 0) {
         this.text = "";
       } else {
@@ -65165,7 +65943,7 @@ class ExternalEditor {
   }
   removeTemporaryFile() {
     try {
-      unlinkSync5(this.tempFile);
+      unlinkSync6(this.tempFile);
     } catch (removeFileError) {
       throw new RemoveFileError(removeFileError);
     }
@@ -66130,9 +66908,9 @@ var init_dist16 = __esm(() => {
 
 // src/auth/antigravity-oauth.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync24, unlinkSync as unlinkSync6 } from "fs";
-import { homedir as homedir28 } from "os";
-import { join as join32 } from "path";
+import { existsSync as existsSync26, unlinkSync as unlinkSync7 } from "fs";
+import { homedir as homedir30 } from "os";
+import { join as join34 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -66253,9 +67031,9 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join32(homedir28(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
-      if (existsSync24(tokenFile))
-        unlinkSync6(tokenFile);
+      const tokenFile = join34(homedir30(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      if (existsSync26(tokenFile))
+        unlinkSync7(tokenFile);
     } catch {}
     log("[AntigravityOAuth] Antigravity session cleared (keychain + agy token file)");
   }
@@ -66353,6 +67131,7 @@ var init_auth_commands = __esm(() => {
   init_antigravity_oauth();
   init_antigravity_token();
   init_codex_oauth();
+  init_grok_oauth();
   init_kimi_oauth();
   init_oauth_registry();
   AUTH_PROVIDERS = [
@@ -66376,6 +67155,13 @@ var init_auth_commands = __esm(() => {
       prefix: "cx@",
       getInstance: () => CodexOAuth.getInstance(),
       registryKeys: ["openai-codex"]
+    },
+    {
+      name: "grok",
+      displayName: "Grok Build (SuperGrok / X Premium+)",
+      prefix: "gk@",
+      getInstance: () => GrokOAuth.getInstance(),
+      registryKeys: ["grok-subscription"]
     }
   ];
 });
@@ -68120,9 +68906,9 @@ function timelineBarCells(totalMs, maxTotalMs, barWidth) {
 function splitStageCells(ttfbMs, ttftMs, totalMs, barCells) {
   const net = Math.max(0, ttfbMs);
   const srv = Math.max(0, ttftMs - ttfbMs);
-  const str = Math.max(0, totalMs - ttftMs);
-  const durations = [net, srv, str];
-  const sum = net + srv + str;
+  const str2 = Math.max(0, totalMs - ttftMs);
+  const durations = [net, srv, str2];
+  const sum = net + srv + str2;
   if (barCells <= 0)
     return { network: 0, server: 0, streaming: 0 };
   if (sum <= 0) {
@@ -68731,11 +69517,11 @@ function renderCard(result, isLiveProbe, w, width, scales, directKeyVar) {
 function renderLegend(w) {
   const net = STAGE_BG_ANSI.network;
   const srv = STAGE_BG_ANSI.server;
-  const str = STAGE_BG_ANSI.streaming;
+  const str2 = STAGE_BG_ANSI.streaming;
   const netFg = hexToAnsiFg(STAGE_FG.network);
   const srvFg = hexToAnsiFg(STAGE_FG.server);
   const strFg = hexToAnsiFg(STAGE_FG.streaming);
-  w(`  ${pc.dim}Stages:${pc.reset}  ` + `${net}  ${ANSI_RESET}${netFg} network${pc.reset}   ` + `${srv}  ${ANSI_RESET}${srvFg} server${pc.reset}   ` + `${str}  ${ANSI_RESET}${strFg} streaming${pc.reset}   ` + `${pc.dim}\xB7\xB7 idle${pc.reset}
+  w(`  ${pc.dim}Stages:${pc.reset}  ` + `${net}  ${ANSI_RESET}${netFg} network${pc.reset}   ` + `${srv}  ${ANSI_RESET}${srvFg} server${pc.reset}   ` + `${str2}  ${ANSI_RESET}${strFg} streaming${pc.reset}   ` + `${pc.dim}\xB7\xB7 idle${pc.reset}
 `);
   w(`  ${pc.dim}bar length = total time, shared scale (slowest = full bar)  \xB7  ` + `tok/s scaled to fastest${pc.reset}
 `);
@@ -70371,22 +71157,22 @@ __export(exports_cli, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync25,
-  mkdirSync as mkdirSync14,
-  readFileSync as readFileSync25,
+  existsSync as existsSync27,
+  mkdirSync as mkdirSync15,
+  readFileSync as readFileSync27,
   readdirSync as readdirSync5,
-  unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync17
+  unlinkSync as unlinkSync8,
+  writeFileSync as writeFileSync18
 } from "fs";
-import { homedir as homedir29 } from "os";
-import { dirname as dirname11, join as join33 } from "path";
+import { homedir as homedir31 } from "os";
+import { dirname as dirname11, join as join35 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join33(homedir29(), ".claudish");
-  if (!existsSync25(cacheDir))
+  const cacheDir = join35(homedir31(), ".claudish");
+  if (!existsSync27(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
@@ -70394,7 +71180,7 @@ function clearAllModelCaches() {
     const files = readdirSync5(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync7(join33(cacheDir, file2));
+        unlinkSync8(join35(cacheDir, file2));
         cleared++;
       }
     }
@@ -70810,15 +71596,15 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join33(homedir29(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync25(markerFile)) {
+      const markerFile = join35(homedir31(), ".claudish", ".legacy-litellm-hint-shown");
+      if (!existsSync27(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
         }
         try {
-          mkdirSync14(dirname11(markerFile), { recursive: true });
-          writeFileSync17(markerFile, new Date().toISOString(), "utf-8");
+          mkdirSync15(dirname11(markerFile), { recursive: true });
+          writeFileSync18(markerFile, new Date().toISOString(), "utf-8");
         } catch {}
       }
     }
@@ -71888,8 +72674,8 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join33(__dirname3, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync25(guidePath, "utf-8");
+    const guidePath = join35(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync27(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
     console.error("Error reading AI Agent Guide:");
@@ -71905,19 +72691,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join33(cwd, ".claude");
-  const skillsDir = join33(claudeDir, "skills");
-  const claudishSkillDir = join33(skillsDir, "claudish-usage");
-  const skillFile = join33(claudishSkillDir, "SKILL.md");
-  if (existsSync25(skillFile)) {
+  const claudeDir = join35(cwd, ".claude");
+  const skillsDir = join35(claudeDir, "skills");
+  const claudishSkillDir = join35(skillsDir, "claudish-usage");
+  const skillFile = join35(claudishSkillDir, "SKILL.md");
+  if (existsSync27(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 = join33(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync25(sourceSkillPath)) {
+  const sourceSkillPath = join35(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync27(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -71926,16 +72712,16 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync25(claudeDir)) {
-      mkdirSync14(claudeDir, { recursive: true });
+    if (!existsSync27(claudeDir)) {
+      mkdirSync15(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync25(skillsDir)) {
-      mkdirSync14(skillsDir, { recursive: true });
+    if (!existsSync27(skillsDir)) {
+      mkdirSync15(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync25(claudishSkillDir)) {
-      mkdirSync14(claudishSkillDir, { recursive: true });
+    if (!existsSync27(claudishSkillDir)) {
+      mkdirSync15(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync2(sourceSkillPath, skillFile);
@@ -72020,33 +72806,33 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync26, mkdirSync as mkdirSync15, readFileSync as readFileSync26, unlinkSync as unlinkSync8, writeFileSync as writeFileSync18 } from "fs";
-import { homedir as homedir30, platform as platform2, tmpdir } from "os";
-import { join as join34 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync16, readFileSync as readFileSync28, unlinkSync as unlinkSync9, writeFileSync as writeFileSync19 } from "fs";
+import { homedir as homedir32, platform as platform2, tmpdir } from "os";
+import { join as join36 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join34(homedir30(), "AppData", "Local");
-    cacheDir = join34(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join36(homedir32(), "AppData", "Local");
+    cacheDir = join36(localAppData, "claudish");
   } else {
-    cacheDir = join34(homedir30(), ".cache", "claudish");
+    cacheDir = join36(homedir32(), ".cache", "claudish");
   }
   try {
-    if (!existsSync26(cacheDir)) {
-      mkdirSync15(cacheDir, { recursive: true });
+    if (!existsSync28(cacheDir)) {
+      mkdirSync16(cacheDir, { recursive: true });
     }
-    return join34(cacheDir, "update-check.json");
+    return join36(cacheDir, "update-check.json");
   } catch {
-    return join34(tmpdir(), "claudish-update-check.json");
+    return join36(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync26(cachePath)) {
+    if (!existsSync28(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync26(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync28(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -72059,7 +72845,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync18(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync19(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache2) {
@@ -72069,8 +72855,8 @@ function isCacheValid(cache2) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync26(cachePath)) {
-      unlinkSync8(cachePath);
+    if (existsSync28(cachePath)) {
+      unlinkSync9(cachePath);
     }
   } catch {}
 }
@@ -72954,15 +73740,15 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync27, writeFileSync as writeFileSync19 } from "fs";
-import { homedir as homedir31 } from "os";
-import { dirname as dirname12, join as join35 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync29, writeFileSync as writeFileSync20 } from "fs";
+import { homedir as homedir33 } from "os";
+import { dirname as dirname12, join as join37 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
-  if (!existsSync27(path2))
+  if (!existsSync29(path2))
     return null;
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync27(path2, "utf-8"));
+    raw2 = JSON.parse(readFileSync29(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -72971,8 +73757,8 @@ function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   return raw2;
 }
 function writeProbeModelsCache(data, path2 = PROBE_MODELS_CACHE_PATH) {
-  mkdirSync16(dirname12(path2), { recursive: true });
-  writeFileSync19(path2, JSON.stringify(data), "utf-8");
+  mkdirSync17(dirname12(path2), { recursive: true });
+  writeFileSync20(path2, JSON.stringify(data), "utf-8");
 }
 function isCacheFresh(data, ttlMs = CACHE_TTL_MS4) {
   if (!data?.generatedAt)
@@ -73091,7 +73877,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 = join35(homedir31(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join37(homedir33(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -79444,18 +80230,18 @@ __export(exports_claude_runner, {
 });
 import { spawn as spawn5 } from "child_process";
 import {
-  closeSync as closeSync4,
-  existsSync as existsSync28,
-  mkdirSync as mkdirSync17,
-  openSync as openSync4,
-  readFileSync as readFileSync28,
+  closeSync as closeSync5,
+  existsSync as existsSync30,
+  mkdirSync as mkdirSync18,
+  openSync as openSync5,
+  readFileSync as readFileSync30,
   readdirSync as readdirSync6,
   statSync as statSync5,
-  unlinkSync as unlinkSync9,
-  writeFileSync as writeFileSync20
+  unlinkSync as unlinkSync10,
+  writeFileSync as writeFileSync21
 } from "fs";
-import { homedir as homedir32, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname13, join as join36 } from "path";
+import { homedir as homedir34, tmpdir as tmpdir2 } from "os";
+import { dirname as dirname13, join as join38 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -79490,14 +80276,14 @@ function isProxyAuthMode(config3) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join36(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join38(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
   }
   return "/etc/claude-code/managed-settings.json";
 }
-function managedSettingsForcesClaudeAi(readFile3 = readFileSync28) {
+function managedSettingsForcesClaudeAi(readFile3 = readFileSync30) {
   try {
     const raw2 = readFile3(managedSettingsPath(), "utf-8");
     const parsed = JSON.parse(raw2);
@@ -79511,9 +80297,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join36(homeDir, ".claudish");
+  const claudishDir = join38(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join36(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join38(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -79640,13 +80426,13 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync20(scriptPath, script, "utf-8");
+  writeFileSync21(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function initializeTokenFile(tokenFilePath) {
   try {
-    mkdirSync17(dirname13(tokenFilePath), { recursive: true });
-    writeFileSync20(tokenFilePath, JSON.stringify({
+    mkdirSync18(dirname13(tokenFilePath), { recursive: true });
+    writeFileSync21(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
       total_tokens: 0,
@@ -79677,11 +80463,11 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join36(dir, name);
+    const full = join38(dir, name);
     try {
       if (statSync5(full).mtimeMs >= cutoff)
         continue;
-      unlinkSync9(full);
+      unlinkSync10(full);
       removed++;
     } catch {}
   }
@@ -79694,7 +80480,7 @@ function parseSettingsArg(value) {
   if (value.trimStart().startsWith("{")) {
     return JSON.parse(value);
   }
-  return JSON.parse(readFileSync28(value, "utf-8"));
+  return JSON.parse(readFileSync30(value, "utf-8"));
 }
 function parseSettingsArgSafe(value) {
   try {
@@ -79706,13 +80492,13 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join36(homedir32(), ".claude", "settings.json"),
-    join36(cwd, ".claude", "settings.json"),
-    join36(cwd, ".claude", "settings.local.json")
+    join38(homedir34(), ".claude", "settings.json"),
+    join38(cwd, ".claude", "settings.json"),
+    join38(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
-  const sources = userSettingsFileCandidates(cwd).filter((file2) => existsSync28(file2));
+  const sources = userSettingsFileCandidates(cwd).filter((file2) => existsSync30(file2));
   const idx = claudeArgs.indexOf("--settings");
   const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
   if (settingsArg)
@@ -79749,13 +80535,13 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join36(homeDir, ".claudish");
+  const claudishDir = join38(homeDir, ".claudish");
   try {
-    mkdirSync17(claudishDir, { recursive: true });
+    mkdirSync18(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join36(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join36(claudishDir, `tokens-${port}.json`);
+  const tempPath = join38(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join38(claudishDir, `tokens-${port}.json`);
   cleanupStaleTokenFiles(claudishDir);
   initializeTokenFile(tokenFilePath);
   let statusCommand;
@@ -79788,7 +80574,7 @@ function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLi
     padding: 0
   };
   const settings = buildClaudishSettingsOverlay(statusLine, proxyAuthMode);
-  writeFileSync20(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync21(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine, tokenFilePath };
 }
 function buildClaudishSettingsOverlay(statusLine, proxyAuthMode) {
@@ -79813,7 +80599,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine, proxy
     if (proxyAuthMode && !("forceLoginMethod" in userSettings)) {
       userSettings.forceLoginMethod = "console";
     }
-    writeFileSync20(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync21(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config3.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -80005,8 +80791,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 = homedir32();
-    const localPath = isWindows2() ? join36(home, ".claude", "local", "claude.exe") : join36(home, ".claude", "local", "claude");
+    const home = homedir34();
+    const localPath = isWindows2() ? join38(home, ".claude", "local", "claude.exe") : join38(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -80017,11 +80803,11 @@ Or set CLAUDE_PATH to your custom installation:`);
   const childWantsTty = config3.interactive && !process.stdout.isTTY && Boolean(process.stdin.isTTY);
   if (childWantsTty) {
     try {
-      const fd = openSync4("/dev/fd/0", "r+");
+      const fd = openSync5("/dev/fd/0", "r+");
       if (isatty(fd)) {
         ttyFd = fd;
       } else {
-        closeSync4(fd);
+        closeSync5(fd);
       }
     } catch {
       ttyFd = undefined;
@@ -80044,7 +80830,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     const fdToClose = ttyFd;
     proc.on("spawn", () => {
       try {
-        closeSync4(fdToClose);
+        closeSync5(fdToClose);
       } catch {}
     });
   }
@@ -80057,7 +80843,7 @@ Or set CLAUDE_PATH to your custom installation:`);
   });
   releaseTerminalIsolation();
   try {
-    unlinkSync9(tempSettingsPath);
+    unlinkSync10(tempSettingsPath);
   } catch {}
   return exitCode;
 }
@@ -80077,7 +80863,7 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
         } catch {}
       }
       try {
-        unlinkSync9(tempSettingsPath);
+        unlinkSync10(tempSettingsPath);
       } catch {}
       process.exit(0);
     });
@@ -80086,23 +80872,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync28(process.env.CLAUDE_PATH)) {
+    if (existsSync30(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir32();
-  const localPath = isWindows3 ? join36(home, ".claude", "local", "claude.exe") : join36(home, ".claude", "local", "claude");
-  if (existsSync28(localPath)) {
+  const home = homedir34();
+  const localPath = isWindows3 ? join38(home, ".claude", "local", "claude.exe") : join38(home, ".claude", "local", "claude");
+  if (existsSync30(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join36(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join36(home, ".npm-global", "claude.cmd"),
-      join36(home, "node_modules", ".bin", "claude.cmd")
+      join38(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join38(home, ".npm-global", "claude.cmd"),
+      join38(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
-      if (existsSync28(path2)) {
+      if (existsSync30(path2)) {
         return path2;
       }
     }
@@ -80110,14 +80896,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join36(home, ".npm-global/bin/claude"),
-      join36(home, ".local/bin/claude"),
-      join36(home, "node_modules/.bin/claude"),
+      join38(home, ".npm-global/bin/claude"),
+      join38(home, ".local/bin/claude"),
+      join38(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join36(home, "../usr/bin/claude")
+      join38(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync28(path2)) {
+      if (existsSync30(path2)) {
         return path2;
       }
     }
@@ -80176,18 +80962,18 @@ __export(exports_diag_output, {
   NullDiagOutput: () => NullDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync18, unlinkSync as unlinkSync10, writeFileSync as writeFileSync21 } from "fs";
-import { homedir as homedir33 } from "os";
-import { join as join37 } from "path";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync19, unlinkSync as unlinkSync11, writeFileSync as writeFileSync22 } from "fs";
+import { homedir as homedir35 } from "os";
+import { join as join39 } from "path";
 function getClaudishDir() {
-  const dir = join37(homedir33(), ".claudish");
+  const dir = join39(homedir35(), ".claudish");
   try {
-    mkdirSync18(dir, { recursive: true });
+    mkdirSync19(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join37(getClaudishDir(), `diag-${process.pid}.log`);
+  return join39(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -80196,7 +80982,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync21(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync22(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -80215,7 +81001,7 @@ class LogFileDiagOutput {
       this.stream.end();
     } catch {}
     try {
-      unlinkSync10(this.logPath);
+      unlinkSync11(this.logPath);
     } catch {}
   }
   getLogPath() {
@@ -80783,9 +81569,9 @@ __export(exports_session_discovery, {
   ACTIVE_WINDOW_MS: () => ACTIVE_WINDOW_MS
 });
 import { execFile, execFileSync as execFileSync2 } from "child_process";
-import { closeSync as closeSync5, openSync as openSync5, readSync, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
-import { homedir as homedir34 } from "os";
-import { basename, join as join38 } from "path";
+import { closeSync as closeSync6, openSync as openSync6, readSync, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { homedir as homedir36 } from "os";
+import { basename, join as join40 } from "path";
 function slugForPath(absPath) {
   return absPath.replace(/[/.]/g, "-");
 }
@@ -80834,7 +81620,7 @@ function projectDirs() {
   }
 }
 function sessionsIn(dirName) {
-  const dir = join38(PROJECTS_DIR, dirName);
+  const dir = join40(PROJECTS_DIR, dirName);
   let names;
   try {
     names = readdirSync7(dir).filter((n) => n.endsWith(".jsonl"));
@@ -80843,7 +81629,7 @@ function sessionsIn(dirName) {
   }
   const rows = [];
   for (const n of names) {
-    const file2 = join38(dir, n);
+    const file2 = join40(dir, n);
     try {
       const st = statSync6(file2);
       if (st.size === 0)
@@ -81023,7 +81809,7 @@ function readChunk(file2, pos, len) {
     return "";
   let fd = null;
   try {
-    fd = openSync5(file2, "r");
+    fd = openSync6(file2, "r");
     const buf = Buffer.allocUnsafe(len);
     const n = readSync(fd, buf, 0, len, pos);
     return buf.subarray(0, n).toString("utf-8");
@@ -81032,7 +81818,7 @@ function readChunk(file2, pos, len) {
   } finally {
     if (fd !== null) {
       try {
-        closeSync5(fd);
+        closeSync6(fd);
       } catch {}
     }
   }
@@ -81202,7 +81988,7 @@ function findLatestSessionId(cwd = process.cwd(), sinceMs = 0) {
 }
 var ENTRYPOINT_BYTES = 8192, PROJECTS_DIR, ACTIVE_WINDOW_MS = 120000, HEAD_BYTES, TAIL_BYTES, HARNESS_ENVELOPES, DEEP_TAIL_BYTES, RECENT_AI_TURNS = 5, RECENT_USER_TURNS = 1;
 var init_session_discovery = __esm(() => {
-  PROJECTS_DIR = join38(homedir34(), ".claude", "projects");
+  PROJECTS_DIR = join40(homedir36(), ".claude", "projects");
   HEAD_BYTES = 64 * 1024;
   TAIL_BYTES = 128 * 1024;
   HARNESS_ENVELOPES = [
@@ -81215,7 +82001,7 @@ var init_session_discovery = __esm(() => {
 });
 
 // src/session/conversation.ts
-import { closeSync as closeSync6, openSync as openSync6, readSync as readSync2, statSync as statSync7 } from "fs";
+import { closeSync as closeSync7, openSync as openSync7, readSync as readSync2, statSync as statSync7 } from "fs";
 import { StringDecoder } from "string_decoder";
 function looksLikeTurn(line) {
   const assistant = line.includes('"type":"assistant"');
@@ -81271,7 +82057,7 @@ function readConversation(file2, opts = {}) {
   let fd = null;
   try {
     const size = statSync7(file2).size;
-    fd = openSync6(file2, "r");
+    fd = openSync7(file2, "r");
     const buf = Buffer.allocUnsafe(chunkBytes);
     const decoder = new StringDecoder("utf-8");
     let pending = "";
@@ -81327,7 +82113,7 @@ function readConversation(file2, opts = {}) {
   } catch {} finally {
     if (fd !== null) {
       try {
-        closeSync6(fd);
+        closeSync7(fd);
       } catch {}
     }
   }
@@ -82894,16 +83680,16 @@ __export(exports_session_stats, {
   readSessionStats: () => readSessionStats,
   computeSavings: () => computeSavings
 });
-import { readFileSync as readFileSync29 } from "fs";
-import { homedir as homedir35 } from "os";
-import { join as join39 } from "path";
+import { readFileSync as readFileSync31 } from "fs";
+import { homedir as homedir37 } from "os";
+import { join as join41 } from "path";
 function tokenFilePath(port) {
-  return process.env.CLAUDISH_TOKEN_FILE || join39(homedir35(), ".claudish", `tokens-${port}.json`);
+  return process.env.CLAUDISH_TOKEN_FILE || join41(homedir37(), ".claudish", `tokens-${port}.json`);
 }
 function readSessionStats(port, opts) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync29(tokenFilePath(port), "utf-8"));
+    raw2 = JSON.parse(readFileSync31(tokenFilePath(port), "utf-8"));
   } catch {
     return null;
   }
@@ -83243,8 +84029,8 @@ var init_session_summary = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync29, readFileSync as readFileSync30 } from "fs";
-import { join as join40, resolve as resolve5 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync32 } from "fs";
+import { join as join42, resolve as resolve5 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -83343,7 +84129,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: resolve5,
-    exists: existsSync29
+    exists: existsSync31
   });
   if (plan.kind === "none")
     return;
@@ -83498,14 +84284,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync30(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync32(cliConfig.inputFile, "utf-8");
       }
       if (!prompt.trim()) {
         console.error("Error: --team requires a prompt (positional args or -f <file>)");
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join40(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join42(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);
@@ -83515,9 +84301,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join40(sessionPath, `response-${anonId}.md`);
+          const responsePath = join42(sessionPath, `response-${anonId}.md`);
           try {
-            const raw2 = readFileSync30(responsePath, "utf-8").trim();
+            const raw2 = readFileSync32(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw2);
             } catch {