claudish 14.10.2 → 14.11.0

package/dist/index.js

@@ -5491,7 +5491,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "14.10.2";
+var VERSION = "14.11.0";
 
 // src/redact.ts
 function isPlaceholder(value) {
@@ -26267,6 +26267,7 @@ var init_antigravity_token = __esm(() => {
 var exports_antigravity_user = {};
 __export(exports_antigravity_user, {
   antigravityHost: () => antigravityHost,
+  antigravityUserAgentFor: () => antigravityUserAgentFor,
   buildAntigravityUserAgent: () => buildAntigravityUserAgent,
   fetchAntigravityAvailableModelsRaw: () => fetchAntigravityAvailableModelsRaw,
   getAntigravityTierDisplayName: () => getAntigravityTierDisplayName,
@@ -26299,6 +26300,9 @@ function antigravityClientVersion() {
 function userAgentFor(version) {
   return `antigravity/cli/${version} (aidev_client; os_type=${process.platform}; arch=${process.arch}; auth_method=consumer)`;
 }
+function antigravityUserAgentFor(version) {
+  return userAgentFor(version);
+}
 function buildAntigravityUserAgent() {
   return userAgentFor(antigravityClientVersion());
 }
@@ -90429,6 +90433,10 @@ ${h("SUBCOMMANDS")}
   ${green("claudish subscription models antigravity")} ${yellow("--raw --json")}
                                           Print the raw Antigravity fetchAvailableModels
                                           ${dim("body as one JSON line (for models-index)")}
+  ${green("claudish subscription probe antigravity")} ${yellow("--model <id> --request-file <path> --raw --json")}
+                                          Send the file's Gemini request once through the
+                                          Antigravity login (generateContent, no retry, model
+                                          ${dim("id unchanged); print the raw answer as one JSON line")}
   ${green("claudish update")}                        Check for updates and install the latest version
 
   ${bold("Profiles:")}
@@ -104456,68 +104464,20 @@ var init_keychain_command = __esm(() => {
   VALUE_FLAGS = new Set(["--config", "--from", "--only"]);
 });
 
-// src/subscription-models-command.ts
-var exports_subscription_models_command = {};
-__export(exports_subscription_models_command, {
-  EXIT: () => EXIT,
-  FAILURE_CODES: () => FAILURE_CODES,
-  INTERNAL_ERROR_MESSAGE: () => INTERNAL_ERROR_MESSAGE,
-  SECRET_GUARD_MESSAGE: () => SECRET_GUARD_MESSAGE,
-  SUBSCRIPTION_MODELS_USAGE: () => SUBSCRIPTION_MODELS_USAGE,
-  SUBSCRIPTION_MODEL_LIST_SCHEMA: () => SUBSCRIPTION_MODEL_LIST_SCHEMA,
-  defaultSubscriptionModelsDeps: () => defaultSubscriptionModelsDeps,
-  exitCodeFor: () => exitCodeFor,
-  parseSubscriptionModelsArgs: () => parseSubscriptionModelsArgs,
-  reportSubscriptionInternalError: () => reportSubscriptionInternalError,
-  runAntigravityRawModelList: () => runAntigravityRawModelList,
-  subscriptionModelsCommand: () => subscriptionModelsCommand
-});
-function exitCodeFor(failure) {
-  if (failure.class === "internal")
-    return failure.code === "usage" ? EXIT.usage : EXIT.internal;
-  return EXIT[failure.class];
-}
-function defaultSubscriptionModelsDeps() {
-  return {
-    platform: () => process.platform,
-    readStore: readAntigravityStoreClassified,
-    tokenDeps: defaultAntigravityTokenDeps,
-    now: () => Date.now(),
-    httpTimeoutMs: 30000,
-    keychainDeadlineMs: 1e4,
-    writeStdout: (line) => new Promise((resolve, reject) => {
-      process.stdout.write(line, (err) => err ? reject(err) : resolve());
-    }),
-    writeStderr: (line) => {
-      process.stderr.write(line);
-    }
-  };
-}
-function parseSubscriptionModelsArgs(argv) {
-  const positionals = argv.filter((a) => !a.startsWith("-"));
-  const flags = argv.filter((a) => a.startsWith("-"));
-  const positionalsOk = positionals.length === 2 && positionals[0] === "models" && positionals[1] === "antigravity";
-  const flagsOk = flags.length === 2 && flags.includes("--raw") && flags.includes("--json");
-  return positionalsOk && flagsOk ? { ok: true, provider: "antigravity" } : { ok: false };
+// src/subscription-antigravity-session.ts
+function newSecrets() {
+  return { values: new Set };
 }
 function addSecret(secrets, value) {
   if (typeof value === "string" && value.length > 0)
     secrets.values.add(value);
 }
-function buildEnvelope(facts, failure, body) {
-  return {
-    schema: SUBSCRIPTION_MODEL_LIST_SCHEMA,
-    ...facts.provider !== undefined ? { provider: facts.provider } : {},
-    claudishVersion: VERSION,
-    ...facts.fetchedAt !== undefined ? { fetchedAt: facts.fetchedAt } : {},
-    ...facts.sourceUrl !== undefined ? { sourceUrl: facts.sourceUrl } : {},
-    ...facts.clientVersion !== undefined ? { clientVersion: facts.clientVersion } : {},
-    ...facts.clientVersionSource !== undefined ? { clientVersionSource: facts.clientVersionSource } : {},
-    tokenRefreshed: facts.tokenRefreshed,
-    ...facts.httpStatus !== undefined ? { httpStatus: facts.httpStatus } : {},
-    ...failure ? { failure } : {},
-    ...body !== undefined ? { body } : {}
-  };
+function containsSecret(secrets, ...texts) {
+  for (const secret of secrets.values) {
+    if (texts.some((text) => text?.includes(secret)))
+      return true;
+  }
+  return false;
 }
 function failureOf2(cls, code, httpStatus) {
   return { class: cls, code, ...httpStatus !== undefined ? { httpStatus } : {} };
@@ -104532,6 +104492,19 @@ function stripUserinfo(url) {
     return url.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^@/]*@/i, "$1");
   }
 }
+async function raceTimeout(work, ms) {
+  let timer;
+  const timedOut = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(TIMED_OUT), ms);
+  });
+  work.catch(() => {});
+  try {
+    return await Promise.race([work, timedOut]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
 function storeReadFailure(read) {
   switch (read.kind) {
     case "absent":
@@ -104574,29 +104547,171 @@ function loadCodeAssistFailure(err) {
     return failureOf2("mint_failed", "load_code_assist_no_project");
   return failureOf2("network", "load_code_assist_network_error");
 }
+async function obtainAccessToken(deps, facts, secrets, preRaw) {
+  const base = deps.tokenDeps();
+  let firstRead = true;
+  let refreshCalled = false;
+  let refreshOutcome = null;
+  const laterReads = [];
+  const observed = {
+    ...base,
+    readStore: () => {
+      if (firstRead) {
+        firstRead = false;
+        return preRaw;
+      }
+      const raw = base.readStore();
+      if (raw)
+        laterReads.push(raw);
+      return raw;
+    },
+    runAgyRefresh: () => {
+      refreshCalled = true;
+      facts.tokenRefreshed = true;
+      refreshOutcome = base.runAgyRefresh();
+      return refreshOutcome;
+    }
+  };
+  let accessToken;
+  try {
+    accessToken = await getValidAntigravityAccessToken(observed);
+  } catch {
+    return { ok: false, failure: tokenFailure(refreshCalled, refreshOutcome) };
+  }
+  addSecret(secrets, accessToken);
+  for (const raw of [preRaw, ...laterReads]) {
+    addSecret(secrets, raw);
+    addSecret(secrets, readSharedAntigravityToken({ ...base, readStore: () => raw })?.refresh_token);
+  }
+  return { ok: true, accessToken };
+}
+async function establishAntigravitySession(deps, secrets, facts) {
+  if (deps.platform() !== "darwin") {
+    return { ok: false, failure: failureOf2("credential_missing", "platform_unsupported") };
+  }
+  const read = await deps.readStore(deps.keychainDeadlineMs);
+  if (read.kind !== "present")
+    return { ok: false, failure: storeReadFailure(read) };
+  addSecret(secrets, read.raw);
+  const token = await obtainAccessToken(deps, facts, secrets, read.raw);
+  if (!token.ok)
+    return token;
+  const version = resolveAntigravityClientVersion();
+  facts.clientVersion = version.version;
+  facts.clientVersionSource = version.source;
+  let projectId;
+  let tierId;
+  try {
+    const setup = await raceTimeout(setupAntigravityUser(token.accessToken), deps.httpTimeoutMs);
+    if (setup === TIMED_OUT) {
+      return { ok: false, failure: failureOf2("network", "load_code_assist_timeout") };
+    }
+    projectId = setup.projectId;
+    tierId = setup.tierId;
+  } catch (err) {
+    return { ok: false, failure: loadCodeAssistFailure(err) };
+  }
+  addSecret(secrets, projectId);
+  return { ok: true, accessToken: token.accessToken, projectId, tierId };
+}
+var SESSION_FAILURE_CODES, TIMED_OUT;
+var init_subscription_antigravity_session = __esm(() => {
+  init_antigravity_token();
+  init_antigravity_user();
+  SESSION_FAILURE_CODES = {
+    credential_missing: ["platform_unsupported", "keychain_item_absent", "token_unparseable"],
+    keychain_locked: ["keychain_locked", "keychain_read_timeout", "keychain_read_failed"],
+    mint_failed: [
+      "agy_missing",
+      "agy_refresh_failed",
+      "agy_refresh_timeout",
+      "agy_refresh_no_valid_token",
+      "load_code_assist_4xx",
+      "load_code_assist_no_project",
+      "load_code_assist_bad_body"
+    ],
+    network: [
+      "load_code_assist_network_error",
+      "load_code_assist_429",
+      "load_code_assist_5xx",
+      "load_code_assist_timeout"
+    ]
+  };
+  TIMED_OUT = Symbol("timed-out");
+});
+
+// src/subscription-models-command.ts
+var exports_subscription_models_command = {};
+__export(exports_subscription_models_command, {
+  EXIT: () => EXIT,
+  FAILURE_CODES: () => FAILURE_CODES,
+  INTERNAL_ERROR_MESSAGE: () => INTERNAL_ERROR_MESSAGE,
+  SECRET_GUARD_MESSAGE: () => SECRET_GUARD_MESSAGE,
+  SUBSCRIPTION_MODELS_USAGE: () => SUBSCRIPTION_MODELS_USAGE,
+  SUBSCRIPTION_MODEL_LIST_SCHEMA: () => SUBSCRIPTION_MODEL_LIST_SCHEMA,
+  defaultSubscriptionModelsDeps: () => defaultSubscriptionModelsDeps,
+  exitCodeFor: () => exitCodeFor,
+  parseSubscriptionModelsArgs: () => parseSubscriptionModelsArgs,
+  reportSubscriptionInternalError: () => reportSubscriptionInternalError,
+  runAntigravityRawModelList: () => runAntigravityRawModelList,
+  subscriptionModelsCommand: () => subscriptionModelsCommand
+});
+function exitCodeFor(failure) {
+  if (failure.class === "internal")
+    return failure.code === "usage" ? EXIT.usage : EXIT.internal;
+  return EXIT[failure.class];
+}
+function defaultSubscriptionModelsDeps() {
+  return {
+    platform: () => process.platform,
+    readStore: readAntigravityStoreClassified,
+    tokenDeps: defaultAntigravityTokenDeps,
+    now: () => Date.now(),
+    httpTimeoutMs: 30000,
+    keychainDeadlineMs: 1e4,
+    writeStdout: (line) => new Promise((resolve, reject) => {
+      process.stdout.write(line, (err) => err ? reject(err) : resolve());
+    }),
+    writeStderr: (line) => {
+      process.stderr.write(line);
+    }
+  };
+}
+function parseSubscriptionModelsArgs(argv) {
+  const positionals = argv.filter((a) => !a.startsWith("-"));
+  const flags = argv.filter((a) => a.startsWith("-"));
+  const positionalsOk = positionals.length === 2 && positionals[0] === "models" && positionals[1] === "antigravity";
+  const flagsOk = flags.length === 2 && flags.includes("--raw") && flags.includes("--json");
+  return positionalsOk && flagsOk ? { ok: true, provider: "antigravity" } : { ok: false };
+}
+function buildEnvelope(facts, failure, body) {
+  return {
+    schema: SUBSCRIPTION_MODEL_LIST_SCHEMA,
+    ...facts.provider !== undefined ? { provider: facts.provider } : {},
+    claudishVersion: VERSION,
+    ...facts.fetchedAt !== undefined ? { fetchedAt: facts.fetchedAt } : {},
+    ...facts.sourceUrl !== undefined ? { sourceUrl: facts.sourceUrl } : {},
+    ...facts.clientVersion !== undefined ? { clientVersion: facts.clientVersion } : {},
+    ...facts.clientVersionSource !== undefined ? { clientVersionSource: facts.clientVersionSource } : {},
+    tokenRefreshed: facts.tokenRefreshed,
+    ...facts.httpStatus !== undefined ? { httpStatus: facts.httpStatus } : {},
+    ...failure ? { failure } : {},
+    ...body !== undefined ? { body } : {}
+  };
+}
+function failureOf3(cls, code, httpStatus) {
+  return failureOf2(cls, code, httpStatus);
+}
 function listFailure(value, status) {
   const models = value !== null && typeof value === "object" && !Array.isArray(value) ? value.models : undefined;
   if (models === null || typeof models !== "object" || Array.isArray(models)) {
-    return failureOf2("list_incomplete", "models_absent", status);
+    return failureOf3("list_incomplete", "models_absent", status);
   }
   if (Object.keys(models).length === 0) {
-    return failureOf2("list_incomplete", "models_empty", status);
+    return failureOf3("list_incomplete", "models_empty", status);
   }
   return null;
 }
-async function raceTimeout(work, ms) {
-  let timer;
-  const timedOut = new Promise((resolve) => {
-    timer = setTimeout(() => resolve(TIMED_OUT), ms);
-  });
-  work.catch(() => {});
-  try {
-    return await Promise.race([work, timedOut]);
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-}
 function fail(facts, failure) {
   return { envelope: buildEnvelope(facts, failure), exitCode: exitCodeFor(failure) };
 }
@@ -104604,20 +104719,13 @@ function lineOf(envelope) {
   return `${JSON.stringify(envelope)}
 `;
 }
-function containsSecret(secrets, ...texts) {
-  for (const secret of secrets.values) {
-    if (texts.some((text) => text?.includes(secret)))
-      return true;
-  }
-  return false;
-}
 function safeStderr(deps, line) {
   try {
     deps.writeStderr(line);
   } catch {}
 }
 async function writeInternalFailure(deps, facts, code, stderrLine, secrets) {
-  const failure = failureOf2("internal", code);
+  const failure = failureOf3("internal", code);
   safeStderr(deps, `${stderrLine}
 `);
   const line = lineOf(buildEnvelope(facts, failure));
@@ -104639,51 +104747,13 @@ async function reportSubscriptionInternalError(deps) {
   }
   return writeInternalFailure(resolved, { tokenRefreshed: false }, "internal_error", INTERNAL_ERROR_MESSAGE);
 }
-async function obtainAccessToken(deps, facts, secrets, preRaw) {
-  const base = deps.tokenDeps();
-  let firstRead = true;
-  let refreshCalled = false;
-  let refreshOutcome = null;
-  const laterReads = [];
-  const observed = {
-    ...base,
-    readStore: () => {
-      if (firstRead) {
-        firstRead = false;
-        return preRaw;
-      }
-      const raw = base.readStore();
-      if (raw)
-        laterReads.push(raw);
-      return raw;
-    },
-    runAgyRefresh: () => {
-      refreshCalled = true;
-      facts.tokenRefreshed = true;
-      refreshOutcome = base.runAgyRefresh();
-      return refreshOutcome;
-    }
-  };
-  let accessToken;
-  try {
-    accessToken = await getValidAntigravityAccessToken(observed);
-  } catch {
-    return { ok: false, result: fail(facts, tokenFailure(refreshCalled, refreshOutcome)) };
-  }
-  addSecret(secrets, accessToken);
-  for (const raw of [preRaw, ...laterReads]) {
-    addSecret(secrets, raw);
-    addSecret(secrets, readSharedAntigravityToken({ ...base, readStore: () => raw })?.refresh_token);
-  }
-  return { ok: true, accessToken };
-}
 function classifyAvailableModels(facts, raw, timedOut) {
   facts.sourceUrl = stripUserinfo(raw.url);
   facts.clientVersion = raw.clientVersion;
   facts.clientVersionSource = raw.clientVersionSource;
   const networkCode = timedOut ? "fetch_available_models_timeout" : "fetch_available_models_network_error";
   if (raw.kind === "unreachable")
-    return fail(facts, failureOf2("network", networkCode));
+    return fail(facts, failureOf3("network", networkCode));
   facts.fetchedAt = raw.fetchedAt;
   facts.httpStatus = raw.status;
   if (raw.status < 200 || raw.status >= 300) {
@@ -104701,39 +104771,20 @@ function classifyAvailableModels(facts, raw, timedOut) {
       };
     }
     case "not-json":
-      return fail(facts, failureOf2("list_incomplete", "body_not_json", raw.status));
+      return fail(facts, failureOf3("list_incomplete", "body_not_json", raw.status));
     default:
-      return fail(facts, failureOf2("network", networkCode, raw.status));
+      return fail(facts, failureOf3("network", networkCode, raw.status));
   }
 }
 async function determine(deps, secrets, facts) {
-  if (deps.platform() !== "darwin") {
-    return fail(facts, failureOf2("credential_missing", "platform_unsupported"));
-  }
-  const read = await deps.readStore(deps.keychainDeadlineMs);
-  if (read.kind !== "present")
-    return fail(facts, storeReadFailure(read));
-  addSecret(secrets, read.raw);
-  const token = await obtainAccessToken(deps, facts, secrets, read.raw);
-  if (!token.ok)
-    return token.result;
-  const version = resolveAntigravityClientVersion();
-  facts.clientVersion = version.version;
-  facts.clientVersionSource = version.source;
-  let projectId;
-  try {
-    const setup = await raceTimeout(setupAntigravityUser(token.accessToken), deps.httpTimeoutMs);
-    if (setup === TIMED_OUT)
-      return fail(facts, failureOf2("network", "load_code_assist_timeout"));
-    projectId = setup.projectId;
-  } catch (err) {
-    return fail(facts, loadCodeAssistFailure(err));
-  }
-  addSecret(secrets, projectId);
+  const session = await establishAntigravitySession(deps, secrets, facts);
+  if (!session.ok)
+    return fail(facts, session.failure);
+  const { accessToken, projectId } = session;
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), deps.httpTimeoutMs);
   try {
-    const raw = await fetchAntigravityAvailableModelsRaw(token.accessToken, projectId, {
+    const raw = await fetchAntigravityAvailableModelsRaw(accessToken, projectId, {
       signal: controller.signal,
       now: deps.now
     });
@@ -104743,7 +104794,7 @@ async function determine(deps, secrets, facts) {
   }
 }
 async function runAntigravityRawModelList(deps) {
-  const secrets = { values: new Set };
+  const secrets = newSecrets();
   const facts = { provider: "antigravity", tokenRefreshed: false };
   let line;
   let exitCode;
@@ -104774,27 +104825,17 @@ async function subscriptionModelsCommand(argv, deps = defaultSubscriptionModelsD
   }
   return runAntigravityRawModelList(deps);
 }
-var SUBSCRIPTION_MODEL_LIST_SCHEMA = "claudish.subscription-model-list.v1", FAILURE_CODES, EXIT, SUBSCRIPTION_MODELS_USAGE = "usage: claudish subscription models antigravity --raw --json", SECRET_GUARD_MESSAGE = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE = "[claudish subscription] internal error", TIMED_OUT;
+var SUBSCRIPTION_MODEL_LIST_SCHEMA = "claudish.subscription-model-list.v1", FAILURE_CODES, EXIT, SUBSCRIPTION_MODELS_USAGE = "usage: claudish subscription models antigravity --raw --json", SECRET_GUARD_MESSAGE = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE = "[claudish subscription] internal error";
 var init_subscription_models_command = __esm(() => {
   init_antigravity_token();
   init_antigravity_user();
+  init_subscription_antigravity_session();
   FAILURE_CODES = {
-    credential_missing: ["platform_unsupported", "keychain_item_absent", "token_unparseable"],
-    keychain_locked: ["keychain_locked", "keychain_read_timeout", "keychain_read_failed"],
-    mint_failed: [
-      "agy_missing",
-      "agy_refresh_failed",
-      "agy_refresh_timeout",
-      "agy_refresh_no_valid_token",
-      "load_code_assist_4xx",
-      "load_code_assist_no_project",
-      "load_code_assist_bad_body"
-    ],
+    credential_missing: SESSION_FAILURE_CODES.credential_missing,
+    keychain_locked: SESSION_FAILURE_CODES.keychain_locked,
+    mint_failed: SESSION_FAILURE_CODES.mint_failed,
     network: [
-      "load_code_assist_network_error",
-      "load_code_assist_429",
-      "load_code_assist_5xx",
-      "load_code_assist_timeout",
+      ...SESSION_FAILURE_CODES.network,
       "fetch_available_models_network_error",
       "fetch_available_models_timeout"
     ],
@@ -104811,7 +104852,399 @@ var init_subscription_models_command = __esm(() => {
     network: 6,
     list_incomplete: 7
   };
-  TIMED_OUT = Symbol("timed-out");
+});
+
+// src/subscription-dispatch.ts
+function isSubscriptionProbeArgv(argv) {
+  for (let i = 0;i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--model" || token === "--request-file") {
+      if (argv[i + 1] !== undefined && !argv[i + 1].startsWith("-"))
+        i++;
+    } else if (!token.startsWith("-")) {
+      return token === "probe";
+    }
+  }
+  return false;
+}
+function probeLoadFailureLine() {
+  return `${JSON.stringify({
+    schema: SUBSCRIPTION_PROBE_SCHEMA,
+    claudishVersion: VERSION,
+    tokenRefreshed: false,
+    failure: { class: "internal", code: "internal_error" }
+  })}
+`;
+}
+var SUBSCRIPTION_PROBE_SCHEMA = "claudish.subscription-probe.v1";
+var init_subscription_dispatch = () => {};
+
+// src/subscription-probe-command.ts
+var exports_subscription_probe_command = {};
+__export(exports_subscription_probe_command, {
+  MAX_UNESCAPE_ROUNDS: () => MAX_UNESCAPE_ROUNDS,
+  PROBE_BODY_CAP_BYTES: () => PROBE_BODY_CAP_BYTES,
+  PROBE_EXIT: () => PROBE_EXIT,
+  PROBE_FAILURE_CODES: () => PROBE_FAILURE_CODES,
+  PROBE_REQUEST_FILE_CAP_BYTES: () => PROBE_REQUEST_FILE_CAP_BYTES,
+  PROBE_REQUEST_FILE_MESSAGE: () => PROBE_REQUEST_FILE_MESSAGE,
+  REDACTED: () => REDACTED2,
+  SUBSCRIPTION_PROBE_SCHEMA: () => SUBSCRIPTION_PROBE_SCHEMA,
+  SUBSCRIPTION_PROBE_USAGE: () => SUBSCRIPTION_PROBE_USAGE,
+  buildProbeEnvelopeBody: () => buildProbeEnvelopeBody,
+  defaultSubscriptionProbeDeps: () => defaultSubscriptionProbeDeps,
+  isSubscriptionProbeArgv: () => isSubscriptionProbeArgv,
+  jsonUnescapedForms: () => jsonUnescapedForms,
+  parseSubscriptionProbeArgs: () => parseSubscriptionProbeArgs,
+  probeExitCodeFor: () => probeExitCodeFor,
+  redactSecretValues: () => redactSecretValues,
+  reportProbeInternalError: () => reportProbeInternalError,
+  runAntigravityProbe: () => runAntigravityProbe,
+  subscriptionProbeCommand: () => subscriptionProbeCommand
+});
+import { randomUUID as randomUUID10 } from "crypto";
+import { readFile as readFile8, stat as stat2 } from "fs/promises";
+function probeExitCodeFor(failure) {
+  if (failure.class === "internal") {
+    return CALLER_CODES.includes(failure.code) ? PROBE_EXIT.usage : PROBE_EXIT.internal;
+  }
+  return PROBE_EXIT[failure.class];
+}
+async function defaultReadRequestFile(path) {
+  const info = await stat2(path);
+  if (!info.isFile())
+    throw new Error("not a file");
+  if (info.size > PROBE_REQUEST_FILE_CAP_BYTES)
+    return null;
+  return readFile8(path, "utf8");
+}
+function defaultSubscriptionProbeDeps() {
+  return {
+    platform: () => process.platform,
+    readStore: readAntigravityStoreClassified,
+    tokenDeps: defaultAntigravityTokenDeps,
+    now: () => Date.now(),
+    httpTimeoutMs: 30000,
+    keychainDeadlineMs: 1e4,
+    requestTimeoutMs: 300000,
+    readRequestFile: defaultReadRequestFile,
+    writeStdout: (line) => new Promise((resolve, reject) => {
+      process.stdout.write(line, (err) => err ? reject(err) : resolve());
+    }),
+    writeStderr: (line) => {
+      process.stderr.write(line);
+    }
+  };
+}
+function parseSubscriptionProbeArgs(argv) {
+  const positionals = [];
+  const values = new Map;
+  const switches = new Set;
+  for (let i = 0;i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--model" || token === "--request-file") {
+      const value = argv[i + 1];
+      if (values.has(token) || value === undefined || value === "" || value.startsWith("-")) {
+        return { ok: false };
+      }
+      values.set(token, value);
+      i++;
+    } else if (token === "--raw" || token === "--json") {
+      if (switches.has(token))
+        return { ok: false };
+      switches.add(token);
+    } else if (token.startsWith("-")) {
+      return { ok: false };
+    } else {
+      positionals.push(token);
+    }
+  }
+  const model = values.get("--model");
+  const requestFile = values.get("--request-file");
+  if (positionals.length !== 2 || positionals[0] !== "probe" || positionals[1] !== "antigravity" || switches.size !== 2 || model === undefined || requestFile === undefined) {
+    return { ok: false };
+  }
+  return { ok: true, provider: "antigravity", model, requestFile };
+}
+function failureOf4(cls, code, httpStatus) {
+  return failureOf2(cls, code, httpStatus);
+}
+function buildEnvelope2(facts, failure, body) {
+  return {
+    schema: SUBSCRIPTION_PROBE_SCHEMA,
+    ...facts.provider !== undefined ? { provider: facts.provider } : {},
+    claudishVersion: VERSION,
+    ...facts.model !== undefined ? { model: facts.model } : {},
+    ...facts.fetchedAt !== undefined ? { fetchedAt: facts.fetchedAt } : {},
+    ...facts.sourceUrl !== undefined ? { sourceUrl: facts.sourceUrl } : {},
+    ...facts.clientVersion !== undefined ? { clientVersion: facts.clientVersion } : {},
+    ...facts.clientVersionSource !== undefined ? { clientVersionSource: facts.clientVersionSource } : {},
+    tokenRefreshed: facts.tokenRefreshed,
+    ...facts.httpStatus !== undefined ? { httpStatus: facts.httpStatus } : {},
+    ...failure ? { failure } : {},
+    ...body ? { bodyRedacted: body.redacted, body: body.text } : {}
+  };
+}
+function fail2(facts, failure) {
+  return { envelope: buildEnvelope2(facts, failure), exitCode: probeExitCodeFor(failure) };
+}
+function lineOf2(envelope) {
+  return `${JSON.stringify(envelope)}
+`;
+}
+function safeStderr2(deps, line) {
+  try {
+    deps.writeStderr(line);
+  } catch {}
+}
+async function writeInternalFailure2(deps, facts, code, stderrLine, secrets) {
+  const failure = failureOf4("internal", code);
+  safeStderr2(deps, `${stderrLine}
+`);
+  let line = lineOf2(buildEnvelope2(facts, failure));
+  if (secrets && containsSecret(secrets, line)) {
+    line = lineOf2(buildEnvelope2({ tokenRefreshed: facts.tokenRefreshed }, failure));
+  }
+  try {
+    await deps.writeStdout(line);
+  } catch {}
+  return probeExitCodeFor(failure);
+}
+function redactSecretValues(text, secrets) {
+  let out = text;
+  const values = [...secrets.values].sort((a, b) => b.length - a.length);
+  for (const value of values) {
+    for (const form of new Set([value, value.replaceAll("/", "\\/")])) {
+      if (out.includes(form))
+        out = out.replaceAll(form, REDACTED2);
+    }
+  }
+  return { text: out, redacted: out !== text };
+}
+function jsonUnescapedForms(text) {
+  const forms = [];
+  if (text === undefined)
+    return { forms, complete: true };
+  let current = text;
+  for (let round = 0;round < MAX_UNESCAPE_ROUNDS; round++) {
+    const next = current.replace(JSON_ESCAPE, (_match, hex, letter) => hex !== undefined ? String.fromCharCode(Number.parseInt(hex, 16)) : SIMPLE_ESCAPES[letter]);
+    if (next === current)
+      return { forms, complete: true };
+    forms.push(next);
+    current = next;
+  }
+  return { forms, complete: false };
+}
+async function readRequest(deps, path) {
+  let text;
+  try {
+    text = await deps.readRequestFile(path);
+  } catch {
+    return { ok: false, code: "request_file_unreadable" };
+  }
+  if (text === null)
+    return { ok: false, code: "request_file_invalid" };
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { ok: false, code: "request_file_invalid" };
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return { ok: false, code: "request_file_invalid" };
+  }
+  return { ok: true, text };
+}
+function buildProbeEnvelopeBody(model, projectId, tierId, requestText, userPromptId = randomUUID10()) {
+  const head = JSON.stringify({ model, project: projectId, user_prompt_id: userPromptId });
+  const credits = tierId && tierId !== "free-tier" ? `,"enabled_credit_types":${JSON.stringify(["GOOGLE_ONE_AI"])}` : "";
+  return `${head.slice(0, -1)},"request":${requestText}${credits}}`;
+}
+function createActivityRequestId3() {
+  return Math.random().toString(36).substring(7);
+}
+async function readCapped(res, cap) {
+  if (!res.body)
+    return "";
+  const reader = res.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    size += value.byteLength;
+    if (size > cap) {
+      await reader.cancel().catch(() => {});
+      return null;
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function determine2(deps, secrets, facts, args) {
+  const request = await readRequest(deps, args.requestFile);
+  if (!request.ok)
+    return fail2(facts, failureOf4("internal", request.code));
+  const session = await establishAntigravitySession(deps, secrets, facts);
+  if (!session.ok)
+    return fail2(facts, session.failure);
+  const url = `${antigravityHost()}/v1internal:generateContent`;
+  const version = resolveAntigravityClientVersion();
+  facts.sourceUrl = stripUserinfo(url);
+  facts.clientVersion = version.version;
+  facts.clientVersionSource = version.source;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), deps.requestTimeoutMs);
+  const networkFailure = () => failureOf4("network", controller.signal.aborted ? "generate_content_timeout" : "generate_content_network_error", facts.httpStatus);
+  try {
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${session.accessToken}`,
+          "Content-Type": "application/json",
+          "User-Agent": antigravityUserAgentFor(version.version),
+          "x-activity-request-id": createActivityRequestId3()
+        },
+        body: buildProbeEnvelopeBody(args.model, session.projectId, session.tierId, request.text),
+        signal: controller.signal,
+        redirect: "manual"
+      });
+    } catch {
+      return fail2(facts, networkFailure());
+    }
+    facts.fetchedAt = new Date(deps.now()).toISOString();
+    facts.httpStatus = res.status;
+    let text;
+    try {
+      text = await readCapped(res, PROBE_BODY_CAP_BYTES);
+    } catch {
+      return fail2(facts, networkFailure());
+    }
+    if (text === null)
+      return fail2(facts, failureOf4("list_incomplete", "body_too_large", res.status));
+    if (res.ok) {
+      try {
+        JSON.parse(text);
+      } catch {
+        return fail2(facts, failureOf4("list_incomplete", "body_not_json", res.status));
+      }
+    }
+    const body = redactSecretValues(text, secrets);
+    const unescaped = jsonUnescapedForms(body.text);
+    if (!unescaped.complete) {
+      return fail2(facts, failureOf4("list_incomplete", "body_unverifiable", res.status));
+    }
+    return {
+      envelope: buildEnvelope2(facts, undefined, body),
+      exitCode: PROBE_EXIT.ok,
+      bodyText: body.text,
+      bodyForms: unescaped.forms
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function runAntigravityProbe(deps, args) {
+  const secrets = newSecrets();
+  const facts = { provider: "antigravity", model: args.model, tokenRefreshed: false };
+  let result;
+  try {
+    result = await determine2(deps, secrets, facts, args);
+  } catch {
+    return writeInternalFailure2(deps, { provider: facts.provider, model: facts.model, tokenRefreshed: facts.tokenRefreshed }, "internal_error", INTERNAL_ERROR_MESSAGE2, secrets);
+  }
+  if (result.envelope.failure?.code === "request_file_unreadable" || result.envelope.failure?.code === "request_file_invalid") {
+    safeStderr2(deps, `${PROBE_REQUEST_FILE_MESSAGE}
+`);
+  }
+  const line = lineOf2(result.envelope);
+  if (containsSecret(secrets, line, result.bodyText, ...result.bodyForms ?? [])) {
+    return writeInternalFailure2(deps, facts, "secret_guard", SECRET_GUARD_MESSAGE2, secrets);
+  }
+  try {
+    await deps.writeStdout(line);
+  } catch {
+    safeStderr2(deps, `${INTERNAL_ERROR_MESSAGE2}
+`);
+    return PROBE_EXIT.internal;
+  }
+  return result.exitCode;
+}
+async function reportProbeInternalError(deps) {
+  let resolved;
+  try {
+    resolved = deps ?? defaultSubscriptionProbeDeps();
+  } catch {
+    process.stderr.write(`${INTERNAL_ERROR_MESSAGE2}
+`);
+    return PROBE_EXIT.internal;
+  }
+  return writeInternalFailure2(resolved, { tokenRefreshed: false }, "internal_error", INTERNAL_ERROR_MESSAGE2);
+}
+async function subscriptionProbeCommand(argv, deps = defaultSubscriptionProbeDeps()) {
+  const args = parseSubscriptionProbeArgs(argv);
+  if (!args.ok) {
+    return writeInternalFailure2(deps, { tokenRefreshed: false }, "usage", SUBSCRIPTION_PROBE_USAGE);
+  }
+  return runAntigravityProbe(deps, args);
+}
+var PROBE_FAILURE_CODES, PROBE_EXIT, CALLER_CODES, PROBE_BODY_CAP_BYTES, PROBE_REQUEST_FILE_CAP_BYTES, REDACTED2 = "[REDACTED]", SUBSCRIPTION_PROBE_USAGE = "usage: claudish subscription probe antigravity --model <wire-model-id> --request-file <path> --raw --json", PROBE_REQUEST_FILE_MESSAGE = "[claudish subscription] the request file must hold one JSON object (the inner Gemini request)", SECRET_GUARD_MESSAGE2 = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE2 = "[claudish subscription] internal error", JSON_ESCAPE, SIMPLE_ESCAPES, MAX_UNESCAPE_ROUNDS = 64;
+var init_subscription_probe_command = __esm(() => {
+  init_antigravity_token();
+  init_antigravity_user();
+  init_subscription_antigravity_session();
+  init_subscription_dispatch();
+  init_subscription_dispatch();
+  PROBE_FAILURE_CODES = {
+    credential_missing: SESSION_FAILURE_CODES.credential_missing,
+    keychain_locked: SESSION_FAILURE_CODES.keychain_locked,
+    mint_failed: SESSION_FAILURE_CODES.mint_failed,
+    network: [
+      ...SESSION_FAILURE_CODES.network,
+      "generate_content_network_error",
+      "generate_content_timeout"
+    ],
+    list_incomplete: ["body_too_large", "body_not_json", "body_unverifiable"],
+    internal: [
+      "usage",
+      "request_file_unreadable",
+      "request_file_invalid",
+      "secret_guard",
+      "internal_error"
+    ]
+  };
+  PROBE_EXIT = {
+    ok: 0,
+    internal: 1,
+    usage: 2,
+    credential_missing: 3,
+    keychain_locked: 4,
+    mint_failed: 5,
+    network: 6,
+    list_incomplete: 7
+  };
+  CALLER_CODES = [
+    "usage",
+    "request_file_unreadable",
+    "request_file_invalid"
+  ];
+  PROBE_BODY_CAP_BYTES = 512 * 1024;
+  PROBE_REQUEST_FILE_CAP_BYTES = 8 * 1024 * 1024;
+  JSON_ESCAPE = /\\(?:u([0-9a-fA-F]{4})|(["\\/bfnrt]))/g;
+  SIMPLE_ESCAPES = {
+    '"': '"',
+    "\\": "\\",
+    "/": "/",
+    b: "\b",
+    f: "\f",
+    n: `
+`,
+    r: "\r",
+    t: "\t"
+  };
 });
 
 // src/account-forecast-render.ts
@@ -115079,7 +115512,7 @@ var init_terminal_isolation = __esm(() => {
 
 // src/claude-runner.ts
 import { spawn as spawn4, spawnSync as spawnSync4 } from "child_process";
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import {
   chmodSync as chmodSync5,
   closeSync as closeSync14,
@@ -116013,7 +116446,7 @@ Or set CLAUDE_PATH to your custom installation:`);
   const sessionFlags = sessionFlagsOf(config.claudeArgs);
   let driverLaunch = null;
   if (surfaces.driver) {
-    const minted = sessionFlags.sessionId || sessionFlags.resumes ? null : randomUUID10();
+    const minted = sessionFlags.sessionId || sessionFlags.resumes ? null : randomUUID11();
     const turnDir = mkdtempSync4(join63(tmpdir3(), "claudish-turns-"));
     chmodSync5(turnDir, 448);
     claudeArgs.unshift(...driverLeadingArgs({ mintedSessionId: minted, turnDir }));
@@ -119200,12 +119633,25 @@ if (isMcpMode) {
   }));
 } else if (isSubscriptionCommand) {
   const subscriptionArgIndex = args.indexOf("subscription");
+  const subscriptionArgv = args.slice(subscriptionArgIndex + 1);
   const subscriptionModule = () => Promise.resolve().then(() => (init_subscription_models_command(), exports_subscription_models_command));
-  subscriptionModule().then((m) => m.subscriptionModelsCommand(args.slice(subscriptionArgIndex + 1))).catch(() => subscriptionModule().then((m) => m.reportSubscriptionInternalError()).catch(() => {
+  const probeModule = () => Promise.resolve().then(() => (init_subscription_probe_command(), exports_subscription_probe_command));
+  const writeLine = (line, code) => new Promise((resolve) => {
+    process.stdout.write(line, () => resolve(code));
+  });
+  Promise.resolve().then(() => (init_subscription_dispatch(), {})).then((dispatch) => {
+    const probe = isSubscriptionProbeArgv(subscriptionArgv);
+    const run = probe ? probeModule().then((m) => m.subscriptionProbeCommand(subscriptionArgv)) : subscriptionModule().then((m) => m.subscriptionModelsCommand(subscriptionArgv));
+    return run.catch(() => probe ? probeModule().then((m) => m.reportProbeInternalError()).catch(() => {
+      process.stderr.write(`[claudish subscription] internal error
+`);
+      return writeLine(probeLoadFailureLine(), 1);
+    }) : subscriptionModule().then((m) => m.reportSubscriptionInternalError()));
+  }).catch(() => {
     process.stderr.write(`[claudish subscription] internal error
 `);
     return 1;
-  })).then((code) => process.exit(code));
+  }).then((code) => process.exit(code));
 } else if (isAccountCommand) {
   const accountArgIndex = args.indexOf("account");
   Promise.resolve().then(() => (init_account_command(), {})).then((m) => accountCommand(args.slice(accountArgIndex + 1)).catch((e) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "14.10.2",
+  "version": "14.11.0",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -71,10 +71,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "14.10.2",
-    "@claudish/magmux-darwin-x64": "14.10.2",
-    "@claudish/magmux-linux-arm64": "14.10.2",
-    "@claudish/magmux-linux-x64": "14.10.2"
+    "@claudish/magmux-darwin-arm64": "14.11.0",
+    "@claudish/magmux-darwin-x64": "14.11.0",
+    "@claudish/magmux-linux-arm64": "14.11.0",
+    "@claudish/magmux-linux-x64": "14.11.0"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",