@omnicross/daemon 0.4.2 → 0.4.4

package/dist/cli.cjs

@@ -953,7 +953,11 @@ var TOKEN_FIELDS = {
   claude: ["accessToken", "refreshToken"],
   codex: ["accessToken", "refreshToken", "idToken"],
   gemini: ["accessToken", "refreshToken"],
-  opencodego: ["apiKey"]
+  opencodego: ["apiKey"],
+  kimi: ["accessToken", "refreshToken"],
+  grok: ["accessToken", "refreshToken"],
+  copilot: ["accessToken", "refreshToken"],
+  antigravity: ["accessToken", "refreshToken"]
 };
 function transformTokenBlock(block, fields, fn) {
   const next = { ...block };
@@ -1171,21 +1175,23 @@ var import_node_path36 = require("path");
 var import_audit_types = require("@omnicross/contracts/audit-types");
 var import_billing_types = require("@omnicross/contracts/billing-types");
 var import_core7 = require("@omnicross/core");
-var import_GeminiCodeAssistProjectResolver2 = require("@omnicross/core/auth/GeminiCodeAssistProjectResolver");
+var import_GeminiCodeAssistProjectResolver6 = require("@omnicross/core/auth/GeminiCodeAssistProjectResolver");
 var import_ApiKeyPoolService = require("@omnicross/core/completion/ApiKeyPoolService");
 var import_outbound_api10 = require("@omnicross/core/outbound-api");
 var import_subscriptionRegistryPort = require("@omnicross/core/outbound-api/subscriptionRegistryPort");
 var import_SubscriptionAccountHealth4 = require("@omnicross/core/pipeline/SubscriptionAccountHealth");
-var import_AccountAllowanceStore10 = require("@omnicross/core/pipeline/AccountAllowanceStore");
+var import_AccountAllowanceStore11 = require("@omnicross/core/pipeline/AccountAllowanceStore");
 var import_AccountAllowanceScheduling5 = require("@omnicross/core/pipeline/AccountAllowanceScheduling");
-var import_upstreamFetch16 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_upstreamFetch18 = require("@omnicross/core/pipeline/upstreamFetch");
 var import_SubscriptionIdentityStore3 = require("@omnicross/core/provider-proxy/identity/SubscriptionIdentityStore");
 var import_gemini_code_assist_resolver = require("@omnicross/core/ports/gemini-code-assist-resolver");
+var import_antigravityFailover = require("@omnicross/core/transformer/transformers/antigravityFailover");
+var import_openCodeGoHeaders2 = require("@omnicross/core/provider-proxy/identity/openCodeGoHeaders");
 var import_provider_proxy4 = require("@omnicross/core/provider-proxy");
 var import_cli_launcher2 = require("@omnicross/cli-launcher");
 var import_outbound_api11 = require("@omnicross/core/outbound-api");
 var import_usage2 = require("@omnicross/core/usage");
-var import_subscriptions12 = require("@omnicross/subscriptions");
+var import_subscriptions13 = require("@omnicross/subscriptions");
 
 // src/admin/accountsCodexOAuth.ts
 var import_node_crypto3 = __toESM(require("crypto"), 1);
@@ -1547,7 +1553,7 @@ function handleCopilotOAuthStatus(sessionId, deps) {
 }
 
 // src/allowance/AccountAllowanceService.ts
-var import_AccountAllowanceStore8 = require("@omnicross/core/pipeline/AccountAllowanceStore");
+var import_AccountAllowanceStore9 = require("@omnicross/core/pipeline/AccountAllowanceStore");
 var import_AccountAllowanceScheduling = require("@omnicross/core/pipeline/AccountAllowanceScheduling");
 
 // src/allowance/ClaudeAllowanceCollector.ts
@@ -2917,9 +2923,321 @@ var GeminiAllowanceCollector = class {
   }
 };
 
-// src/allowance/OpenCodeGoAllowanceCollector.ts
+// src/allowance/AntigravityAllowanceCollector.ts
+var import_GeminiCodeAssistProjectResolver2 = require("@omnicross/core/auth/GeminiCodeAssistProjectResolver");
+var import_antigravityQuotaFamily = require("@omnicross/core/pipeline/antigravityQuotaFamily");
 var import_AccountAllowanceStore7 = require("@omnicross/core/pipeline/AccountAllowanceStore");
 var import_upstreamFetch7 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_antigravityIdentity = require("@omnicross/core/transformer/transformers/antigravityIdentity");
+var ANTIGRAVITY_ALLOWANCE_CACHE_MS = 5 * 6e4;
+var RETRIEVE_USER_QUOTA_SUMMARY_PATH = "/v1internal:retrieveUserQuotaSummary";
+var FETCH_AVAILABLE_MODELS_PATH = "/v1internal:fetchAvailableModels";
+var ANTIGRAVITY_DISCOVERY_DENYLIST = /* @__PURE__ */ new Set([
+  "chat_20706",
+  "chat_23310",
+  "gemini-2.5-pro"
+]);
+function isRecord5(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function secondsUntil7(instant, now) {
+  if (!instant) return void 0;
+  return Math.max(0, Math.floor((Date.parse(instant) - now) / 1e3));
+}
+var WINDOW_LABELS = {
+  "five-hour": "5 Hour",
+  weekly: "Weekly",
+  daily: "Daily"
+};
+function classifyWindowId(...sources) {
+  for (const source of sources) {
+    if (!source) continue;
+    const text = source.toLowerCase();
+    if (text.includes("week") || text.includes("7d") || /7[\s_-]*day/.test(text)) return "weekly";
+    if (text.includes("5h") || text.includes("five hour") || /5[\s_-]*hour/.test(text)) return "five-hour";
+    if (text.includes("day") || text.includes("daily") || text.includes("24h")) return "daily";
+  }
+  return void 0;
+}
+function inferWindowFromReset(resetsAt, now) {
+  if (resetsAt !== void 0 && Date.parse(resetsAt) - now > 24 * 60 * 60 * 1e3) return "weekly";
+  return "daily";
+}
+function clampFraction(value) {
+  if (value === void 0 || !Number.isFinite(value)) return void 0;
+  return Math.min(1, Math.max(0, value));
+}
+function usedPercentFromFraction(fraction) {
+  const clamped = clampFraction(fraction);
+  if (clamped === void 0) return null;
+  return Math.round((1 - clamped) * 1e3) / 10;
+}
+function toResetsAt(resetTime) {
+  if (!resetTime || !Number.isFinite(Date.parse(resetTime))) return void 0;
+  return new Date(Date.parse(resetTime)).toISOString();
+}
+function parseAntigravityQuotaSummary(payload, now) {
+  if (!isRecord5(payload)) return null;
+  const groups = Array.isArray(payload["groups"]) ? payload["groups"] : [];
+  const topBuckets = Array.isArray(payload["buckets"]) ? payload["buckets"] : [];
+  const hasGrouped = groups.some((group) => Array.isArray(group.buckets) && group.buckets.length > 0);
+  if (!hasGrouped && topBuckets.length === 0) return null;
+  const windows = /* @__PURE__ */ new Map();
+  const addBucket = (bucket, groupName) => {
+    const families = (0, import_antigravityQuotaFamily.antigravityCounterFamiliesForBucketId)(bucket.bucketId, groupName);
+    if (families.length === 0) return;
+    const resetsAt = toResetsAt(bucket.resetTime);
+    const windowId = classifyWindowId(bucket.window, bucket.displayName, bucket.bucketId) ?? (resetsAt !== void 0 ? inferWindowFromReset(resetsAt, now) : void 0);
+    if (windowId === void 0) return;
+    const usedPercent = usedPercentFromFraction(bucket.remainingFraction) ?? (bucket.disabled === true || bucket.resetTime ? bucket.disabled === true ? 100 : null : null);
+    for (const family of families) {
+      const id = `antigravity:${family}:${windowId}`;
+      const candidate = {
+        id,
+        label: `${WINDOW_LABELS[windowId]} (${family})`,
+        scope: "model-family",
+        // The window carries the MODEL family (gemini/claude/gpt-oss) — the
+        // scheduling gate compares it against the requested model's family.
+        modelFamily: import_antigravityQuotaFamily.ANTIGRAVITY_COUNTER_TO_MODEL_FAMILY[family],
+        usedPercent,
+        ...resetsAt !== void 0 ? { resetsAt } : {},
+        remainingSeconds: secondsUntil7(resetsAt, now),
+        state: "fresh",
+        ...bucket.disabled === true ? { disabled: true } : {}
+      };
+      const existing = windows.get(id);
+      if (!existing || candidate.disabled === true || existing.disabled !== true && (candidate.usedPercent ?? -1) > (existing.usedPercent ?? -1)) {
+        windows.set(id, candidate);
+      }
+    }
+  };
+  if (hasGrouped) {
+    for (const group of groups) {
+      for (const bucket of group.buckets ?? []) addBucket(bucket, group.displayName);
+    }
+  } else {
+    for (const bucket of topBuckets) addBucket(bucket);
+  }
+  const result = [...windows.values()];
+  return result.length > 0 ? result : null;
+}
+function legacyQuotaInfos(model) {
+  const out = [];
+  const source = {
+    ...model.apiProvider ? { apiProvider: model.apiProvider } : {},
+    ...model.modelProvider ? { modelProvider: model.modelProvider } : {}
+  };
+  const add = (value, windowDefault) => {
+    if (!value) return;
+    const list = Array.isArray(value) ? value : [value];
+    for (const info of list) {
+      out.push({ ...source, ...windowDefault ? { windowId: windowDefault } : {}, ...info });
+    }
+  };
+  add(model.quotaInfo);
+  add(model.quotaInfos);
+  add(model.dailyQuotaInfo, "daily");
+  add(model.dailyQuotaInfos, "daily");
+  add(model.weeklyQuotaInfo, "weekly");
+  add(model.weeklyQuotaInfos, "weekly");
+  return out;
+}
+function legacyCounterFamily(info) {
+  switch (info.modelProvider ?? info.apiProvider) {
+    case "MODEL_PROVIDER_ANTHROPIC":
+    case "API_PROVIDER_ANTHROPIC_VERTEX":
+      return "anthropic";
+    case "MODEL_PROVIDER_GOOGLE":
+    case "API_PROVIDER_GOOGLE_GEMINI":
+      return "google";
+    case "MODEL_PROVIDER_OPENAI":
+    case "API_PROVIDER_OPENAI_VERTEX":
+      return "openai";
+    default:
+      return void 0;
+  }
+}
+function parseAntigravityLegacyQuota(payload, now) {
+  if (!isRecord5(payload)) return null;
+  const models = payload["models"];
+  if (!isRecord5(models)) return null;
+  const windows = /* @__PURE__ */ new Map();
+  for (const info of Object.values(models).flatMap(legacyQuotaInfos)) {
+    const family = legacyCounterFamily(info);
+    if (!family) continue;
+    const resetsAt = toResetsAt(info.resetTime);
+    const windowId = classifyWindowId(info.windowId, info.windowLabel) ?? (resetsAt !== void 0 ? inferWindowFromReset(resetsAt, now) : void 0);
+    if (windowId === void 0) continue;
+    const id = `antigravity:${family}:${windowId}`;
+    const candidate = {
+      id,
+      label: `${WINDOW_LABELS[windowId]} (${family})`,
+      scope: "model-family",
+      modelFamily: import_antigravityQuotaFamily.ANTIGRAVITY_COUNTER_TO_MODEL_FAMILY[family],
+      usedPercent: usedPercentFromFraction(info.remainingFraction),
+      ...resetsAt !== void 0 ? { resetsAt } : {},
+      remainingSeconds: secondsUntil7(resetsAt, now),
+      state: "fresh"
+    };
+    const existing = windows.get(id);
+    if (!existing || (candidate.usedPercent ?? -1) > (existing.usedPercent ?? -1)) {
+      windows.set(id, candidate);
+    }
+  }
+  const result = [...windows.values()];
+  return result.length > 0 ? result : null;
+}
+var AntigravityAllowanceCollector = class {
+  constructor(credentials, store = (0, import_AccountAllowanceStore7.getSharedAccountAllowanceStore)(), fetchImpl = (url, init, accountId) => (0, import_upstreamFetch7.fetchUpstream)(url, init, { providerId: "antigravity", accountId, redactBodies: true }), now = Date.now) {
+    this.credentials = credentials;
+    this.store = store;
+    this.fetchImpl = fetchImpl;
+    this.now = now;
+  }
+  credentials;
+  store;
+  fetchImpl;
+  now;
+  inFlight = /* @__PURE__ */ new Map();
+  async collectMany(accounts, options = {}) {
+    const settled = await Promise.allSettled(
+      accounts.map((account) => this.collect(account, options))
+    );
+    return settled.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
+  }
+  collect(account, options = {}) {
+    const now = this.now();
+    if (account.tokens.authMethod !== "oauth") {
+      const existing = this.store.get("antigravity", account.id, now);
+      if (existing?.windows.every((window) => window.state === "unsupported")) {
+        return Promise.resolve(existing);
+      }
+      const snapshot = this.unsupportedSnapshot(account.id, now);
+      this.store.set(snapshot);
+      return Promise.resolve(snapshot);
+    }
+    const cached = this.store.get("antigravity", account.id, now);
+    if (!options.force && cached && this.isCacheValid(cached, now, options.refreshAheadMs)) {
+      return Promise.resolve(cached);
+    }
+    const running = this.inFlight.get(account.id);
+    if (running) return running;
+    const promise = this.fetchAccount(account.id).catch(() => this.failureSnapshot(account.id, "antigravity_usage_request_failed", this.now())).finally(() => this.inFlight.delete(account.id));
+    this.inFlight.set(account.id, promise);
+    return promise;
+  }
+  isCacheValid(snapshot, now, refreshAheadMs) {
+    if (snapshot.windows.every((window) => window.state === "unsupported")) return true;
+    const expiresAt = snapshot.expiresAt ? Date.parse(snapshot.expiresAt) : 0;
+    const ahead = typeof refreshAheadMs === "number" && Number.isFinite(refreshAheadMs) ? Math.max(0, refreshAheadMs) : 0;
+    return Number.isFinite(expiresAt) && expiresAt > now + ahead;
+  }
+  async fetchAccount(accountId) {
+    let accessToken = await this.credentials.getAccessTokenForAccount("antigravity", accountId);
+    if (!accessToken) return this.failureSnapshot(accountId, "antigravity_usage_token_unavailable", this.now());
+    let response = await this.request(accountId, accessToken, RETRIEVE_USER_QUOTA_SUMMARY_PATH, {
+      project: void 0
+    });
+    if (response.status === 401 || response.status === 403) {
+      const refreshed = await this.credentials.refreshAccountToken("antigravity", accountId);
+      if (!refreshed) return this.failureSnapshot(accountId, "antigravity_usage_unauthorized", this.now());
+      accessToken = await this.credentials.getAccessTokenForAccount("antigravity", accountId);
+      if (!accessToken) return this.failureSnapshot(accountId, "antigravity_usage_token_unavailable", this.now());
+      response = await this.request(accountId, accessToken, RETRIEVE_USER_QUOTA_SUMMARY_PATH, {
+        project: void 0
+      });
+      if (response.status === 401 || response.status === 403) {
+        return this.failureSnapshot(accountId, "antigravity_usage_unauthorized", this.now());
+      }
+    }
+    if (response.ok) {
+      const payload = await response.json().catch(() => null);
+      const windows = parseAntigravityQuotaSummary(payload, this.now());
+      if (windows) {
+        const snapshot2 = this.snapshot(accountId, windows);
+        this.store.set(snapshot2);
+        return snapshot2;
+      }
+    }
+    const legacy = await this.request(accountId, accessToken, FETCH_AVAILABLE_MODELS_PATH, {});
+    if (!legacy.ok) {
+      return this.failureSnapshot(accountId, "antigravity_usage_http_error", this.now());
+    }
+    const legacyPayload = await legacy.json().catch(() => null);
+    const legacyWindows = parseAntigravityLegacyQuota(legacyPayload, this.now());
+    if (!legacyWindows) {
+      return this.failureSnapshot(accountId, "antigravity_usage_invalid_response", this.now());
+    }
+    const snapshot = this.snapshot(accountId, legacyWindows);
+    this.store.set(snapshot);
+    return snapshot;
+  }
+  /** One upstream round-trip with the antigravity/hub masquerade UA. */
+  request(accountId, accessToken, path2, body) {
+    return this.fetchImpl(`${import_GeminiCodeAssistProjectResolver2.ANTIGRAVITY_CODE_ASSIST_ENDPOINT}${path2}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": (0, import_antigravityIdentity.getAntigravityUserAgent)()
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15e3)
+    }, accountId);
+  }
+  snapshot(accountId, windows, now = this.now()) {
+    return {
+      providerId: "antigravity",
+      accountId,
+      source: "oauth-usage-api",
+      observedAt: new Date(now).toISOString(),
+      expiresAt: new Date(now + ANTIGRAVITY_ALLOWANCE_CACHE_MS).toISOString(),
+      windows
+    };
+  }
+  failureSnapshot(accountId, code, now) {
+    const existing = this.store.get("antigravity", accountId, now);
+    const snapshot = existing ? {
+      ...existing,
+      expiresAt: new Date(now + ANTIGRAVITY_ALLOWANCE_CACHE_MS).toISOString(),
+      windows: existing.windows.map((window) => ({
+        ...window,
+        state: window.state === "unsupported" ? "unsupported" : window.usedPercent !== null || window.resetsAt || window.disabled ? "stale" : "unavailable"
+      })),
+      lastErrorCode: code
+    } : {
+      providerId: "antigravity",
+      accountId,
+      source: "oauth-usage-api",
+      observedAt: new Date(now).toISOString(),
+      expiresAt: new Date(now + ANTIGRAVITY_ALLOWANCE_CACHE_MS).toISOString(),
+      windows: [
+        { id: "antigravity-quota", label: "Antigravity quota", scope: "all", usedPercent: null, state: "unavailable" }
+      ],
+      lastErrorCode: code
+    };
+    this.store.set(snapshot);
+    return snapshot;
+  }
+  unsupportedSnapshot(accountId, now) {
+    return {
+      providerId: "antigravity",
+      accountId,
+      source: "oauth-usage-api",
+      observedAt: new Date(now).toISOString(),
+      windows: [
+        { id: "antigravity-quota", label: "Antigravity quota", scope: "all", usedPercent: null, state: "unsupported" }
+      ],
+      lastErrorCode: "antigravity_usage_unsupported_auth"
+    };
+  }
+};
+
+// src/allowance/OpenCodeGoAllowanceCollector.ts
+var import_AccountAllowanceStore8 = require("@omnicross/core/pipeline/AccountAllowanceStore");
+var import_upstreamFetch8 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_openCodeGoHeaders = require("@omnicross/core/provider-proxy/identity/openCodeGoHeaders");
 var import_subscriptions7 = require("@omnicross/subscriptions");
 var OPENCODEGO_ALLOWANCE_CACHE_MS = 5 * 6e4;
 var OPENCODEGO_DEFAULT_GO_BASE = "https://opencode.ai/zen/go";
@@ -2933,7 +3251,7 @@ function isoInstant2(value) {
   const time = Date.parse(value);
   return Number.isFinite(time) ? new Date(time).toISOString() : void 0;
 }
-function secondsUntil7(instant, now) {
+function secondsUntil8(instant, now) {
   if (!instant) return void 0;
   return Math.max(0, Math.floor((Date.parse(instant) - now) / 1e3));
 }
@@ -2948,12 +3266,12 @@ function windowFromPayload3(id, label, minutes, payload, now) {
     usedPercent,
     windowMinutes: minutes,
     ...resetsAt !== void 0 ? { resetsAt } : {},
-    remainingSeconds: secondsUntil7(resetsAt, now),
+    remainingSeconds: secondsUntil8(resetsAt, now),
     state: usedPercent !== null || resetsAt ? "fresh" : "unavailable"
   };
 }
 var OpenCodeGoAllowanceCollector = class {
-  constructor(credentials, store = (0, import_AccountAllowanceStore7.getSharedAccountAllowanceStore)(), fetchImpl = (url, init, accountId) => (0, import_upstreamFetch7.fetchUpstream)(url, init, { providerId: "opencodego", accountId, redactBodies: true }), now = Date.now) {
+  constructor(credentials, store = (0, import_AccountAllowanceStore8.getSharedAccountAllowanceStore)(), fetchImpl = (url, init, accountId) => (0, import_upstreamFetch8.fetchUpstream)(url, init, { providerId: "opencodego", accountId, redactBodies: true }), now = Date.now) {
     this.credentials = credentials;
     this.store = store;
     this.fetchImpl = fetchImpl;
@@ -2986,7 +3304,14 @@ var OpenCodeGoAllowanceCollector = class {
     const base = account.tokens.baseUrl ? (0, import_subscriptions7.normalizeOpenCodeGoBaseUrl)(account.tokens.baseUrl) : OPENCODEGO_DEFAULT_GO_BASE;
     const response = await this.fetchImpl(`${base}/v1/usage`, {
       method: "GET",
-      headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+      // opencodego-egress-identity: the background poll identifies itself with
+      // the same configured/default UA the relay carries (no session header —
+      // a poll has no conversation).
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+        "User-Agent": (0, import_openCodeGoHeaders.getOpenCodeGoUserAgent)()
+      },
       signal: AbortSignal.timeout(15e3)
     }, account.id);
     if (response.status === 401 || response.status === 403) {
@@ -3058,7 +3383,7 @@ function codexUnavailable(accountId, now) {
   };
 }
 var AccountAllowanceService = class {
-  constructor(credentials, store = (0, import_AccountAllowanceStore8.getSharedAccountAllowanceStore)(), collector, codexCollector, kimiCollector, opencodegoCollector, grokCollector, copilotCollector, geminiCollector, now = Date.now) {
+  constructor(credentials, store = (0, import_AccountAllowanceStore9.getSharedAccountAllowanceStore)(), collector, codexCollector, kimiCollector, opencodegoCollector, grokCollector, copilotCollector, geminiCollector, antigravityCollector, now = Date.now) {
     this.credentials = credentials;
     this.store = store;
     this.now = now;
@@ -3069,6 +3394,7 @@ var AccountAllowanceService = class {
     this.grokCollector = grokCollector ?? new GrokAllowanceCollector(credentials, store);
     this.copilotCollector = copilotCollector ?? new CopilotAllowanceCollector(credentials, store);
     this.geminiCollector = geminiCollector ?? new GeminiAllowanceCollector(credentials, store);
+    this.antigravityCollector = antigravityCollector ?? new AntigravityAllowanceCollector(credentials, store);
   }
   credentials;
   store;
@@ -3080,6 +3406,7 @@ var AccountAllowanceService = class {
   copilotCollector;
   opencodegoCollector;
   geminiCollector;
+  antigravityCollector;
   /**
    * Read all/filtered snapshots. Claude's and Codex's five-minute caches are
    * refreshed lazily on read (Codex polls `/backend-api/wham/usage`; the
@@ -3128,6 +3455,11 @@ var AccountAllowanceService = class {
       (account) => !filter.accountId || account.id === filter.accountId
     );
     if (wantsGemini) await this.geminiCollector.collectMany(geminiAccounts);
+    const wantsAntigravity = !filter.providerId || filter.providerId === "antigravity";
+    const antigravityAccounts = (config.antigravityAccounts ?? []).filter(
+      (account) => !filter.accountId || account.id === filter.accountId
+    );
+    if (wantsAntigravity) await this.antigravityCollector.collectMany(antigravityAccounts);
     const known = /* @__PURE__ */ new Set();
     if (wantsClaude) for (const account of claudeAccounts) known.add(`claude\0${account.id}`);
     if (wantsCodex) for (const account of codexAccounts) known.add(`codex\0${account.id}`);
@@ -3136,6 +3468,7 @@ var AccountAllowanceService = class {
     if (wantsGrok) for (const account of grokAccounts) known.add(`grok\0${account.id}`);
     if (wantsCopilot) for (const account of copilotAccounts) known.add(`copilot\0${account.id}`);
     if (wantsGemini) for (const account of geminiAccounts) known.add(`gemini\0${account.id}`);
+    if (wantsAntigravity) for (const account of antigravityAccounts) known.add(`antigravity\0${account.id}`);
     return this.store.list(filter).filter((snapshot) => known.has(`${snapshot.providerId}\0${snapshot.accountId}`));
   }
   knownAccounts(config) {
@@ -3146,7 +3479,8 @@ var AccountAllowanceService = class {
       ...(config.opencodegoAccounts ?? []).map((account) => ({ providerId: "opencodego", accountId: account.id })),
       ...(config.grokAccounts ?? []).map((account) => ({ providerId: "grok", accountId: account.id })),
       ...(config.copilotAccounts ?? []).map((account) => ({ providerId: "copilot", accountId: account.id })),
-      ...(config.geminiAccounts ?? []).map((account) => ({ providerId: "gemini", accountId: account.id }))
+      ...(config.geminiAccounts ?? []).map((account) => ({ providerId: "gemini", accountId: account.id })),
+      ...(config.antigravityAccounts ?? []).map((account) => ({ providerId: "antigravity", accountId: account.id }))
     ];
   }
   /** Force-refresh Claude usage for one account or every stored Claude account. */
@@ -3216,6 +3550,15 @@ var AccountAllowanceService = class {
     );
     return this.geminiCollector.collectMany(accounts, { force: true });
   }
+  /** Force-refresh Antigravity usage (quotaSummary dual buckets) for one/all accounts. */
+  async refreshAntigravity(accountId) {
+    const config = await this.credentials.getFullConfig();
+    this.store.pruneToKnownAccounts(this.knownAccounts(config));
+    const accounts = (config.antigravityAccounts ?? []).filter(
+      (account) => !accountId || account.id === accountId
+    );
+    return this.antigravityCollector.collectMany(accounts, { force: true });
+  }
   /**
    * Keep Claude + Codex + Kimi snapshots warm for allowance-aware routing. All
    * collectors preserve their cache + per-account in-flight coalescing; a tick
@@ -3233,6 +3576,7 @@ var AccountAllowanceService = class {
     await this.grokCollector.collectMany(config.grokAccounts ?? [], { refreshAheadMs });
     await this.copilotCollector.collectMany(config.copilotAccounts ?? [], { refreshAheadMs });
     await this.geminiCollector.collectMany(config.geminiAccounts ?? [], { refreshAheadMs });
+    await this.antigravityCollector.collectMany(config.antigravityAccounts ?? [], { refreshAheadMs });
   }
   /** Remove a cache row as soon as an account is deleted by the admin path. */
   removeAccountSnapshot(providerId, accountId) {
@@ -3327,7 +3671,7 @@ var ClaudeAllowanceRefreshScheduler = class {
 var import_node_crypto4 = require("crypto");
 var import_node_fs6 = require("fs");
 var import_node_path6 = require("path");
-var import_AccountAllowanceStore9 = require("@omnicross/core/pipeline/AccountAllowanceStore");
+var import_AccountAllowanceStore10 = require("@omnicross/core/pipeline/AccountAllowanceStore");
 var ACCOUNT_ALLOWANCE_CACHE_VERSION = 1;
 var MAX_PERSISTED_ALLOWANCE_SNAPSHOTS = 256;
 var MAX_ALLOWANCE_CACHE_BYTES = 1e6;
@@ -3356,7 +3700,7 @@ var JsonAccountAllowancePersistence = class {
   save(snapshots) {
     const rows = [];
     for (const snapshot of snapshots) {
-      const normalized2 = (0, import_AccountAllowanceStore9.normalizeAccountAllowanceSnapshot)(snapshot);
+      const normalized2 = (0, import_AccountAllowanceStore10.normalizeAccountAllowanceSnapshot)(snapshot);
       if (!normalized2) continue;
       rows.push(normalized2);
       if (rows.length >= MAX_PERSISTED_ALLOWANCE_SNAPSHOTS) break;
@@ -3632,7 +3976,7 @@ var import_outbound_api5 = require("@omnicross/core/outbound-api");
 var import_image_generation_types = require("@omnicross/contracts/image-generation-types");
 var import_AccountAllowanceScheduling2 = require("@omnicross/core/pipeline/AccountAllowanceScheduling");
 var import_SubscriptionAccountHealth = require("@omnicross/core/pipeline/SubscriptionAccountHealth");
-var import_upstreamFetch10 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_upstreamFetch12 = require("@omnicross/core/pipeline/upstreamFetch");
 var import_core3 = require("@omnicross/core");
 
 // src/image-generation/imagesConfigValidation.ts
@@ -3949,6 +4293,19 @@ function resolveAdminConfig(admin) {
     token: typeof admin?.token === "string" && admin.token.length > 0 ? admin.token : void 0
   };
 }
+function validateAntigravity(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const a = raw;
+  if (typeof a["sandboxFailover"] !== "boolean") return void 0;
+  return { sandboxFailover: a["sandboxFailover"] };
+}
+function validateOpenCodeGo(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const o = raw;
+  const ua = o["userAgent"];
+  if (typeof ua !== "string" || ua.trim().length === 0) return void 0;
+  return { userAgent: ua.trim() };
+}
 function validateUsage(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
   const u = raw;
@@ -4242,7 +4599,9 @@ function validateConfig(raw) {
   const admin = validateAdmin(obj["admin"]);
   const logging = validateLogging(obj["logging"]);
   const usage = validateUsage(obj["usage"]);
-  return { providers, server, admin, logging };
+  const antigravity = validateAntigravity(obj["antigravity"]);
+  const opencodego = validateOpenCodeGo(obj["opencodego"]);
+  return { providers, server, admin, logging, usage, antigravity, opencodego };
 }
 var secretBox = null;
 function setSecretBox(box) {
@@ -5286,11 +5645,11 @@ function preserveOutboundProxySecrets(incoming, current) {
 }
 
 // src/proxy/upstreamProxyResolver.ts
-var import_upstreamFetch8 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_upstreamFetch9 = require("@omnicross/core/pipeline/upstreamFetch");
 var serverProxy;
 function setServerProxyConfig(proxy) {
   serverProxy = proxy;
-  (0, import_upstreamFetch8.bumpUpstreamProxyGeneration)();
+  (0, import_upstreamFetch9.bumpUpstreamProxyGeneration)();
 }
 function getServerProxyConfig() {
   return serverProxy;
@@ -5357,8 +5716,169 @@ function createUpstreamProxyResolver(src = {}) {
   };
 }
 
-// src/admin/accountsOAuth.ts
+// src/admin/accountsAntigravityOAuth.ts
+var import_GeminiCodeAssistProjectResolver3 = require("@omnicross/core/auth/GeminiCodeAssistProjectResolver");
 var import_subscriptions8 = require("@omnicross/subscriptions");
+function err5(status, message) {
+  return { status, body: { error: { type: "admin_api_error", message } } };
+}
+var DEFAULT_ANTIGRAVITY_OAUTH_TTL_MS = 10 * 6e4;
+function handleAntigravityOAuthStart(deps) {
+  if (deps.antigravitySessions.isBusy()) {
+    return err5(
+      409,
+      "an antigravity sign-in is already in progress (loopback 127.0.0.1:51121 is held) \u2014 finish it in the browser or wait for it to time out"
+    );
+  }
+  const { authUrl, state } = import_subscriptions8.antigravityOAuth.generateAuthParams();
+  const { sessionId, signal } = deps.antigravitySessions.begin();
+  void runAntigravityLoopback(sessionId, state, signal, deps);
+  return { status: 200, body: { authUrl, sessionId } };
+}
+async function runAntigravityLoopback(sessionId, state, signal, deps) {
+  const isPending = () => !signal.aborted && deps.antigravitySessions.get(sessionId)?.status === "pending";
+  try {
+    const code = await deps.antigravityAwaitLoopback(state, void 0, signal);
+    if (!isPending()) return;
+    const exchangeFetch = deps.oauthExchangeFetch("antigravity");
+    const result = await import_subscriptions8.antigravityOAuth.exchangeCodeForTokens(code, exchangeFetch);
+    if (!isPending()) return;
+    const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
+    const email = await import_subscriptions8.antigravityOAuth.fetchUserEmail(result.accessToken, exchangeFetch);
+    if (!isPending()) return;
+    const projectId = await (0, import_GeminiCodeAssistProjectResolver3.getAntigravityProjectResolver)().resolveProject(result.accessToken);
+    if (!isPending()) return;
+    const block = {
+      authMethod: "oauth",
+      status: "authorized",
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken,
+      expiresAt,
+      ...email ? { email } : {},
+      ...projectId ? { projectId } : {},
+      lastRefreshedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await deps.subscriptionAccountAppender.appendProviderAccount("antigravity", block);
+    if (isPending()) deps.antigravitySessions.settle(sessionId, "done");
+  } catch (e) {
+    if (!isPending()) return;
+    const reason = e instanceof Error ? e.message : "antigravity sign-in failed";
+    deps.antigravitySessions.settle(sessionId, "error", reason);
+  }
+}
+function handleAntigravityOAuthCancel(sessionId, deps) {
+  if (!deps.antigravitySessions.cancel(sessionId)) {
+    return err5(404, "unknown or expired antigravity sign-in session");
+  }
+  return { status: 200, body: { ok: true } };
+}
+function handleAntigravityOAuthStatus(sessionId, deps) {
+  const s = deps.antigravitySessions.get(sessionId);
+  if (!s) return err5(404, "unknown or expired antigravity sign-in session");
+  return { status: 200, body: { state: s.status, ...s.error ? { message: s.error } : {} } };
+}
+
+// src/allowance/AntigravityModelDiscovery.ts
+var import_canonical_models = require("@omnicross/contracts/canonical-models");
+var import_subscription_model_catalog = require("@omnicross/contracts/subscription-model-catalog");
+var import_GeminiCodeAssistProjectResolver4 = require("@omnicross/core/auth/GeminiCodeAssistProjectResolver");
+var import_upstreamFetch10 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_antigravityIdentity2 = require("@omnicross/core/transformer/transformers/antigravityIdentity");
+function isRecord6(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function parseAntigravityAvailableModels(payload) {
+  if (!isRecord6(payload)) return [];
+  const models = payload["models"];
+  if (!isRecord6(models)) return [];
+  const out = [];
+  for (const [id, raw] of Object.entries(models)) {
+    if (ANTIGRAVITY_DISCOVERY_DENYLIST.has(id)) continue;
+    if (!isRecord6(raw)) continue;
+    if (raw["isInternal"] === true) continue;
+    out.push({
+      id,
+      ...optionalString(raw["displayName"]) ? { displayName: optionalString(raw["displayName"]) } : {},
+      ...optionalBoolean(raw["supportsImages"]) !== void 0 ? { supportsImages: optionalBoolean(raw["supportsImages"]) } : {},
+      ...optionalBoolean(raw["supportsThinking"]) !== void 0 ? { supportsThinking: optionalBoolean(raw["supportsThinking"]) } : {},
+      ...optionalNumber(raw["thinkingBudget"]) !== void 0 ? { thinkingBudget: optionalNumber(raw["thinkingBudget"]) } : {},
+      ...optionalNumber(raw["maxTokens"]) !== void 0 ? { maxTokens: optionalNumber(raw["maxTokens"]) } : {},
+      ...optionalNumber(raw["maxOutputTokens"]) !== void 0 ? { maxOutputTokens: optionalNumber(raw["maxOutputTokens"]) } : {}
+    });
+  }
+  out.sort((a, b) => a.id.localeCompare(b.id));
+  return out;
+}
+function mergeAntigravityCatalog(discovered, log = (line) => console.warn(line), staticIds = import_subscription_model_catalog.SUBSCRIPTION_MODEL_CATALOG.antigravity) {
+  const entries = staticIds.map((id) => {
+    const capabilities = (0, import_canonical_models.lookupCanonicalCapabilities)(id);
+    return {
+      id,
+      origin: "static",
+      displayName: id,
+      ...capabilities?.vision !== void 0 ? { supportsImages: capabilities.vision } : {},
+      ...capabilities?.reasoning !== void 0 ? { supportsThinking: capabilities.reasoning } : {},
+      ...capabilities?.thinkingTokenLimit ? { thinkingBudget: capabilities.thinkingTokenLimit.max } : {},
+      // Discovery calls the context window maxTokens, not the output ceiling.
+      ...capabilities?.contextLength !== void 0 ? { maxTokens: capabilities.contextLength } : {},
+      ...capabilities?.maxTokens !== void 0 ? { maxOutputTokens: capabilities.maxTokens } : {}
+    };
+  });
+  const staticSet = new Set(staticIds);
+  for (const model of discovered) {
+    if (staticSet.has(model.id)) {
+      log(
+        `[AntigravityModelDiscovery] dynamic model '${model.id}' conflicts with the static catalog \u2014 static entry kept`
+      );
+      continue;
+    }
+    entries.push({ ...model, origin: "discovered" });
+  }
+  return entries;
+}
+async function fetchAntigravityAvailableModels(accessToken, fetchImpl = (url, init) => (0, import_upstreamFetch10.fetchUpstream)(url, init, { providerId: "antigravity", redactBodies: true })) {
+  let response;
+  try {
+    response = await fetchImpl(`${import_GeminiCodeAssistProjectResolver4.ANTIGRAVITY_CODE_ASSIST_ENDPOINT}/v1internal:fetchAvailableModels`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": (0, import_antigravityIdentity2.getAntigravityUserAgent)()
+      },
+      body: JSON.stringify({}),
+      signal: AbortSignal.timeout(15e3)
+    });
+  } catch {
+    return null;
+  }
+  if (!response.ok) return null;
+  const payload = await response.json().catch(() => null);
+  if (!isRecord6(payload) || !isRecord6(payload["models"])) return null;
+  return parseAntigravityAvailableModels(payload);
+}
+async function handleAntigravityModelsRoute(deps) {
+  const accessToken = await deps.resolveAntigravityAccessToken().catch(() => null);
+  const discovered = accessToken ? await fetchAntigravityAvailableModels(accessToken, deps.fetchImpl) : null;
+  const models = mergeAntigravityCatalog(discovered ?? []);
+  return {
+    status: 200,
+    body: { models, discovered: discovered !== null }
+  };
+}
+
+// src/admin/accountsOAuth.ts
+var import_subscriptions9 = require("@omnicross/subscriptions");
 
 // src/admin/accountsWrite.ts
 var VALID_PROVIDER_IDS = [
@@ -5368,7 +5888,8 @@ var VALID_PROVIDER_IDS = [
   "opencodego",
   "kimi",
   "grok",
-  "copilot"
+  "copilot",
+  "antigravity"
 ];
 function asSubscriptionProviderId(id) {
   return VALID_PROVIDER_IDS.includes(id) ? id : null;
@@ -5550,7 +6071,7 @@ function validateCopilot(body) {
   ]);
   return out;
 }
-function validateOpenCodeGo(body) {
+function validateOpenCodeGo2(body) {
   const authMethod = str(body["authMethod"]);
   const status = str(body["status"]);
   if (authMethod !== "manual") return null;
@@ -5584,7 +6105,7 @@ function validateTokenBody(providerId, body) {
     case "gemini":
       return validateGemini(body);
     case "opencodego":
-      return validateOpenCodeGo(body);
+      return validateOpenCodeGo2(body);
     case "kimi":
       return validateKimi(body);
     case "grok":
@@ -5620,37 +6141,37 @@ async function statusEntryFor(reader, providerId) {
 
 // src/admin/accountsOAuth.ts
 var OAUTH_HTTP_PROVIDERS = /* @__PURE__ */ new Set(["claude", "gemini"]);
-function err5(status, message) {
+function err6(status, message) {
   return { status, body: { error: { type: "admin_api_error", message } } };
 }
 function handleOAuthStart(providerId, deps) {
   if (!OAUTH_HTTP_PROVIDERS.has(providerId)) {
-    return err5(400, `oauth not available for provider '${providerId}'`);
+    return err6(400, `oauth not available for provider '${providerId}'`);
   }
-  const flow = providerId === "claude" ? import_subscriptions8.claudeOAuth : import_subscriptions8.geminiOAuth;
+  const flow = providerId === "claude" ? import_subscriptions9.claudeOAuth : import_subscriptions9.geminiOAuth;
   const { authUrl, codeVerifier, state } = flow.generateAuthParams();
   const sessionId = deps.oauthSessions.put({ providerId, codeVerifier, state });
   return { status: 200, body: { authUrl, sessionId } };
 }
 async function handleOAuthComplete(providerId, body, deps) {
   if (!OAUTH_HTTP_PROVIDERS.has(providerId)) {
-    return err5(400, `oauth not available for provider '${providerId}'`);
+    return err6(400, `oauth not available for provider '${providerId}'`);
   }
   const sessionId = typeof body["sessionId"] === "string" ? body["sessionId"] : "";
   const rawCode = typeof body["code"] === "string" ? body["code"] : "";
-  if (!sessionId) return err5(400, "oauth complete requires { sessionId }");
-  if (!rawCode) return err5(400, "oauth complete requires { code }");
+  if (!sessionId) return err6(400, "oauth complete requires { sessionId }");
+  if (!rawCode) return err6(400, "oauth complete requires { code }");
   const session = deps.oauthSessions.peek(sessionId);
-  if (!session) return err5(410, "oauth session is unknown, expired, or already used");
+  if (!session) return err6(410, "oauth session is unknown, expired, or already used");
   if (session.providerId !== providerId) {
-    return err5(400, `oauth session does not match provider '${providerId}'`);
+    return err6(400, `oauth session does not match provider '${providerId}'`);
   }
   let code = rawCode.trim();
   if (providerId === "claude") {
     const [splitCode, pastedState] = code.split("#");
-    if (!splitCode) return err5(400, "no authorization code was provided");
+    if (!splitCode) return err6(400, "no authorization code was provided");
     if (pastedState && pastedState !== session.state) {
-      return err5(400, "oauth state did not match (possible CSRF) \u2014 aborting");
+      return err6(400, "oauth state did not match (possible CSRF) \u2014 aborting");
     }
     code = splitCode;
   }
@@ -5660,7 +6181,7 @@ async function handleOAuthComplete(providerId, body, deps) {
     block = providerId === "claude" ? await exchangeClaude(code, session.codeVerifier, session.state, exchangeFetch) : await exchangeGemini(code, session.codeVerifier, exchangeFetch);
   } catch (exchangeError) {
     const reason = exchangeError instanceof Error ? exchangeError.message : "token exchange failed";
-    return err5(502, `oauth token exchange failed for '${providerId}': ${reason}`);
+    return err6(502, `oauth token exchange failed for '${providerId}': ${reason}`);
   }
   deps.oauthSessions.consume(sessionId);
   const label = typeof body["label"] === "string" && body["label"].trim() ? body["label"].trim() : void 0;
@@ -5669,7 +6190,7 @@ async function handleOAuthComplete(providerId, body, deps) {
   return { status: 200, body: status ? { account: status } : { ok: true } };
 }
 async function exchangeClaude(code, codeVerifier, state, exchangeFetch) {
-  const result = await import_subscriptions8.claudeOAuth.exchangeCodeForTokens(
+  const result = await import_subscriptions9.claudeOAuth.exchangeCodeForTokens(
     { authorizationCode: code, codeVerifier, state },
     exchangeFetch
   );
@@ -5685,7 +6206,7 @@ async function exchangeClaude(code, codeVerifier, state, exchangeFetch) {
   };
 }
 async function exchangeGemini(code, codeVerifier, exchangeFetch) {
-  const result = await import_subscriptions8.geminiOAuth.exchangeCodeForTokens(code, codeVerifier, exchangeFetch);
+  const result = await import_subscriptions9.geminiOAuth.exchangeCodeForTokens(code, codeVerifier, exchangeFetch);
   const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
   return {
     authMethod: "oauth",
@@ -5990,8 +6511,8 @@ function errBody(message) {
   return { error: { type: "admin_api_error", message } };
 }
 var defaultCommandRunner = (command) => new Promise((resolve11) => {
-  (0, import_node_child_process.exec)(command, { timeout: 18e4 }, (err8, _stdout, stderr) => {
-    if (err8) resolve11({ ok: false, error: stderr.trim() || err8.message });
+  (0, import_node_child_process.exec)(command, { timeout: 18e4 }, (err9, _stdout, stderr) => {
+    if (err9) resolve11({ ok: false, error: stderr.trim() || err9.message });
     else resolve11({ ok: true });
   });
 });
@@ -6037,8 +6558,8 @@ async function handleCliLaunch(cli, body, ctx) {
       providerId: typeof body["providerId"] === "string" ? body["providerId"] : void 0,
       model: typeof body["model"] === "string" ? body["model"] : void 0
     });
-  } catch (err8) {
-    return { status: 400, body: errBody(err8 instanceof Error ? err8.message : "no launch target") };
+  } catch (err9) {
+    return { status: 400, body: errBody(err9 instanceof Error ? err9.message : "no launch target") };
   }
   const id = (0, import_node_crypto7.randomUUID)();
   let leaseId2;
@@ -6066,9 +6587,9 @@ async function handleCliLaunch(cli, body, ctx) {
     } else {
       launch = await buildLaunchEnv(cli, ctx.llmConfig, target);
     }
-  } catch (err8) {
-    const status = err8 instanceof import_provider_proxy2.RouteLeaseError ? err8.status : 400;
-    return { status, body: errBody(err8 instanceof Error ? err8.message : "failed to build launch env") };
+  } catch (err9) {
+    const status = err9 instanceof import_provider_proxy2.RouteLeaseError ? err9.status : 400;
+    return { status, body: errBody(err9 instanceof Error ? err9.message : "failed to build launch env") };
   }
   const cwd = typeof body["cwd"] === "string" && body["cwd"].trim() ? body["cwd"].trim() : void 0;
   const opener = ctx.opener ?? defaultTerminalOpener;
@@ -6096,9 +6617,9 @@ async function handleCliLaunch(cli, body, ctx) {
       onFailure: onSessionEnd
     });
     if (cleanup) openerCleanup = cleanup;
-  } catch (err8) {
+  } catch (err9) {
     onSessionEnd();
-    return { status: 500, body: errBody(err8 instanceof Error ? err8.message : "failed to open terminal") };
+    return { status: 500, body: errBody(err9 instanceof Error ? err9.message : "failed to open terminal") };
   }
   if (ended) {
     openerCleanup?.();
@@ -6353,7 +6874,7 @@ async function runSearchLiveChecks(contributions, now = () => (/* @__PURE__ */ n
 }
 
 // src/search/SearchAssembly.ts
-var import_upstreamFetch9 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_upstreamFetch11 = require("@omnicross/core/pipeline/upstreamFetch");
 var import_search = require("@omnicross/core/search");
 var import_api2 = require("@omnicross/core/search/api");
 var import_http2 = require("@omnicross/core/search/http");
@@ -6371,7 +6892,7 @@ function searchPolicyFrom(config) {
   };
 }
 function resolveSearchUpstreamDispatcher(url) {
-  return (0, import_upstreamFetch9.resolveUpstreamDispatcher)({ url });
+  return (0, import_upstreamFetch11.resolveUpstreamDispatcher)({ url });
 }
 var searchUpstreamProxyConfig = createUpstreamProxyResolver();
 function resolveSearchUpstreamProxyConfig(url) {
@@ -6653,7 +7174,7 @@ async function handleSearchQuery(req, res, deps) {
 // src/admin/searchAdminView.ts
 var API_KEY_PROVIDERS = /* @__PURE__ */ new Set(["tavily", "jina", "zhipu", "z.ai"]);
 var BASIC_AUTH_PROVIDERS = /* @__PURE__ */ new Set(["searxng"]);
-function isRecord5(value) {
+function isRecord7(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function redactSearchServerConfig(search) {
@@ -6703,13 +7224,13 @@ function resolveSecretField(entry, field, stored) {
   else delete entry[field];
 }
 function preserveSearchSecrets(incoming, current) {
-  if (!isRecord5(incoming)) return incoming;
+  if (!isRecord7(incoming)) return incoming;
   const section = { ...incoming };
   const providersValue = section["providers"];
-  if (!isRecord5(providersValue)) return section;
+  if (!isRecord7(providersValue)) return section;
   const providers = {};
   for (const [id, entryValue] of Object.entries(providersValue)) {
-    if (!isRecord5(entryValue)) {
+    if (!isRecord7(entryValue)) {
       providers[id] = entryValue;
       continue;
     }
@@ -6787,7 +7308,7 @@ function parseKeyPolicyBody(body) {
 var ENDPOINTS = /* @__PURE__ */ new Set(["chat", "responses", "messages", "gemini"]);
 var TARGET_KINDS = /* @__PURE__ */ new Set(["account", "account-group", "account-pool", "provider"]);
 var FALLBACKS = /* @__PURE__ */ new Set(["next", "fail", "global"]);
-function isRecord6(value) {
+function isRecord8(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function nonBlank(value) {
@@ -6807,7 +7328,7 @@ function validateGatewayBindingsSegment(patch) {
   const ids = /* @__PURE__ */ new Set();
   raw.forEach((entry, index) => {
     const path2 = `bindings[${index}]`;
-    if (!isRecord6(entry)) {
+    if (!isRecord8(entry)) {
       errors.push(`${path2} must be an object`);
       return;
     }
@@ -6836,12 +7357,12 @@ function validateGatewayBindingsSegment(patch) {
       } else if (entry.modelMappings.length > 100) {
         errors.push(`${path2}.modelMappings cannot contain more than 100 entries`);
       } else if (entry.modelMappings.some(
-        (mapping) => !isRecord6(mapping) || !nonBlank(mapping.source) || !nonBlank(mapping.target)
+        (mapping) => !isRecord8(mapping) || !nonBlank(mapping.source) || !nonBlank(mapping.target)
       )) {
         errors.push(`${path2}.modelMappings must contain non-empty source and target strings`);
       }
     }
-    if (!isRecord6(entry.target) || !TARGET_KINDS.has(String(entry.target.kind))) {
+    if (!isRecord8(entry.target) || !TARGET_KINDS.has(String(entry.target.kind))) {
       errors.push(`${path2}.target is invalid`);
     } else {
       if (!nonBlank(entry.target.providerId)) errors.push(`${path2}.target.providerId is required`);
@@ -6856,7 +7377,7 @@ function validateGatewayBindingsSegment(patch) {
       }
     }
     if (entry.modelMap !== void 0) {
-      if (!isRecord6(entry.modelMap) || Object.values(entry.modelMap).some((value) => typeof value !== "string")) {
+      if (!isRecord8(entry.modelMap) || Object.values(entry.modelMap).some((value) => typeof value !== "string")) {
         errors.push(`${path2}.modelMap must contain string values`);
       }
     }
@@ -7141,7 +7662,12 @@ var PROVIDER_KEYS = {
   },
   kimi: { block: "kimi", accounts: "kimiAccounts", active: "activeKimiAccountId" },
   grok: { block: "grok", accounts: "grokAccounts", active: "activeGrokAccountId" },
-  copilot: { block: "copilot", accounts: "copilotAccounts", active: "activeCopilotAccountId" }
+  copilot: { block: "copilot", accounts: "copilotAccounts", active: "activeCopilotAccountId" },
+  antigravity: {
+    block: "antigravity",
+    accounts: "antigravityAccounts",
+    active: "activeAntigravityAccountId"
+  }
 };
 function clone(value) {
   return JSON.parse(JSON.stringify(value));
@@ -7663,7 +8189,7 @@ async function applyImport(packString, passphrase, mode, deps, parseProviderInpu
 }
 
 // src/admin/adminMigration.ts
-function err6(status, message) {
+function err7(status, message) {
   return { status, body: { error: { type: "admin_api_error", message } } };
 }
 async function handleExport(body, deps) {
@@ -7673,30 +8199,30 @@ async function handleExport(body, deps) {
     return { status: 200, body: { pack, version: BUNDLE_VERSION } };
   } catch (error) {
     if (error instanceof WeakPassphraseError) {
-      return err6(400, error.message);
+      return err7(400, error.message);
     }
-    return err6(500, "failed to build the migration pack");
+    return err7(500, "failed to build the migration pack");
   }
 }
 async function handleImport(body, deps) {
   const blob = typeof body["blob"] === "string" ? body["blob"] : "";
   const passphrase = typeof body["passphrase"] === "string" ? body["passphrase"] : "";
   const mode = body["mode"] === "overwrite" ? "overwrite" : "merge";
-  if (!blob) return err6(400, "import requires { blob }");
+  if (!blob) return err7(400, "import requires { blob }");
   try {
     const counts = await applyImport(blob, passphrase, mode, deps, deps.parseProviderInput);
     return { status: 200, body: counts };
   } catch (error) {
     if (error instanceof WeakPassphraseError) {
-      return err6(400, error.message);
+      return err7(400, error.message);
     }
-    return err6(400, error instanceof Error ? error.message : "import failed");
+    return err7(400, error instanceof Error ? error.message : "import failed");
   }
 }
 
 // src/admin/usagePricing.ts
 var import_usage = require("@omnicross/core/usage");
-var err7 = (status, message) => ({
+var err8 = (status, message) => ({
   status,
   body: { error: { type: "admin_api_error", message } }
 });
@@ -7709,7 +8235,7 @@ function parseRange(query2) {
   const startTs = parseFiniteInt(query2.get("startTs"));
   const endTs = parseFiniteInt(query2.get("endTs"));
   if (startTs === null || endTs === null) {
-    return err7(400, "startTs and endTs are required finite-integer unix-millis query params");
+    return err8(400, "startTs and endTs are required finite-integer unix-millis query params");
   }
   return { startTs, endTs };
 }
@@ -7734,14 +8260,14 @@ async function handleUsageGet(view, query2, deps) {
     case "timeseries": {
       const bucket = query2.get("bucket");
       if (bucket !== "hour" && bucket !== "day" && bucket !== "month") {
-        return err7(400, "bucket must be one of 'hour', 'day', 'month'");
+        return err8(400, "bucket must be one of 'hour', 'day', 'month'");
       }
       const now = Date.now();
       const clamped = { startTs: range.startTs, endTs: Math.min(range.endTs, now) };
       if (clamped.startTs < clamped.endTs) {
         const projected = Math.ceil((clamped.endTs - clamped.startTs) / BUCKET_SPAN_MS[bucket]) + 1;
         if (projected > MAX_TIMESERIES_BUCKETS) {
-          return err7(
+          return err8(
             400,
             `requested range projects ~${projected} '${bucket}' buckets (max ${MAX_TIMESERIES_BUCKETS}); narrow the range or use a coarser bucket`
           );
@@ -7764,7 +8290,7 @@ async function handleUsageGet(view, query2, deps) {
       };
     }
     default:
-      return err7(404, `unknown usage view '${view ?? ""}'`);
+      return err8(404, `unknown usage view '${view ?? ""}'`);
   }
 }
 function poolKeyLabels(cfg) {
@@ -7813,7 +8339,7 @@ async function handlePricingList(deps) {
 async function handlePricingUpsert(body, deps) {
   const input = parsePricingEntryInput(body);
   if (!input) {
-    return err7(400, "invalid pricing entry (providerId, modelId, finite numeric inputPricePer1m/outputPricePer1m required)");
+    return err8(400, "invalid pricing entry (providerId, modelId, finite numeric inputPricePer1m/outputPricePer1m required)");
   }
   const entry = await deps.pricingEngine.upsertManual(input);
   return { status: 200, body: { entry } };
@@ -7822,7 +8348,7 @@ async function handlePricingDelete(query2, deps) {
   const providerId = query2.get("providerId")?.trim() ?? "";
   const modelId = query2.get("modelId")?.trim() ?? "";
   if (!providerId || !modelId) {
-    return err7(400, "delete requires providerId and modelId query params");
+    return err8(400, "delete requires providerId and modelId query params");
   }
   const deleted = await deps.pricingStore.delete(providerId, modelId);
   if (deleted) await deps.pricingEngine.invalidateCache();
@@ -7842,13 +8368,13 @@ async function handlePricingFetchLatest(deps) {
       }
     };
   } catch (e) {
-    return err7(502, `pricing-source fetch failed: ${e instanceof Error ? e.message : String(e)}`);
+    return err8(502, `pricing-source fetch failed: ${e instanceof Error ? e.message : String(e)}`);
   }
 }
 async function handlePricingResolveConflicts(body, deps) {
   const raw = body["resolutions"];
   if (!Array.isArray(raw)) {
-    return err7(400, "resolve-conflicts requires { resolutions: [...] }");
+    return err8(400, "resolve-conflicts requires { resolutions: [...] }");
   }
   const currentRows = await deps.pricingStore.getAll();
   const userEditedKeys = new Set(
@@ -7858,21 +8384,21 @@ async function handlePricingResolveConflicts(body, deps) {
   const pendingIncoming = /* @__PURE__ */ new Map();
   let staleCount = 0;
   for (const item of raw) {
-    if (!item || typeof item !== "object") return err7(400, "invalid resolution entry");
+    if (!item || typeof item !== "object") return err8(400, "invalid resolution entry");
     const r = item;
     const action = r["action"];
     if (action !== "overwrite" && action !== "skip") {
-      return err7(400, "resolution action must be 'overwrite' or 'skip'");
+      return err8(400, "resolution action must be 'overwrite' or 'skip'");
     }
     const providerId = typeof r["providerId"] === "string" && r["providerId"].trim() ? r["providerId"].trim() : "";
     const modelId = typeof r["modelId"] === "string" && r["modelId"].trim() ? r["modelId"].trim() : "";
     if (!providerId || !modelId) {
-      return err7(400, "each resolution requires top-level providerId and modelId");
+      return err8(400, "each resolution requires top-level providerId and modelId");
     }
     const incoming = parsePricingEntryInput(r["incoming"]);
-    if (!incoming) return err7(400, "each resolution must echo a valid incoming pricing entry");
+    if (!incoming) return err8(400, "each resolution must echo a valid incoming pricing entry");
     if (incoming.providerId !== providerId || incoming.modelId !== modelId) {
-      return err7(400, "resolution providerId/modelId must match the echoed incoming entry");
+      return err8(400, "resolution providerId/modelId must match the echoed incoming entry");
     }
     const key = `${providerId}::${modelId}`;
     if (action === "overwrite" && !userEditedKeys.has(key)) {
@@ -7917,7 +8443,7 @@ function query(req) {
 }
 function allowanceProvider(value) {
   if (!value) return void 0;
-  return value === "claude" || value === "codex" || value === "kimi" || value === "opencodego" || value === "grok" || value === "copilot" || value === "gemini" ? value : null;
+  return value === "claude" || value === "codex" || value === "kimi" || value === "opencodego" || value === "grok" || value === "copilot" || value === "gemini" || value === "antigravity" ? value : null;
 }
 async function handleAccountAllowanceApi(req, res, method, rest, service) {
   if (!service) return writeError2(res, 501, "account allowance service is not available");
@@ -7994,6 +8520,16 @@ async function handleAccountAllowanceApi(req, res, method, rest, service) {
       }
       return writeJson3(res, 200, { allowances: allowances2 });
     }
+    if (requestedProvider === "antigravity") {
+      if (!service.refreshAntigravity) {
+        return writeError2(res, 501, "antigravity allowance refresh is not available");
+      }
+      const allowances2 = await service.refreshAntigravity(accountId);
+      if (accountId && allowances2.length === 0) {
+        return writeError2(res, 404, `Antigravity account '${accountId}' not found`);
+      }
+      return writeJson3(res, 200, { allowances: allowances2 });
+    }
     if (requestedProvider === "gemini") {
       if (!service.refreshGemini) {
         return writeError2(res, 501, "gemini allowance refresh is not available");
@@ -8148,7 +8684,7 @@ async function handleAdminApi(req, res, path2, deps) {
       case "server":
         return await handleServer(req, res, method, deps);
       case "images":
-        return await handleImages(res, method, rest, deps);
+        return await handleImages(req, res, method, rest, deps);
       case "search":
         return await handleSearchAdmin(req, res, method, rest, deps);
       case "accounts":
@@ -8174,8 +8710,8 @@ async function handleAdminApi(req, res, path2, deps) {
       default:
         return writeJsonError(res, 404, `unknown admin resource '${resource}'`);
     }
-  } catch (err8) {
-    writeJsonError(res, 500, err8 instanceof Error ? err8.message : String(err8));
+  } catch (err9) {
+    writeJsonError(res, 500, err9 instanceof Error ? err9.message : String(err9));
   }
 }
 function requestQuery(req) {
@@ -8350,7 +8886,7 @@ async function handleDiscoverModels(res, id, cfg) {
     const headers = { Accept: "application/json" };
     if (resolvedKey) headers["Authorization"] = `Bearer ${resolvedKey}`;
     Object.assign(headers, expandRowExtraHeaders(row));
-    const response = await (0, import_upstreamFetch10.fetchUpstream)(url, { method: "GET", headers }, { providerId: "byo" });
+    const response = await (0, import_upstreamFetch12.fetchUpstream)(url, { method: "GET", headers }, { providerId: "byo" });
     if (!response.ok) {
       const text = await response.text().catch(() => "");
       let message = text.slice(0, 300);
@@ -8367,8 +8903,8 @@ async function handleDiscoverModels(res, id, cfg) {
     const data = await response.json();
     const models = Array.isArray(data?.data) ? data.data.map((m) => typeof m?.id === "string" ? m.id : "").filter((m) => m.length > 0) : [];
     return writeJson4(res, 200, { models });
-  } catch (err8) {
-    const message = err8 instanceof Error ? err8.message : String(err8);
+  } catch (err9) {
+    const message = err9 instanceof Error ? err9.message : String(err9);
     return writeJson4(res, 200, { models: [], error: `discovery failed: ${message}` });
   }
 }
@@ -8410,7 +8946,7 @@ async function handleTestModel(req, res, id, cfg) {
   Object.assign(headers, expandRowExtraHeaders(row));
   const startedAt = Date.now();
   try {
-    const response = await (0, import_upstreamFetch10.fetchUpstream)(
+    const response = await (0, import_upstreamFetch12.fetchUpstream)(
       url,
       { method: "POST", headers, body: JSON.stringify(payload) },
       { providerId: "byo" }
@@ -8432,8 +8968,8 @@ async function handleTestModel(req, res, id, cfg) {
       latencyMs,
       sample: extractSampleText(text, row.apiFormat)
     });
-  } catch (err8) {
-    const message = err8 instanceof Error ? err8.message : String(err8);
+  } catch (err9) {
+    const message = err9 instanceof Error ? err9.message : String(err9);
     return writeJson4(res, 200, { ok: false, latencyMs: Date.now() - startedAt, message });
   }
 }
@@ -9018,8 +9554,8 @@ function imageConfigurationAuditFields(previous, next) {
   const after = next ?? import_outbound_api5.DEFAULT_IMAGES_SERVER_CONFIG;
   const fields = [];
   if (before.enabled !== after.enabled) fields.push("enablement");
-  if (before.provider !== after.provider) fields.push("provider");
-  if (before.defaultModel !== after.defaultModel || !sameConfigValue(before.modelAliases, after.modelAliases)) fields.push("model");
+  if (!sameConfigValue(before.models, after.models)) fields.push("provider");
+  if (before.defaultModel !== after.defaultModel || !sameConfigValue(before.aliases, after.aliases) || !sameConfigValue(before.codex, after.codex)) fields.push("model");
   if (!sameConfigValue(before.account, after.account)) fields.push("account");
   if (!sameConfigValue(before.queue, after.queue)) fields.push("queue");
   if (!sameConfigValue(before.temporary, after.temporary)) fields.push("temporary");
@@ -9223,6 +9759,12 @@ async function handleAccounts(req, res, method, rest, deps) {
       deps.accountAllowanceService
     );
   }
+  if (method === "GET" && rest[0] === "antigravity" && rest[1] === "models") {
+    const result = await handleAntigravityModelsRoute({
+      resolveAntigravityAccessToken: deps.resolveAntigravityAccessToken ?? (async () => null)
+    });
+    return writeJson4(res, result.status, result.body);
+  }
   if (method === "GET" && rest.length === 0) {
     const accounts = await deps.subscriptionAccounts.listAll();
     const providerAccounts = await deps.subscriptionTokenWriter.listSanitizedAccounts();
@@ -9248,12 +9790,12 @@ async function handleAccounts(req, res, method, rest, deps) {
     }
     return writeJson4(res, 200, { ok: true, affected: result.affected });
   }
-  if (method === "GET" && (rest[0] === "codex" || rest[0] === "kimi" || rest[0] === "grok" || rest[0] === "copilot") && rest[1] === "oauth" && rest[3] === "status") {
-    const result = rest[0] === "codex" ? handleCodexOAuthStatus(rest[2], deps) : rest[0] === "kimi" ? handleKimiOAuthStatus(rest[2], deps) : rest[0] === "grok" ? handleGrokOAuthStatus(rest[2], deps) : handleCopilotOAuthStatus(rest[2], deps);
+  if (method === "GET" && (rest[0] === "codex" || rest[0] === "kimi" || rest[0] === "grok" || rest[0] === "copilot" || rest[0] === "antigravity") && rest[1] === "oauth" && rest[3] === "status") {
+    const result = rest[0] === "codex" ? handleCodexOAuthStatus(rest[2], deps) : rest[0] === "kimi" ? handleKimiOAuthStatus(rest[2], deps) : rest[0] === "grok" ? handleGrokOAuthStatus(rest[2], deps) : rest[0] === "copilot" ? handleCopilotOAuthStatus(rest[2], deps) : handleAntigravityOAuthStatus(rest[2], deps);
     return writeJson4(res, result.status, result.body);
   }
-  if (method === "DELETE" && (rest[0] === "codex" || rest[0] === "kimi" || rest[0] === "grok" || rest[0] === "copilot") && rest[1] === "oauth" && rest[2]) {
-    const result = rest[0] === "codex" ? handleCodexOAuthCancel(rest[2], deps) : rest[0] === "kimi" ? handleKimiOAuthCancel(rest[2], deps) : rest[0] === "grok" ? handleGrokOAuthCancel(rest[2], deps) : handleCopilotOAuthCancel(rest[2], deps);
+  if (method === "DELETE" && (rest[0] === "codex" || rest[0] === "kimi" || rest[0] === "grok" || rest[0] === "copilot" || rest[0] === "antigravity") && rest[1] === "oauth" && rest[2]) {
+    const result = rest[0] === "codex" ? handleCodexOAuthCancel(rest[2], deps) : rest[0] === "kimi" ? handleKimiOAuthCancel(rest[2], deps) : rest[0] === "grok" ? handleGrokOAuthCancel(rest[2], deps) : rest[0] === "copilot" ? handleCopilotOAuthCancel(rest[2], deps) : handleAntigravityOAuthCancel(rest[2], deps);
     return writeJson4(res, result.status, result.body);
   }
   if (method === "GET" && rest.length === 3 && rest[2] === "diagnostics") {
@@ -9323,6 +9865,10 @@ async function handleAccounts(req, res, method, rest, deps) {
         const result2 = await handleCopilotOAuthStart(deps, body2["enterpriseUrl"]);
         return writeJson4(res, result2.status, result2.body);
       }
+      if (providerId === "antigravity") {
+        const result2 = handleAntigravityOAuthStart(deps);
+        return writeJson4(res, result2.status, result2.body);
+      }
       const result = handleOAuthStart(providerId, deps);
       return writeJson4(res, result.status, result.body);
     }
@@ -9685,7 +10231,41 @@ function imageEndpointUrls(base) {
     edits: `${base}/v1/images/edits`
   }) : null;
 }
-async function handleImages(res, method, rest, deps) {
+function imageProviderEvidence(images, capabilities) {
+  const evidenceAt = safeStatusTimestamp(capabilities?.oldestEvidenceAt);
+  const resolvedAt = safeStatusTimestamp(capabilities?.resolvedAt);
+  if (evidenceAt === void 0 || resolvedAt === void 0) return null;
+  const expiresAt = evidenceAt <= Number.MAX_SAFE_INTEGER - images.evidenceTtlMs ? evidenceAt + images.evidenceTtlMs : void 0;
+  return Object.freeze({
+    verifiedAt: evidenceAt,
+    ageMs: Math.max(0, resolvedAt - evidenceAt),
+    ...expiresAt !== void 0 ? { expiresAt } : {}
+  });
+}
+async function handleImagesVerifyLive(req, res, deps) {
+  const verifier = deps.imageLiveVerifier;
+  if (!verifier) {
+    return writeJsonError(res, 501, "Images live verification is not available");
+  }
+  const serverConfig = await (0, import_outbound_api5.loadServerConfig)(deps.settingsStore);
+  const images = serverConfig.images ?? import_outbound_api5.DEFAULT_IMAGES_SERVER_CONFIG;
+  req.resume();
+  const controller = new AbortController();
+  req.on("close", () => controller.abort());
+  const result = await verifier.verifyLive(images, controller.signal);
+  const antigravityRouted = Object.values(images.models).includes("antigravity-subscription");
+  return writeJson4(res, 200, {
+    ...result,
+    ...antigravityRouted ? { antigravityDeferred: true } : {}
+  });
+}
+async function handleImages(req, res, method, rest, deps) {
+  if (rest.length === 1 && rest[0] === "verify-live") {
+    if (method !== "POST") {
+      return writeJsonError(res, 405, `method ${method} not allowed on Images verify-live`);
+    }
+    return handleImagesVerifyLive(req, res, deps);
+  }
   if (rest.length !== 1 || rest[0] !== "capabilities") {
     return writeJsonError(res, 404, "unknown Images admin resource");
   }
@@ -9700,14 +10280,14 @@ async function handleImages(res, method, rest, deps) {
   const capability = await reader.inspectCapability(IMAGE_ADMIN_STATUS_TENANT);
   const resources = safeRuntimeResources(reader.resourceStatus());
   const outbound = deps.outboundApiServer.getStatus();
-  const evidenceAt = safeStatusTimestamp(capability.capabilities?.oldestEvidenceAt);
-  const resolvedAt = safeStatusTimestamp(capability.capabilities?.resolvedAt);
-  const expiresAt = evidenceAt !== void 0 && evidenceAt <= Number.MAX_SAFE_INTEGER - images.evidenceTtlMs ? evidenceAt + images.evidenceTtlMs : void 0;
-  const evidence = evidenceAt !== void 0 && resolvedAt !== void 0 ? Object.freeze({
-    verifiedAt: evidenceAt,
-    ageMs: Math.max(0, resolvedAt - evidenceAt),
-    ...expiresAt !== void 0 ? { expiresAt } : {}
-  }) : null;
+  const evidence = imageProviderEvidence(images, capability.capabilities);
+  const providers = (capability.providers ?? []).map((provider) => Object.freeze({
+    providerId: provider.providerId,
+    available: provider.available === true,
+    reason: provider.available ? null : safeImageCapabilityReason(provider.reason),
+    models: Object.freeze([...provider.models]),
+    evidence: imageProviderEvidence(images, provider.capabilities)
+  }));
   const draining = lifecycle.draining.map((generation) => Object.freeze({
     generationId: safeImageGenerationId(generation.generationId),
     enabled: generation.enabled,
@@ -9717,7 +10297,7 @@ async function handleImages(res, method, rest, deps) {
   return writeJson4(res, 200, {
     configured: {
       enabled: images.enabled,
-      provider: images.provider,
+      provider: images.models[images.defaultModel] ?? "codex-subscription",
       model: images.defaultModel,
       remoteUrlsEnabled: images.remote.enabled,
       referenceTtlMs: images.references.ttlMs
@@ -9728,6 +10308,7 @@ async function handleImages(res, method, rest, deps) {
       evidence,
       features: safeCapabilityValues(capability.capabilities, images.defaultModel)
     },
+    providers,
     runtime: {
       disposed: lifecycle.disposed,
       generationId: safeImageGenerationId(lifecycle.current.generationId),
@@ -9817,12 +10398,12 @@ async function handlePlayground(req, res, method, deps) {
   const payload = body["body"];
   const status = deps.outboundApiServer.getStatus();
   if (!status.running || !status.port) return writeJsonError(res, 503, "outbound server not running");
-  const path2 = resolvePlaygroundPath(endpoint, isRecord7(payload) ? payload : {});
+  const path2 = resolvePlaygroundPath(endpoint, isRecord9(payload) ? payload : {});
   if (!path2) return writeJsonError(res, 400, `unknown endpoint '${endpoint}'`);
   const upstreamBody = typeof payload === "string" ? payload : JSON.stringify(payload ?? {});
   await proxyToOutbound(res, status.port, path2, key, upstreamBody);
 }
-function isRecord7(v) {
+function isRecord9(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 function proxyToOutbound(res, outboundPort, path2, key, body) {
@@ -9851,8 +10432,8 @@ function proxyToOutbound(res, outboundPort, path2, key, body) {
         });
       }
     );
-    upstream.on("error", (err8) => {
-      if (!res.headersSent) writeJsonError(res, 502, `playground proxy failed: ${err8.message}`);
+    upstream.on("error", (err9) => {
+      if (!res.headersSent) writeJsonError(res, 502, `playground proxy failed: ${err9.message}`);
       else res.end();
       resolve11();
     });
@@ -9958,7 +10539,7 @@ async function handleUiStatic(req, res, urlPath, uiDist) {
 }
 
 // src/admin/version.ts
-var DAEMON_VERSION = true ? "0.4.2" : "0.0.0-dev";
+var DAEMON_VERSION = true ? "0.4.4" : "0.0.0-dev";
 
 // src/admin/AdminServer.ts
 var LOOPBACK_ADDR = "127.0.0.1";
@@ -10001,13 +10582,13 @@ var AdminServer = class {
       const server = import_node_http2.default.createServer((req, res) => {
         this.onRequest(req, res);
       });
-      const onError = (err8) => {
-        if (err8.code === "EADDRINUSE" && port !== 0) {
+      const onError = (err9) => {
+        if (err9.code === "EADDRINUSE" && port !== 0) {
           server.removeListener("error", onError);
           this.listen(bindAddr, 0).then(resolve11, reject);
           return;
         }
-        reject(err8);
+        reject(err9);
       };
       server.on("error", onError);
       server.listen(port, bindAddr, () => {
@@ -10025,8 +10606,8 @@ var AdminServer = class {
   }
   /** Per-request handler: auth gate (when a token is set) → routing. */
   onRequest(req, res) {
-    void this.dispatch(req, res).catch((err8) => {
-      const message = err8 instanceof Error ? err8.message : String(err8);
+    void this.dispatch(req, res).catch((err9) => {
+      const message = err9 instanceof Error ? err9.message : String(err9);
       this.deps.logger.error("[AdminServer] unhandled error:", message);
       if (!res.headersSent) {
         res.writeHead(500, { "Content-Type": "application/json" });
@@ -10249,7 +10830,10 @@ var HTML_HEADERS = {
 function pageHtml(message) {
   return `<!doctype html><meta charset="utf-8"><title>omnicross login</title><body style="font-family:sans-serif;padding:2rem"><h2>${message}</h2><p>You can close this window and return to the terminal.</p></body>`;
 }
-function awaitLoopbackCode(expectedState, timeoutMs = DEFAULT_TIMEOUT_MS, signal) {
+function awaitLoopbackCode(expectedState, timeoutMs = DEFAULT_TIMEOUT_MS, signal, binding = {}) {
+  const port = binding.port ?? LOOPBACK_PORT;
+  const callbackPath = binding.path ?? CALLBACK_PATH;
+  const label = binding.label ?? "codex";
   return new Promise((resolve11, reject) => {
     let settled = false;
     const finish = (server2, fn) => {
@@ -10260,8 +10844,8 @@ function awaitLoopbackCode(expectedState, timeoutMs = DEFAULT_TIMEOUT_MS, signal
       server2.close();
     };
     const server = (0, import_node_http3.createServer)((req, res) => {
-      const url = new URL(req.url ?? "", `http://${LOOPBACK_HOST}:${LOOPBACK_PORT}`);
-      if (url.pathname !== CALLBACK_PATH) {
+      const url = new URL(req.url ?? "", `http://${LOOPBACK_HOST}:${port}`);
+      if (url.pathname !== callbackPath) {
         res.writeHead(404, HTML_HEADERS);
         res.end(pageHtml("Not found"));
         return;
@@ -10290,25 +10874,25 @@ function awaitLoopbackCode(expectedState, timeoutMs = DEFAULT_TIMEOUT_MS, signal
       return;
     }
     signal?.addEventListener("abort", abort, { once: true });
-    server.on("error", (err8) => {
+    server.on("error", (err9) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      if (err8.code === "EADDRINUSE") {
+      if (err9.code === "EADDRINUSE") {
         reject(
           new Error(
-            `login: cannot bind ${LOOPBACK_HOST}:${LOOPBACK_PORT} (address in use) \u2014 another codex login or process is holding the port`
+            `login: cannot bind ${LOOPBACK_HOST}:${port} (address in use) \u2014 another ${label} login or process is holding the port`
           )
         );
       } else {
-        reject(err8);
+        reject(err9);
       }
     });
     const timer = setTimeout(() => {
       finish(server, () => reject(new Error(`login: timed out after ${Math.round(timeoutMs / 1e3)}s waiting for the callback`)));
     }, timeoutMs);
     if (typeof timer.unref === "function") timer.unref();
-    server.listen(LOOPBACK_PORT, LOOPBACK_HOST);
+    server.listen(port, LOOPBACK_HOST);
   });
 }
 
@@ -10378,7 +10962,7 @@ function createPoolKeysLoader(getProviderRow, autoDisabled) {
 
 // src/allowance/ProviderKeyQuotaService.ts
 var import_core4 = require("@omnicross/core");
-var import_upstreamFetch11 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_upstreamFetch13 = require("@omnicross/core/pipeline/upstreamFetch");
 
 // src/allowance/ProviderKeyQuota.ts
 var MINUTE_MS3 = 6e4;
@@ -10407,11 +10991,11 @@ function isoInstant3(value) {
   }
   return void 0;
 }
-function secondsUntil8(instant, now) {
+function secondsUntil9(instant, now) {
   if (!instant) return void 0;
   return Math.max(0, Math.floor((Date.parse(instant) - now) / 1e3));
 }
-function isRecord8(value) {
+function isRecord10(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function detectProviderKeyQuotaAdapter(baseUrl) {
@@ -10478,17 +11062,17 @@ function zaiWindowIdLabel(durationMs) {
   return { id: "quota", label: "Quota" };
 }
 function parseZaiQuotaPayload(payload, now) {
-  if (!isRecord8(payload)) return null;
-  const data = isRecord8(payload["data"]) ? payload["data"] : payload;
+  if (!isRecord10(payload)) return null;
+  const data = isRecord10(payload["data"]) ? payload["data"] : payload;
   if (payload["success"] === false) return null;
   const limits = Array.isArray(data["limits"]) ? data["limits"] : [];
   const byWindow = /* @__PURE__ */ new Map();
   for (const raw of limits) {
-    if (!isRecord8(raw)) continue;
+    if (!isRecord10(raw)) continue;
     const item = raw;
     if (item.type === void 0) continue;
     const details = raw["usageDetails"];
-    if (Array.isArray(details) && details.some((d) => isRecord8(d) && d["modelCode"] === "zread")) {
+    if (Array.isArray(details) && details.some((d) => isRecord10(d) && d["modelCode"] === "zread")) {
       continue;
     }
     const durationMs = zaiWindowDurationMs(item);
@@ -10507,7 +11091,7 @@ function parseZaiQuotaPayload(payload, now) {
       usedPercent,
       ...durationMs !== void 0 ? { windowMinutes: Math.round(durationMs / MINUTE_MS3) } : {},
       ...resetsAt !== void 0 ? { resetsAt } : {},
-      remainingSeconds: secondsUntil8(resetsAt, now),
+      remainingSeconds: secondsUntil9(resetsAt, now),
       state: "fresh"
     };
     const existing = byWindow.get(id);
@@ -10521,7 +11105,7 @@ function parseZaiQuotaPayload(payload, now) {
 var MINIMAX_STATUS_EXHAUSTED = 2;
 var MINIMAX_SHARED_BUCKET = "general";
 function parseMiniMaxBucket(value) {
-  if (!isRecord8(value)) return null;
+  if (!isRecord10(value)) return null;
   const modelName = typeof value["model_name"] === "string" ? value["model_name"].trim() : "";
   if (!modelName) return null;
   const instant = (v) => {
@@ -10548,14 +11132,14 @@ function minimaxWindow(id, label, windowMinutes, resetsAtMs, remainingPercent, s
     usedPercent,
     ...windowMinutes !== void 0 ? { windowMinutes } : {},
     ...resetsAt !== void 0 ? { resetsAt } : {},
-    remainingSeconds: secondsUntil8(resetsAt, now),
+    remainingSeconds: secondsUntil9(resetsAt, now),
     state: usedPercent !== null ? "fresh" : "unavailable"
   };
 }
 function parseMiniMaxTokenPlanPayload(payload, now) {
-  if (!isRecord8(payload)) return null;
+  if (!isRecord10(payload)) return null;
   const baseResp = payload["base_resp"];
-  if (!isRecord8(baseResp) || baseResp["status_code"] !== 0) return null;
+  if (!isRecord10(baseResp) || baseResp["status_code"] !== 0) return null;
   const buckets = Array.isArray(payload["model_remains"]) ? payload["model_remains"] : [];
   let general = null;
   for (const raw of buckets) {
@@ -10588,11 +11172,11 @@ function parseMiniMaxTokenPlanPayload(payload, now) {
   ];
 }
 function parseUmansUsagePayload(payload, now) {
-  if (!isRecord8(payload)) return null;
-  const limits = isRecord8(payload["limits"]) ? payload["limits"] : void 0;
-  const requests = limits && isRecord8(limits["requests"]) ? limits["requests"] : void 0;
-  const usage = isRecord8(payload["usage"]) ? payload["usage"] : void 0;
-  const window = isRecord8(payload["window"]) ? payload["window"] : void 0;
+  if (!isRecord10(payload)) return null;
+  const limits = isRecord10(payload["limits"]) ? payload["limits"] : void 0;
+  const requests = limits && isRecord10(limits["requests"]) ? limits["requests"] : void 0;
+  const usage = isRecord10(payload["usage"]) ? payload["usage"] : void 0;
+  const window = isRecord10(payload["window"]) ? payload["window"] : void 0;
   const hardCap = finiteNumber5(requests?.["hard_cap"]);
   const softLimit = finiteNumber5(requests?.["limit"]);
   const requestsInWindow = finiteNumber5(usage?.["requests_in_window"]);
@@ -10613,15 +11197,15 @@ function parseUmansUsagePayload(payload, now) {
       usedPercent,
       windowMinutes: 5 * 60,
       ...resetsAt !== void 0 ? { resetsAt } : {},
-      remainingSeconds: secondsUntil8(resetsAt, now),
+      remainingSeconds: secondsUntil9(resetsAt, now),
       state: "fresh"
     }
   ];
 }
 function parseSyntheticQuotasPayload(payload, now) {
-  if (!isRecord8(payload)) return null;
-  const fiveHour = isRecord8(payload["rollingFiveHourLimit"]) ? payload["rollingFiveHourLimit"] : void 0;
-  const weekly = isRecord8(payload["weeklyTokenLimit"]) ? payload["weeklyTokenLimit"] : void 0;
+  if (!isRecord10(payload)) return null;
+  const fiveHour = isRecord10(payload["rollingFiveHourLimit"]) ? payload["rollingFiveHourLimit"] : void 0;
+  const weekly = isRecord10(payload["weeklyTokenLimit"]) ? payload["weeklyTokenLimit"] : void 0;
   const windows = [];
   if (fiveHour) {
     const max = finiteNumber5(fiveHour["max"]);
@@ -10635,7 +11219,7 @@ function parseSyntheticQuotasPayload(payload, now) {
       usedPercent,
       windowMinutes: 5 * 60,
       ...resetsAt !== void 0 ? { resetsAt } : {},
-      remainingSeconds: secondsUntil8(resetsAt, now),
+      remainingSeconds: secondsUntil9(resetsAt, now),
       state: usedPercent !== null || resetsAt ? "fresh" : "unavailable"
     });
   }
@@ -10650,7 +11234,7 @@ function parseSyntheticQuotasPayload(payload, now) {
       usedPercent,
       windowMinutes: 7 * 24 * 60,
       ...resetsAt !== void 0 ? { resetsAt } : {},
-      remainingSeconds: secondsUntil8(resetsAt, now),
+      remainingSeconds: secondsUntil9(resetsAt, now),
       state: usedPercent !== null || resetsAt ? "fresh" : "unavailable"
     });
   }
@@ -10662,12 +11246,12 @@ var CLINE_WINDOW_CONFIG = {
   monthly: { id: "thirty-day", label: "30 days", minutes: 30 * 24 * 60 }
 };
 function parseClinePassUsageLimitsPayload(payload, now) {
-  if (!isRecord8(payload)) return null;
-  const data = isRecord8(payload["data"]) ? payload["data"] : payload;
+  if (!isRecord10(payload)) return null;
+  const data = isRecord10(payload["data"]) ? payload["data"] : payload;
   const limits = Array.isArray(data["limits"]) ? data["limits"] : [];
   const windows = [];
   for (const raw of limits) {
-    if (!isRecord8(raw)) continue;
+    if (!isRecord10(raw)) continue;
     const config = CLINE_WINDOW_CONFIG[typeof raw["type"] === "string" ? raw["type"] : ""];
     if (!config) continue;
     const usedPercent = finitePercent4(raw["percentUsed"]);
@@ -10680,7 +11264,7 @@ function parseClinePassUsageLimitsPayload(payload, now) {
       usedPercent,
       windowMinutes: config.minutes,
       ...resetsAt !== void 0 ? { resetsAt } : {},
-      remainingSeconds: secondsUntil8(resetsAt, now),
+      remainingSeconds: secondsUntil9(resetsAt, now),
       state: "fresh"
     });
   }
@@ -10719,7 +11303,7 @@ function rowKeyEntries(row) {
   return [];
 }
 var ProviderKeyQuotaService = class {
-  constructor(box, fetchImpl = (url, init) => (0, import_upstreamFetch11.fetchUpstream)(url, init, { redactBodies: true }), now = Date.now) {
+  constructor(box, fetchImpl = (url, init) => (0, import_upstreamFetch13.fetchUpstream)(url, init, { redactBodies: true }), now = Date.now) {
     this.box = box;
     this.fetchImpl = fetchImpl;
     this.now = now;
@@ -10822,7 +11406,7 @@ var ProviderKeyQuotaService = class {
 // src/image-generation/ImageDoctorService.ts
 var import_image_generation = require("@omnicross/core/image-generation");
 var import_outbound_api7 = require("@omnicross/core/outbound-api");
-var import_subscriptions9 = require("@omnicross/subscriptions");
+var import_subscriptions10 = require("@omnicross/subscriptions");
 
 // src/image-generation/FileCodexImageCapabilityEvidenceSource.ts
 var import_node_crypto13 = require("crypto");
@@ -11260,16 +11844,16 @@ function createImageDoctorService(options) {
     paths,
     ttlMs: config.evidenceTtlMs
   }));
-  const createLiveVerifier = options.createLiveVerifier ?? ((strategy, config) => (0, import_subscriptions9.createCodexImageLiveVerifier)({
+  const createLiveVerifier = options.createLiveVerifier ?? ((strategy, config) => (0, import_subscriptions10.createCodexImageLiveVerifier)({
     authStrategy: strategy,
     generationTimeoutMs: config.queue.generationTimeoutMs
   }));
-  const readAccount = async () => {
-    const codex = (await options.subscriptionAccounts.listAll()).find((entry) => entry.providerId === "codex");
+  const readAccount = async (providerId) => {
+    const entry = (await options.subscriptionAccounts.listAll()).find((candidate) => candidate.providerId === providerId);
     return Object.freeze({
-      present: codex !== void 0,
-      usable: codex?.credentialStatus.ok === true,
-      reason: codex === void 0 ? "missing" : codex.credentialStatus.ok ? "ready" : "unavailable"
+      present: entry !== void 0,
+      usable: entry?.credentialStatus.ok === true,
+      reason: entry === void 0 ? "missing" : entry.credentialStatus.ok ? "ready" : "unavailable"
     });
   };
   const activePaths = () => options.storageCatalog.active().resolver;
@@ -11307,6 +11891,7 @@ function createImageDoctorService(options) {
       } catch {
         storesValid = false;
       }
+      const antigravityAccount = await readAccount("antigravity");
       const rows = await options.keyDb.outboundApiKeysList();
       let legacyRows = 0;
       let invalidRows = 0;
@@ -11323,7 +11908,7 @@ function createImageDoctorService(options) {
           invalidRows += 1;
         }
       }
-      const account = await readAccount();
+      const account = await readAccount("codex");
       let evidence;
       let evidenceStore;
       try {
@@ -11337,10 +11922,11 @@ function createImageDoctorService(options) {
       return Object.freeze({
         config: Object.freeze({
           enabled: config.enabled,
-          provider: config.provider,
+          provider: config.models[config.defaultModel] ?? "codex-subscription",
           model: config.defaultModel,
           valid: configErrors.length === 0,
-          errorCount: configErrors.length
+          errorCount: configErrors.length,
+          routedProviders: Object.freeze([...new Set(Object.values(config.models))])
         }),
         roots: Object.freeze({
           valid: verifiedAreas === ROOT_AREAS.length,
@@ -11365,12 +11951,13 @@ function createImageDoctorService(options) {
           imagesAuthorizedRows
         }),
         account,
+        antigravityAccount,
         evidence: Object.freeze(evidence)
       });
     },
     verifyLive: async (config, signal) => {
       if (!config.enabled) return Object.freeze({ ok: false, code: "images_disabled" });
-      const account = await readAccount();
+      const account = await readAccount("codex");
       if (!account.usable) {
         return Object.freeze({ ok: false, code: "codex_account_unavailable" });
       }
@@ -11622,7 +12209,7 @@ var ImageCleanupService = class {
 var import_node_crypto16 = require("crypto");
 var import_image_generation5 = require("@omnicross/core/image-generation");
 var import_outbound_api8 = require("@omnicross/core/outbound-api");
-var import_subscriptions10 = require("@omnicross/subscriptions");
+var import_subscriptions11 = require("@omnicross/subscriptions");
 
 // src/image-generation/ImageApiRuntimeResolver.ts
 var import_node_crypto14 = require("crypto");
@@ -11650,10 +12237,11 @@ function createTrustedImageApiRuntimeResolver(options) {
     throw new TypeError("enabled image remote loading requires a proven resolver");
   }
   const hmacKey = Buffer.from(options.hmacKey);
-  const modelAliases = new Map(Object.entries(options.config.modelAliases));
+  const modelAliases = new Map(Object.entries(options.config.aliases));
+  const modelRoutes = new Map(Object.entries(options.config.models));
   const limits = Object.freeze({ ...options.config.limits });
-  const providerId = options.config.provider;
   const defaultModel = options.config.defaultModel;
+  const providerId = modelRoutes.get(defaultModel) ?? "codex-subscription";
   const referenceStore = options.referenceStore;
   const retention = Object.freeze({
     enabled: true,
@@ -11674,6 +12262,7 @@ function createTrustedImageApiRuntimeResolver(options) {
         providerId,
         defaultModel,
         modelAliases,
+        modelRoutes,
         limits,
         ...preferredAccountId ? { preferredAccountId } : {},
         ...preferredAccountGroup ? { preferredAccountGroup } : {},
@@ -12075,7 +12664,9 @@ var GENERATION_ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/u;
 function snapshotConfig(config) {
   return {
     ...config,
-    modelAliases: { ...config.modelAliases },
+    models: { ...config.models },
+    aliases: { ...config.aliases },
+    codex: { ...config.codex },
     account: { ...config.account },
     queue: { ...config.queue },
     temporary: { ...config.temporary },
@@ -12109,10 +12700,15 @@ function createImageRuntimeGeneration(options) {
       }
     });
   }
-  const authStrategy = options.subscriptionAccounts.getStrategy("codex");
-  if (!authStrategy || authStrategy.providerId !== "codex") {
+  const routedProviders = [...new Set(Object.values(config.models))];
+  const codexStrategy = routedProviders.includes("codex-subscription") ? options.subscriptionAccounts.getStrategy("codex") : void 0;
+  if (routedProviders.includes("codex-subscription") && (!codexStrategy || codexStrategy.providerId !== "codex")) {
     throw new TypeError("enabled image runtime requires the Codex subscription strategy");
   }
+  const antigravityStrategy = routedProviders.includes("antigravity-subscription") ? options.subscriptionAccounts.getStrategy("antigravity") : void 0;
+  if (routedProviders.includes("antigravity-subscription") && (!antigravityStrategy || antigravityStrategy.providerId !== "antigravity")) {
+    throw new TypeError("enabled image runtime requires the Antigravity subscription strategy");
+  }
   const privateHmacKey = options.privateHmacKey ? Buffer.from(options.privateHmacKey) : loadOrCreateImageTenantHmacSalt(options.storage.paths, import_node_crypto16.randomBytes);
   if (privateHmacKey.byteLength !== 32) {
     privateHmacKey.fill(0);
@@ -12147,23 +12743,32 @@ function createImageRuntimeGeneration(options) {
     if (options.testOnlySyntheticVerifiedProvider && options.testOnlySyntheticVerifiedProvider.label !== "synthetic-verified-image-provider-test-only") {
       throw new TypeError("synthetic verified image provider test seam label is invalid");
     }
-    const provider = options.testOnlySyntheticVerifiedProvider ? options.testOnlySyntheticVerifiedProvider.createProvider({
+    const providers = options.testOnlySyntheticVerifiedProvider ? [options.testOnlySyntheticVerifiedProvider.createProvider({
       generationId: options.generationId,
       scheduler,
       now: options.now ?? Date.now,
       referenceStore: options.storage.referenceStore,
       stateStore: options.storage.stateStore
-    }) : (0, import_subscriptions10.createCodexSubscriptionImageProvider)({
-      authStrategy,
+    })] : routedProviders.map((providerId) => providerId === "codex-subscription" ? (0, import_subscriptions11.createCodexSubscriptionImageProvider)({
+      authStrategy: codexStrategy,
       evidenceSource: generationEvidenceSource,
       executionScheduler: scheduler,
       generationTimeoutMs: config.queue.generationTimeoutMs,
+      now: options.now,
+      wire: {
+        imageModel: config.codex.imageModel,
+        carrierModel: config.codex.carrierModel
+      }
+    }) : (0, import_subscriptions11.createAntigravitySubscriptionImageProvider)({
+      authStrategy: antigravityStrategy,
+      executionScheduler: scheduler,
+      generationTimeoutMs: config.queue.generationTimeoutMs,
       now: options.now
-    });
-    if (provider.id !== config.provider) {
+    }));
+    if (providers.length === 1 && providers[0].id !== "codex-subscription") {
       throw new TypeError("synthetic verified image provider id must match configured provider");
     }
-    const providerRegistry = new import_image_generation5.ImageProviderRegistry([provider]);
+    const providerRegistry = new import_image_generation5.ImageProviderRegistry(providers);
     const orchestrator = new import_image_generation5.ImageOrchestrator({
       registry: providerRegistry,
       referenceStore: options.storage.referenceStore,
@@ -12185,35 +12790,72 @@ function createImageRuntimeGeneration(options) {
       ...options.createCallId ? { createCallId: options.createCallId } : {},
       ...options.now ? { now: options.now } : {}
     });
+    const defaultProviderId = config.models[config.defaultModel] ?? "codex-subscription";
+    const inspectOneProvider = async (providerId, apiKeyId) => {
+      const capabilities = await orchestrator.getCapabilities(providerId, {
+        requestId: `${options.generationId}:capability-inspection`,
+        tenantId: apiKeyId,
+        signal: new AbortController().signal,
+        sessionKey: `outbound:images:${apiKeyId}`,
+        ...config.account.id ? { preferredAccountId: config.account.id } : {},
+        ...config.account.group ? { preferredAccountGroup: config.account.group } : {},
+        boundAccountFallbackPolicy: config.account.fallback
+      });
+      return capabilities;
+    };
     const inspectCapability = async (apiKeyId) => {
-      try {
-        const capabilities = await orchestrator.getCapabilities(config.provider, {
-          requestId: `${options.generationId}:capability-inspection`,
-          tenantId: apiKeyId,
-          signal: new AbortController().signal,
-          sessionKey: `outbound:images:${apiKeyId}`,
-          ...config.account.id ? { preferredAccountId: config.account.id } : {},
-          ...config.account.group ? { preferredAccountGroup: config.account.group } : {},
-          boundAccountFallbackPolicy: config.account.fallback
-        });
-        const available = capabilities.available === true && capabilities.generate === true && capabilities.models.includes(config.defaultModel);
-        return Object.freeze({
-          enabled: true,
-          available,
-          providerId: config.provider,
-          model: config.defaultModel,
-          ...!available ? { reason: capabilities.reason ?? "runtime_unavailable" } : {},
-          capabilities
-        });
-      } catch (error) {
+      const providerCapabilities = /* @__PURE__ */ new Map();
+      let defaultProviderError;
+      const providerRows = [];
+      for (const providerId of [...new Set(Object.values(config.models))]) {
+        try {
+          const capabilities2 = await inspectOneProvider(providerId, apiKeyId);
+          providerCapabilities.set(providerId, capabilities2);
+          const affirmed = capabilities2.available === true && capabilities2.generate === true;
+          providerRows.push({
+            providerId,
+            available: affirmed,
+            ...!affirmed ? { reason: capabilities2.reason ?? "runtime_unavailable" } : {},
+            models: affirmed ? Object.entries(config.models).filter(([model, modelProvider]) => modelProvider === providerId && capabilities2.models.includes(model)).map(([model]) => model) : [],
+            capabilities: capabilities2
+          });
+        } catch (error) {
+          if (providerId === defaultProviderId) defaultProviderError = error;
+          providerRows.push({
+            providerId,
+            available: false,
+            reason: error instanceof import_image_generation5.ImageGenerationError && (error.code === "upstream_auth_required" || error.code === "invalid_api_key") ? "account_unverified" : "runtime_unavailable",
+            models: []
+          });
+        }
+      }
+      const providers2 = Object.freeze(providerRows);
+      const routedModels = Object.freeze(
+        providerRows.flatMap((row) => row.available ? row.models : [])
+      );
+      const capabilities = providerCapabilities.get(defaultProviderId);
+      if (!capabilities) {
         return Object.freeze({
           enabled: true,
           available: false,
-          providerId: config.provider,
+          providerId: defaultProviderId,
           model: config.defaultModel,
-          reason: error instanceof import_image_generation5.ImageGenerationError && (error.code === "upstream_auth_required" || error.code === "invalid_api_key") ? "account_unverified" : "runtime_unavailable"
+          routedModels,
+          providers: providers2,
+          reason: defaultProviderError instanceof import_image_generation5.ImageGenerationError && (defaultProviderError.code === "upstream_auth_required" || defaultProviderError.code === "invalid_api_key") ? "account_unverified" : "runtime_unavailable"
         });
       }
+      const available = capabilities.available === true && capabilities.generate === true && capabilities.models.includes(config.defaultModel);
+      return Object.freeze({
+        enabled: true,
+        available,
+        providerId: defaultProviderId,
+        model: config.defaultModel,
+        routedModels,
+        providers: providers2,
+        ...!available ? { reason: capabilities.reason ?? "runtime_unavailable" } : {},
+        capabilities
+      });
     };
     const resolverToDispose = runtimeResolver;
     const schedulerToDispose = scheduler;
@@ -12251,7 +12893,7 @@ function createImageRuntimeGeneration(options) {
       imageApi,
       hosted,
       hostedRuntime: Object.freeze({
-        providerId: config.provider,
+        providerId: defaultProviderId,
         imageModel: config.defaultModel,
         referenceTtlMs: config.references.ttlMs,
         maxOutputBytes: config.limits.maxOutputBytes,
@@ -15194,6 +15836,9 @@ var ImageRuntimeManager = class {
   }
   async listAvailableModels(apiKeyId) {
     const inspection = await this.inspectCapability(apiKeyId);
+    if (inspection.routedModels !== void 0) {
+      return Object.freeze([...inspection.routedModels]);
+    }
     return inspection.available && inspection.model === "gpt-image-2" ? Object.freeze([inspection.model]) : Object.freeze([]);
   }
   resourceStatus() {
@@ -17381,11 +18026,12 @@ var JsonVoucherDb = class {
 // src/ports/JsonSubscriptionCredentialStore.ts
 var import_node_fs28 = require("fs");
 var import_node_path27 = require("path");
+var import_GeminiCodeAssistProjectResolver5 = require("@omnicross/core/auth/GeminiCodeAssistProjectResolver");
 var import_SubscriptionAccountHealth2 = require("@omnicross/core/pipeline/SubscriptionAccountHealth");
 var import_AccountAllowanceScheduling3 = require("@omnicross/core/pipeline/AccountAllowanceScheduling");
-var import_upstreamFetch12 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_upstreamFetch14 = require("@omnicross/core/pipeline/upstreamFetch");
 var import_SubscriptionIdentityStore2 = require("@omnicross/core/provider-proxy/identity/SubscriptionIdentityStore");
-var import_subscriptions11 = require("@omnicross/subscriptions");
+var import_subscriptions12 = require("@omnicross/subscriptions");
 
 // src/ports/account-sync.ts
 function viewOf(tokens) {
@@ -17533,7 +18179,7 @@ var JsonSubscriptionCredentialStore = class {
    * a plaintext token pair into `upstream-trace.jsonl`.
    */
   buildRefreshFetch(providerId, accountId) {
-    return this.fetchImpl ?? ((url, init) => (0, import_upstreamFetch12.fetchUpstream)(url, init, { providerId, accountId, redactBodies: true }));
+    return this.fetchImpl ?? ((url, init) => (0, import_upstreamFetch14.fetchUpstream)(url, init, { providerId, accountId, redactBodies: true }));
   }
   /**
    * In-flight refresh coalescing. OAuth refresh tokens are
@@ -17574,7 +18220,7 @@ var JsonSubscriptionCredentialStore = class {
    * other hot reads. Never returns token material.
    */
   getAccountProxy(providerId, accountId) {
-    if (providerId !== "claude" && providerId !== "codex" && providerId !== "gemini" && providerId !== "opencodego" && providerId !== "kimi" && providerId !== "grok" && providerId !== "copilot") {
+    if (providerId !== "claude" && providerId !== "codex" && providerId !== "gemini" && providerId !== "opencodego" && providerId !== "kimi" && providerId !== "grok" && providerId !== "copilot" && providerId !== "antigravity") {
       return void 0;
     }
     return getAccountProxy(this.readConfig(), providerId, accountId);
@@ -17593,7 +18239,7 @@ var JsonSubscriptionCredentialStore = class {
     const fingerprintOn = identityStore.isEnabled();
     const now = Date.now();
     const out = {};
-    for (const provider of ["claude", "codex", "gemini", "opencodego", "kimi", "grok", "copilot"]) {
+    for (const provider of ["claude", "codex", "gemini", "opencodego", "kimi", "grok", "copilot", "antigravity"]) {
       const sanitized = sanitizeAccounts(config, provider);
       if (sanitized.length === 0) continue;
       for (const account of sanitized) {
@@ -17659,7 +18305,7 @@ var JsonSubscriptionCredentialStore = class {
       this.materializeMigration(config);
       const refreshFetch = this.buildRefreshFetch("claude", capturedId);
       try {
-        const result = await import_subscriptions11.claudeOAuth.refreshAccessToken(claude.refreshToken, refreshFetch);
+        const result = await import_subscriptions12.claudeOAuth.refreshAccessToken(claude.refreshToken, refreshFetch);
         const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
         const next = {
           ...claude,
@@ -17694,7 +18340,7 @@ var JsonSubscriptionCredentialStore = class {
       this.materializeMigration(config);
       const refreshFetch = this.buildRefreshFetch("codex", capturedId);
       try {
-        const result = await import_subscriptions11.codexOAuth.refreshAccessToken(codex.refreshToken, refreshFetch);
+        const result = await import_subscriptions12.codexOAuth.refreshAccessToken(codex.refreshToken, refreshFetch);
         const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
         const next = {
           ...codex,
@@ -17732,7 +18378,7 @@ var JsonSubscriptionCredentialStore = class {
       this.materializeMigration(config);
       const refreshFetch = this.buildRefreshFetch("gemini", capturedId);
       try {
-        const result = await import_subscriptions11.geminiOAuth.refreshAccessToken(gemini.refreshToken, refreshFetch);
+        const result = await import_subscriptions12.geminiOAuth.refreshAccessToken(gemini.refreshToken, refreshFetch);
         const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
         const next = {
           ...gemini,
@@ -17768,10 +18414,10 @@ var JsonSubscriptionCredentialStore = class {
       this.materializeMigration(config);
       const refreshFetch = this.buildRefreshFetch("kimi", capturedId);
       try {
-        const result = await import_subscriptions11.kimiOAuth.refreshAccessToken(
+        const result = await import_subscriptions12.kimiOAuth.refreshAccessToken(
           kimi.refreshToken,
           refreshFetch,
-          import_subscriptions11.kimiOAuth.kimiFingerprintHeaders(kimi.deviceId)
+          import_subscriptions12.kimiOAuth.kimiFingerprintHeaders(kimi.deviceId)
         );
         const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
         const next = {
@@ -17808,8 +18454,8 @@ var JsonSubscriptionCredentialStore = class {
       this.materializeMigration(config);
       const refreshFetch = this.buildRefreshFetch("grok", capturedId);
       try {
-        const tokenEndpoint = await import_subscriptions11.grokOAuth.resolveGrokTokenEndpoint(refreshFetch);
-        const result = await import_subscriptions11.grokOAuth.refreshGrokAccessToken(grok.refreshToken, tokenEndpoint, refreshFetch);
+        const tokenEndpoint = await import_subscriptions12.grokOAuth.resolveGrokTokenEndpoint(refreshFetch);
+        const result = await import_subscriptions12.grokOAuth.refreshGrokAccessToken(grok.refreshToken, tokenEndpoint, refreshFetch);
         const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
         const next = {
           ...grok,
@@ -17852,6 +18498,76 @@ var JsonSubscriptionCredentialStore = class {
       return false;
     });
   }
+  /**
+   * Refresh the Antigravity (Google) OAuth access token. Like gemini, the
+   * Google token endpoint does NOT return a refresh_token on refresh, so this
+   * writes ONLY access+expiresAt (+status/lastRefreshedAt) and DELIBERATELY
+   * preserves the stored `refreshToken` — plus the account's `projectId`
+   * (a handshake product; the post-refresh re-validation is the refresh
+   * scheduler's hook, not this write) and `email`. HONEST `false` when no
+   * refresh_token.
+   */
+  async refreshAntigravityToken() {
+    return this.coalesce("antigravity:active", async () => {
+      const config = this.readConfig();
+      const active = getActiveAccount(config, "antigravity");
+      const antigravity = active?.tokens;
+      if (!active || !antigravity?.refreshToken) return false;
+      const capturedId = active.id;
+      this.materializeMigration(config);
+      const refreshFetch = this.buildRefreshFetch("antigravity", capturedId);
+      try {
+        const result = await import_subscriptions12.antigravityOAuth.refreshAccessToken(antigravity.refreshToken, refreshFetch);
+        const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
+        const next = {
+          ...antigravity,
+          // KEEP the existing refreshToken/projectId/email.
+          accessToken: result.accessToken,
+          expiresAt,
+          status: "authorized",
+          lastRefreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          errorMessage: void 0
+        };
+        this.writeBackById("antigravity", capturedId, next);
+        await this.revalidateAntigravityProject(capturedId);
+        return true;
+      } catch (error) {
+        this.markExpiredById("antigravity", capturedId, antigravity, error);
+        return false;
+      }
+    });
+  }
+  /**
+   * Post-refresh project re-validation hook (antigravity design D8): after a
+   * successful antigravity token refresh, re-run the Code Assist project
+   * handshake and write the (possibly rotated) `projectId` back to the account.
+   * A handshake FAILURE keeps the stored projectId untouched (logged) so the
+   * account keeps serving with the last-known-good project until a later
+   * refresh succeeds. Returns whether the handshake produced a project.
+   */
+  async revalidateAntigravityProject(accountId) {
+    const before = getAccountById(this.readConfig(), "antigravity", accountId);
+    const accessToken = before?.tokens?.accessToken;
+    if (!accessToken) return false;
+    try {
+      const projectId = await (0, import_GeminiCodeAssistProjectResolver5.getAntigravityProjectResolver)().resolveProject(accessToken);
+      if (projectId !== void 0) {
+        const config = this.readConfig();
+        const account = getAccountById(config, "antigravity", accountId);
+        const tokens = account?.tokens;
+        if (account && tokens?.accessToken === accessToken && tokens.projectId !== projectId) {
+          this.writeBackById("antigravity", accountId, { ...tokens, projectId });
+        }
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.warn(
+        `[JsonSubscriptionCredentialStore] antigravity project re-validation failed for account ${accountId}: ` + (error instanceof Error ? error.message : String(error))
+      );
+      return false;
+    }
+  }
   /**
    * Refresh a SPECIFIC managed account by id (background scheduler sweep and
    * account-pool resolution). It uses only that account's stored refresh
@@ -17880,6 +18596,7 @@ var JsonSubscriptionCredentialStore = class {
         };
         if (refreshed.idToken) next.idToken = refreshed.idToken;
         this.writeBackById(provider, id, next);
+        if (provider === "antigravity") await this.revalidateAntigravityProject(id);
         return true;
       } catch (error) {
         this.markExpiredById(provider, id, captured, error);
@@ -17904,7 +18621,7 @@ var JsonSubscriptionCredentialStore = class {
     }
     const oauth = account.tokens;
     if (!oauth.accessToken) return null;
-    if (providerId === "codex" || providerId === "gemini" || providerId === "kimi" || providerId === "grok" || providerId === "copilot") {
+    if (providerId === "codex" || providerId === "gemini" || providerId === "kimi" || providerId === "grok" || providerId === "copilot" || providerId === "antigravity") {
       const expiresAtMs = oauth.expiresAt ? Date.parse(oauth.expiresAt) : 0;
       const expiringSoon = expiresAtMs > 0 && Date.now() >= expiresAtMs - ACCOUNT_REFRESH_LEAD_MS;
       if (expiringSoon && oauth.refreshToken) {
@@ -17997,10 +18714,10 @@ var JsonSubscriptionCredentialStore = class {
     if (provider === "kimi") {
       const account = accountId ? getAccountById(this.readConfig(), "kimi", accountId) : void 0;
       const deviceId = account?.tokens?.deviceId;
-      const r2 = await import_subscriptions11.kimiOAuth.refreshAccessToken(
+      const r2 = await import_subscriptions12.kimiOAuth.refreshAccessToken(
         refreshToken,
         refreshFetch,
-        import_subscriptions11.kimiOAuth.kimiFingerprintHeaders(deviceId)
+        import_subscriptions12.kimiOAuth.kimiFingerprintHeaders(deviceId)
       );
       return {
         accessToken: r2.accessToken,
@@ -18009,8 +18726,8 @@ var JsonSubscriptionCredentialStore = class {
       };
     }
     if (provider === "grok") {
-      const tokenEndpoint = await import_subscriptions11.grokOAuth.resolveGrokTokenEndpoint(refreshFetch);
-      const r2 = await import_subscriptions11.grokOAuth.refreshGrokAccessToken(refreshToken, tokenEndpoint, refreshFetch);
+      const tokenEndpoint = await import_subscriptions12.grokOAuth.resolveGrokTokenEndpoint(refreshFetch);
+      const r2 = await import_subscriptions12.grokOAuth.refreshGrokAccessToken(refreshToken, tokenEndpoint, refreshFetch);
       return {
         accessToken: r2.accessToken,
         refreshToken: r2.refreshToken,
@@ -18020,7 +18737,14 @@ var JsonSubscriptionCredentialStore = class {
     if (provider === "copilot") {
       throw new Error("GitHub Copilot tokens cannot be refreshed \u2014 re-authenticate the account");
     }
-    const flow = provider === "claude" ? import_subscriptions11.claudeOAuth : provider === "codex" ? import_subscriptions11.codexOAuth : import_subscriptions11.geminiOAuth;
+    if (provider === "antigravity") {
+      const r2 = await import_subscriptions12.antigravityOAuth.refreshAccessToken(refreshToken, refreshFetch);
+      return {
+        accessToken: r2.accessToken,
+        expiresAt: new Date(Date.now() + r2.expiresIn * 1e3).toISOString()
+      };
+    }
+    const flow = provider === "claude" ? import_subscriptions12.claudeOAuth : provider === "codex" ? import_subscriptions12.codexOAuth : import_subscriptions12.geminiOAuth;
     const r = await flow.refreshAccessToken(refreshToken, refreshFetch);
     return {
       accessToken: r.accessToken,
@@ -18263,7 +18987,7 @@ var JsonSubscriptionCredentialStore = class {
 };
 
 // src/AccountHealthProbeScheduler.ts
-var import_upstreamFetch13 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_upstreamFetch15 = require("@omnicross/core/pipeline/upstreamFetch");
 
 // src/probe/CodexGenerationProbe.ts
 var import_codexCliHeaders = require("@omnicross/core/provider-proxy/identity/codexCliHeaders");
@@ -18415,7 +19139,11 @@ var PROVIDER_PROBE_PLANS = {
   // The Copilot quota endpoint (copilot_internal/user) is a verified FREE
   // authed GET but lives on api.github.com with its own auth dialect and a
   // monthly-only window — the allowance collector owns the health surface.
-  copilot: { kind: "local" }
+  copilot: { kind: "local" },
+  // Antigravity's quota endpoints are POST RPCs on daily-cloudcode-pa (not a
+  // cheap GET) and need the antigravity/hub UA — the allowance collector owns
+  // the health surface; the probe stays local.
+  antigravity: { kind: "local" }
 };
 function probePlanFor(providerId) {
   return PROVIDER_PROBE_PLANS[providerId] ?? { kind: "local" };
@@ -18437,7 +19165,7 @@ var AccountHealthProbeScheduler = class {
     this.logger = logger;
     this.config = config;
     this.now = opts.now ?? Date.now;
-    this.fetchImpl = opts.fetchImpl ?? import_upstreamFetch13.fetchUpstream;
+    this.fetchImpl = opts.fetchImpl ?? import_upstreamFetch15.fetchUpstream;
     this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     this.planFor = opts.planFor ?? probePlanFor;
   }
@@ -19593,7 +20321,7 @@ var AuditWriter = class {
 var import_node_fs34 = require("fs");
 var import_node_crypto24 = require("crypto");
 var import_node_path34 = require("path");
-var import_upstreamFetch14 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_upstreamFetch16 = require("@omnicross/core/pipeline/upstreamFetch");
 
 // src/billing/billingFiles.ts
 var BILLING_FILE_RE = /^billing-(\d{4})-(\d{2})-(\d{2})\.jsonl$/;
@@ -19616,7 +20344,7 @@ var BillingPublisher = class {
   constructor(billingDir, logger, opts = {}) {
     this.billingDir = billingDir;
     this.logger = logger;
-    this.fetchImpl = opts.fetchImpl ?? ((url, init) => (0, import_upstreamFetch14.fetchUpstream)(url, init));
+    this.fetchImpl = opts.fetchImpl ?? ((url, init) => (0, import_upstreamFetch16.fetchUpstream)(url, init));
     this.defer = opts.defer ?? ((fn) => setTimeout(fn, 0));
     this.timeoutMs = opts.timeoutMs ?? BILLING_POST_TIMEOUT_MS;
     this.now = opts.now ?? Date.now;
@@ -19866,7 +20594,7 @@ var BillingRetrySweeper = class {
 // src/TokenRefreshScheduler.ts
 var REFRESH_LEAD_MS2 = 5 * 6e4;
 var SWEEP_INTERVAL_MS5 = 6e4;
-var OAUTH_PROVIDERS2 = ["claude", "codex", "gemini", "kimi", "grok", "copilot"];
+var OAUTH_PROVIDERS2 = ["claude", "codex", "gemini", "kimi", "grok", "copilot", "antigravity"];
 var TokenRefreshScheduler = class {
   constructor(store, logger, intervalMs = SWEEP_INTERVAL_MS5, leadMs = REFRESH_LEAD_MS2) {
     this.store = store;
@@ -19957,6 +20685,8 @@ var TokenRefreshScheduler = class {
       // never reaches this — the branch exists for union totality.
       case "copilot":
         return this.store.refreshCopilotToken();
+      case "antigravity":
+        return this.store.refreshAntigravityToken();
     }
   }
 };
@@ -20033,7 +20763,7 @@ function createRouteLeaseSubscriptionPreflight(credentials) {
 
 // src/webhook/WebhookDispatcher.ts
 var import_node_crypto25 = require("crypto");
-var import_upstreamFetch15 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_upstreamFetch17 = require("@omnicross/core/pipeline/upstreamFetch");
 var WEBHOOK_MAX_ATTEMPTS = 3;
 var WEBHOOK_QUEUE_MAX = 1e3;
 var WEBHOOK_SEND_TIMEOUT_MS = 1e4;
@@ -20053,7 +20783,7 @@ var WebhookDispatcher = class {
   sleep;
   now;
   constructor(opts = {}) {
-    this.fetchImpl = opts.fetchImpl ?? ((url, init) => (0, import_upstreamFetch15.fetchUpstream)(url, init));
+    this.fetchImpl = opts.fetchImpl ?? ((url, init) => (0, import_upstreamFetch17.fetchUpstream)(url, init));
     this.logger = opts.logger;
     this.maxAttempts = opts.maxAttempts ?? WEBHOOK_MAX_ATTEMPTS;
     this.queueMax = opts.queueMax ?? WEBHOOK_QUEUE_MAX;
@@ -20139,8 +20869,8 @@ var WebhookDispatcher = class {
         signal: AbortSignal.timeout(this.timeoutMs)
       });
       return res.ok ? { ok: true, status: res.status } : { ok: false, status: res.status };
-    } catch (err8) {
-      return { ok: false, error: err8 instanceof Error ? err8.message : String(err8) };
+    } catch (err9) {
+      return { ok: false, error: err9 instanceof Error ? err9.message : String(err9) };
     }
   }
   /**
@@ -20277,12 +21007,12 @@ function buildDaemon(config, paths) {
   setSecretBox(secretBox3);
   setSecretBox2(secretBox3);
   const decryptedConfig = decryptConfigSecrets(config, secretBox3);
-  const accountAllowanceStore = new import_AccountAllowanceStore10.AccountAllowanceStore(
+  const accountAllowanceStore = new import_AccountAllowanceStore11.AccountAllowanceStore(
     Date.now,
     void 0,
     new JsonAccountAllowancePersistence(defaultAccountAllowancePath(paths.configPath))
   );
-  (0, import_AccountAllowanceStore10.setSharedAccountAllowanceStore)(accountAllowanceStore);
+  (0, import_AccountAllowanceStore11.setSharedAccountAllowanceStore)(accountAllowanceStore);
   (0, import_AccountAllowanceScheduling5.getSharedAccountAllowanceScheduling)().configure(
     (0, import_outbound_api10.normalizeServerConfig)(decryptedConfig.server).allowanceScheduling
   );
@@ -20307,20 +21037,22 @@ function buildDaemon(config, paths) {
   claudeAllowanceRefreshScheduler.configure(
     (0, import_outbound_api10.normalizeServerConfig)(decryptedConfig.server).allowanceScheduling
   );
-  const subscriptionAccounts = new import_subscriptions12.SubscriptionAccountService(credentialStore);
-  (0, import_subscriptions12.setSubscriptionAccountService)(subscriptionAccounts);
-  const subscriptionRegistry = new import_subscriptions12.SubscriptionProviderRegistry(
+  const subscriptionAccounts = new import_subscriptions13.SubscriptionAccountService(credentialStore);
+  (0, import_subscriptions13.setSubscriptionAccountService)(subscriptionAccounts);
+  const subscriptionRegistry = new import_subscriptions13.SubscriptionProviderRegistry(
     subscriptionAccounts,
     credentialStore
   );
-  (0, import_subscriptions12.setSubscriptionProviderRegistry)(subscriptionRegistry);
+  (0, import_subscriptions13.setSubscriptionProviderRegistry)(subscriptionRegistry);
   setServerProxyConfig(decryptedConfig.server?.proxy);
-  (0, import_upstreamFetch16.setUpstreamProxyResolver)(
+  (0, import_upstreamFetch18.setUpstreamProxyResolver)(
     createUpstreamProxyResolver({
       getAccountProxy: (providerId, accountId) => credentialStore.getAccountProxy(providerId, accountId)
     })
   );
-  (0, import_gemini_code_assist_resolver.setGeminiCodeAssistResolver)((0, import_GeminiCodeAssistProjectResolver2.getGeminiCodeAssistProjectResolver)());
+  (0, import_gemini_code_assist_resolver.setGeminiCodeAssistResolver)((0, import_GeminiCodeAssistProjectResolver6.getGeminiCodeAssistProjectResolver)());
+  (0, import_antigravityFailover.setAntigravitySandboxFailover)(decryptedConfig.antigravity?.sandboxFailover === true);
+  (0, import_openCodeGoHeaders2.setOpenCodeGoUserAgent)(decryptedConfig.opencodego?.userAgent ?? null);
   const autoDisableStore = new AutoDisableStore();
   const providerKeyQuotaService = new ProviderKeyQuotaService(secretBox3);
   const apiKeyPool = new import_ApiKeyPoolService.ApiKeyPoolService(
@@ -20339,7 +21071,7 @@ function buildDaemon(config, paths) {
   const pricingEngine = new import_usage2.PricingEngine(pricingStore, logger, {
     // Catalog egress follows the same global/env proxy policy as every other
     // daemon upstream call; no provider/account override applies here.
-    fetchImpl: ((input, init) => (0, import_upstreamFetch16.fetchUpstream)(String(input), init ?? {}))
+    fetchImpl: ((input, init) => (0, import_upstreamFetch18.fetchUpstream)(String(input), init ?? {}))
   });
   const pricingRefreshScheduler = new PricingRefreshScheduler(
     pricingEngine,
@@ -20581,6 +21313,7 @@ function buildDaemon(config, paths) {
     outboundApiServer,
     imageRuntimeConfig,
     imageRuntimeStatus: paths.imageRuntimeStatus ?? imageRuntimeManager,
+    imageLiveVerifier: paths.imageLiveVerifier ?? imageDoctor,
     imageConfigAudit: paths.imageConfigAudit ?? ((record) => {
       imageObservability.recordConfigurationAudit(record);
     }),
@@ -20624,7 +21357,7 @@ function buildDaemon(config, paths) {
     // — `server.proxy.byProvider[...]` was silently skipped — and the call was
     // excluded from the upstream trace, so a failing login left no evidence.
     // `redactBodies` keeps the code/verifier + minted token out of that trace.
-    oauthExchangeFetch: paths.oauthExchangeFetch ? () => paths.oauthExchangeFetch : (providerId) => (url, init) => (0, import_upstreamFetch16.fetchUpstream)(url, init, { providerId, redactBodies: true }),
+    oauthExchangeFetch: paths.oauthExchangeFetch ? () => paths.oauthExchangeFetch : (providerId) => (url, init) => (0, import_upstreamFetch18.fetchUpstream)(url, init, { providerId, redactBodies: true }),
     subscriptionAccountAppender: credentialStore,
     // Codex interactive OAuth (app-parity-2 child 5) — the async loopback flow store
     // + the one-shot 127.0.0.1:1455 listener. Token captured + persisted daemon-side;
@@ -20639,6 +21372,21 @@ function buildDaemon(config, paths) {
     // Grok interactive OAuth — the same async DEVICE-CODE shape as kimi.
     grokSessions: new CodexOAuthSessionStore(),
     copilotSessions: new CodexOAuthSessionStore(),
+    // Antigravity interactive OAuth — the async LOOPBACK flow store + the
+    // one-shot 127.0.0.1:51121 listener (same shape as codex; test seam below).
+    antigravitySessions: new CodexOAuthSessionStore(),
+    antigravityAwaitLoopback: paths.antigravityAwaitLoopback ?? ((state, timeoutMs, signal) => awaitLoopbackCode(state, timeoutMs, signal, {
+      port: 51121,
+      path: "/oauth-callback",
+      label: "antigravity"
+    })),
+    // The dynamic model-catalog probe's token source (the ACTIVE antigravity
+    // account; refreshed by the by-id near-expiry seam inside the lookup).
+    resolveAntigravityAccessToken: async () => {
+      const config2 = await credentialStore.getFullConfig();
+      const activeId = config2.activeAntigravityAccountId ?? config2.antigravityAccounts?.[0]?.id;
+      return activeId ? credentialStore.getAccessTokenForAccount("antigravity", activeId) : null;
+    },
     // Migration pack (app-parity child 6, design D2/D3) — the concrete credential
     // store provides BOTH the full DECRYPTED read (`getFullConfig`, export) and
     // the multi-account append (`appendProviderAccount`, import re-encrypts at-
@@ -20697,7 +21445,7 @@ function buildDaemon(config, paths) {
   });
   const webhookDispatcher = new WebhookDispatcher({
     logger,
-    fetchImpl: (url, init) => (0, import_upstreamFetch16.fetchUpstream)(url, init)
+    fetchImpl: (url, init) => (0, import_upstreamFetch18.fetchUpstream)(url, init)
   });
   setWebhookRuntime(webhookDispatcher, (0, import_SubscriptionAccountHealth4.getSharedAccountHealth)());
   const auditWriter = new AuditWriter(auditDir, logger);
@@ -20832,15 +21580,59 @@ function buildClaudeDoctorChecks(config) {
   });
   return checks;
 }
+function buildAntigravityDoctorChecks(snapshot) {
+  const checks = [];
+  checks.push({
+    name: "antigravity credential",
+    ok: snapshot.accountCount > 0 && snapshot.hasAccessToken,
+    detail: snapshot.accountCount === 0 ? "no antigravity account stored \u2014 run `omnicross login antigravity`" : `${snapshot.accountCount} account(s)${snapshot.activeEmail ? `, active: ${snapshot.activeEmail}` : ""}${snapshot.hasAccessToken ? "" : " \u2014 the active account has no access token"}`
+  });
+  const expiresAtMs = snapshot.expiresAt ? Date.parse(snapshot.expiresAt) : 0;
+  const expired = snapshot.expired || expiresAtMs > 0 && Date.now() >= expiresAtMs;
+  const expiringSoon = expiresAtMs > 0 && Date.now() >= expiresAtMs - 10 * 6e4;
+  checks.push({
+    name: "token freshness",
+    ok: !expired,
+    warn: !expired && expiringSoon,
+    detail: expired ? "the active account is expired (its last refresh failed \u2014 re-login or fix the refresh path)" : snapshot.expiresAt ? `expires at ${snapshot.expiresAt}${expiringSoon ? " (inside the refresh lead window)" : ""}` : "no expiry recorded (refresh scheduler treats it as non-expiring)"
+  });
+  return checks;
+}
+function hasFreshAntigravityQuota(snapshot, now = Date.now()) {
+  if (!snapshot || snapshot.lastErrorCode) return false;
+  if (snapshot.expiresAt && !(Date.parse(snapshot.expiresAt) > now)) return false;
+  return snapshot.windows.some(
+    (window) => window.state === "fresh" && (!window.resetsAt || Date.parse(window.resetsAt) > now) && (window.disabled === true || typeof window.usedPercent === "number" && Number.isFinite(window.usedPercent))
+  );
+}
+function buildAntigravityLiveChecks(result) {
+  return [
+    {
+      name: "token refresh (--live)",
+      ok: result.refreshOk,
+      detail: result.refreshOk ? "the active account refreshed successfully" : "refresh failed (see the daemon log)"
+    },
+    {
+      name: "quota collection (--live)",
+      ok: result.quotaOk,
+      detail: result.quotaOk ? "quotaSummary windows collected" : result.detail
+    }
+  ];
+}
 function buildImagesDoctorChecks(snapshot) {
   const enabled = snapshot.config.enabled;
-  const accountOk = !enabled || snapshot.account.usable;
+  const routed = snapshot.config.routedProviders ?? ["codex-subscription"];
+  const codexRouted = routed.includes("codex-subscription");
+  const antigravityRouted = routed.includes("antigravity-subscription");
+  const antigravity = snapshot.antigravityAccount ?? { present: false, usable: false, reason: "missing" };
+  const accountOk = !enabled || !codexRouted || snapshot.account.usable;
+  const antigravityOk = !enabled || !antigravityRouted || antigravity.usable;
   const evidenceOk = !enabled || snapshot.evidence.valid && snapshot.evidence.freshEntries > 0;
   return [
     {
       name: "normalized Images config",
       ok: snapshot.config.valid,
-      detail: snapshot.config.valid ? `enabled=${enabled}, provider=${snapshot.config.provider}, model=${snapshot.config.model}` : `invalid normalized configuration (${snapshot.config.errorCount} issue(s))`
+      detail: snapshot.config.valid ? `enabled=${enabled}, providers=${routed.join("+")}, default=${snapshot.config.model} (${snapshot.config.provider})` : `invalid normalized configuration (${snapshot.config.errorCount} issue(s))`
     },
     {
       name: "private roots",
@@ -20861,8 +21653,14 @@ function buildImagesDoctorChecks(snapshot) {
     {
       name: "Codex account",
       ok: accountOk,
-      warn: !snapshot.account.usable,
-      detail: snapshot.account.usable ? "eligible local credential is present" : `${snapshot.account.reason}; Images live verification is unavailable`
+      warn: enabled && codexRouted && !snapshot.account.usable,
+      detail: !codexRouted ? "not routed by the current model table (no credential required)" : snapshot.account.usable ? "eligible local credential is present" : `${snapshot.account.reason}; codex-routed image models and live verification are unavailable`
+    },
+    {
+      name: "Antigravity account",
+      ok: antigravityOk,
+      warn: enabled && antigravityRouted && !antigravity.usable,
+      detail: !antigravityRouted ? "not routed by the current model table (no credential required)" : antigravity.usable ? "eligible local credential is present (protocol evidence still unverified)" : `${antigravity.reason}; antigravity-routed image models are unavailable`
     },
     {
       name: "cached capability evidence",
@@ -20877,6 +21675,12 @@ async function runImagesLiveDoctor(config, doctor, signal = new AbortController(
     "  [\u26A0] live Images verification may consume subscription quota; one minimal low-quality PNG request will be sent"
   );
   const result = await doctor.verifyLive(config.images ?? import_outbound_api12.DEFAULT_IMAGES_SERVER_CONFIG, signal);
+  const antigravityRouted = Object.values(config.images?.models ?? {}).includes("antigravity-subscription");
+  if (antigravityRouted) {
+    console.info(
+      "  [i] live verification covers the Codex wire only; the Antigravity provider has no independent verifier in v1 (its first real request bootstraps)"
+    );
+  }
   if (!result.ok) {
     console.info(`  [\u2717] live Images verification: ${result.code}`);
     return false;
@@ -21011,14 +21815,49 @@ async function runLiveProbe(url, key, fetchImpl = fetch) {
       status: res.status,
       estimateHeader: res.headers.get("x-omnicross-count-estimate")
     };
-  } catch (err8) {
+  } catch (err9) {
     return {
       status: null,
       estimateHeader: null,
-      error: err8 instanceof Error ? err8.message : String(err8)
+      error: err9 instanceof Error ? err9.message : String(err9)
     };
   }
 }
+async function runAntigravityDoctor(daemon, live) {
+  const config = await daemon.credentialStore.getFullConfig();
+  const accounts = config.antigravityAccounts ?? [];
+  const activeId = config.activeAntigravityAccountId ?? accounts[0]?.id;
+  const active = accounts.find((account) => account.id === activeId);
+  const snapshot = {
+    accountCount: accounts.length,
+    ...active?.tokens.email ? { activeEmail: active.tokens.email } : {},
+    hasAccessToken: Boolean(active?.tokens.accessToken),
+    expired: active?.tokens.status === "expired",
+    ...active?.tokens.expiresAt ? { expiresAt: active.tokens.expiresAt } : {}
+  };
+  const checks = buildAntigravityDoctorChecks(snapshot);
+  if (live && active) {
+    const refreshOk = await daemon.credentialStore.refreshAntigravityToken();
+    let quotaOk = false;
+    let detail = "quotaSummary collection produced no usable windows";
+    try {
+      const snapshots = await daemon.accountAllowanceService.refreshAntigravity(active.id);
+      quotaOk = hasFreshAntigravityQuota(snapshots.find((entry) => entry.accountId === active.id));
+      if (!quotaOk) detail = snapshots[0]?.lastErrorCode ?? detail;
+    } catch (error) {
+      detail = error instanceof Error ? error.message : String(error);
+    }
+    checks.push(...buildAntigravityLiveChecks({ refreshOk, quotaOk, detail }));
+  }
+  console.info("omnicross doctor antigravity \u2014 subscription credential health");
+  let hardFailure = false;
+  for (const check of checks) {
+    const mark = check.ok ? check.warn ? "\u26A0" : "\u2713" : "\u2717";
+    if (!check.ok) hardFailure = true;
+    console.info(`  [${mark}] ${check.name}: ${check.detail}`);
+  }
+  return hardFailure ? 1 : 0;
+}
 async function runDoctor(argv, fetchImpl = fetch) {
   const { values, positionals } = (0, import_node_util2.parseArgs)({
     args: argv,
@@ -21032,8 +21871,8 @@ async function runDoctor(argv, fetchImpl = fetch) {
     allowPositionals: true
   });
   const subject = positionals[0] ?? "claude";
-  if (subject !== "claude" && subject !== "images" && subject !== "search") {
-    throw new Error(`doctor: unknown subject '${subject}' (supported: 'claude', 'images', 'search')`);
+  if (subject !== "claude" && subject !== "images" && subject !== "search" && subject !== "antigravity") {
+    throw new Error(`doctor: unknown subject '${subject}' (supported: 'claude', 'images', 'search', 'antigravity')`);
   }
   const configPath = values.config;
   if (!configPath) {
@@ -21056,6 +21895,9 @@ async function runDoctor(argv, fetchImpl = fetch) {
         runtime: daemon.searchRuntime
       });
     }
+    if (subject === "antigravity") {
+      return await runAntigravityDoctor(daemon, values.live === true);
+    }
     const checks = subject === "images" ? buildImagesDoctorChecks(await daemon.imageDoctor.inspectLocal(
       serverConfig.images ?? import_outbound_api12.DEFAULT_IMAGES_SERVER_CONFIG
     )) : buildClaudeDoctorChecks(serverConfig);
@@ -21422,9 +22264,9 @@ async function runLaunch(argv, deps) {
     await daemon.llmConfig.ready();
     await daemon.migrateUsageStore();
     await daemon.providerProxy.start();
-  } catch (err8) {
+  } catch (err9) {
     await shutdownLaunchDaemon(daemon);
-    throw err8;
+    throw err9;
   }
   let launch;
   try {
@@ -21432,9 +22274,9 @@ async function runLaunch(argv, deps) {
       providerId: values.provider,
       model: values.model
     });
-  } catch (err8) {
+  } catch (err9) {
     await shutdownLaunchDaemon(daemon);
-    throw err8;
+    throw err9;
   }
   try {
     const plan = buildCliSpawnPlan({
@@ -21539,9 +22381,9 @@ function spawnCliInherit(plan) {
       process.removeListener("SIGINT", onSignal);
       process.removeListener("SIGTERM", onSignal);
     };
-    child.on("error", (err8) => {
+    child.on("error", (err9) => {
       detach();
-      if (err8.code === "ENOENT") {
+      if (err9.code === "ENOENT") {
         reject(
           new Error(
             `launch: "${plan.command}" not found on PATH \u2014 install the CLI first.`
@@ -21549,7 +22391,7 @@ function spawnCliInherit(plan) {
         );
         return;
       }
-      reject(err8);
+      reject(err9);
     });
     child.on("exit", (code, signal) => {
       detach();
@@ -21562,9 +22404,10 @@ function spawnCliInherit(plan) {
 var import_node_child_process3 = require("child_process");
 var import_node_readline2 = require("readline");
 var import_node_util7 = require("util");
-var import_upstreamFetch17 = require("@omnicross/core/pipeline/upstreamFetch");
-var import_subscriptions13 = require("@omnicross/subscriptions");
-var PROVIDERS2 = ["claude", "codex", "gemini", "kimi", "grok", "copilot"];
+var import_GeminiCodeAssistProjectResolver7 = require("@omnicross/core/auth/GeminiCodeAssistProjectResolver");
+var import_upstreamFetch19 = require("@omnicross/core/pipeline/upstreamFetch");
+var import_subscriptions14 = require("@omnicross/subscriptions");
+var PROVIDERS2 = ["claude", "codex", "gemini", "kimi", "grok", "copilot", "antigravity"];
 async function runLogin(argv, deps) {
   const { values, positionals } = (0, import_node_util7.parseArgs)({
     args: argv,
@@ -21591,11 +22434,11 @@ async function runLogin(argv, deps) {
   if (values.enterprise !== void 0 && provider !== "copilot") {
     throw new Error("login: --enterprise is only supported for the copilot provider");
   }
-  const enterpriseDomain = values.enterprise !== void 0 ? import_subscriptions13.copilotOAuth.normalizeCopilotEnterpriseDomain(values.enterprise) : void 0;
+  const enterpriseDomain = values.enterprise !== void 0 ? import_subscriptions14.copilotOAuth.normalizeCopilotEnterpriseDomain(values.enterprise) : void 0;
   const resolved = {
     openBrowser: deps?.openBrowser ?? openBrowser,
     promptPaste: deps?.promptPaste ?? promptPaste,
-    awaitLoopback: deps?.awaitLoopback ?? ((state) => awaitLoopbackCode(state)),
+    awaitLoopback: deps?.awaitLoopback ?? ((state, timeoutMs, signal, binding) => awaitLoopbackCode(state, timeoutMs, signal, binding)),
     awaitKimiDevice: deps?.awaitKimiDevice ?? ((fetchImpl) => runKimiDeviceFlow(fetchImpl, resolvedOpenBrowser)),
     awaitGrokDevice: deps?.awaitGrokDevice ?? ((fetchImpl) => runGrokDeviceFlow(fetchImpl, resolvedOpenBrowser)),
     awaitCopilotDevice: deps?.awaitCopilotDevice ?? ((fetchImpl, enterpriseUrl) => runCopilotDeviceFlow(fetchImpl, resolvedOpenBrowser, enterpriseUrl)),
@@ -21604,10 +22447,10 @@ async function runLogin(argv, deps) {
   const resolvedOpenBrowser = resolved.openBrowser;
   const box = resolveSecretBox(values["master-key-file"]);
   setSecretBox(box);
-  (0, import_upstreamFetch17.setUpstreamProxyResolver)(createUpstreamProxyResolver());
+  (0, import_upstreamFetch19.setUpstreamProxyResolver)(createUpstreamProxyResolver());
   try {
     const tokensPath = defaultTokensPath(values.config);
-    const exchangeFetch = resolved.tokensFetch ?? ((url, init) => (0, import_upstreamFetch17.fetchUpstream)(url, init, { providerId: provider, redactBodies: true }));
+    const exchangeFetch = resolved.tokensFetch ?? ((url, init) => (0, import_upstreamFetch19.fetchUpstream)(url, init, { providerId: provider, redactBodies: true }));
     const store = new JsonSubscriptionCredentialStore(tokensPath, box, exchangeFetch);
     const expiresAt = await runProviderLogin(
       provider,
@@ -21621,7 +22464,7 @@ async function runLogin(argv, deps) {
     console.info(`  token: [stored, encrypted]   expiresAt: ${expiresAt ?? "n/a"}`);
   } finally {
     setSecretBox(null);
-    (0, import_upstreamFetch17.setUpstreamProxyResolver)(null);
+    (0, import_upstreamFetch19.setUpstreamProxyResolver)(null);
   }
 }
 async function runProviderLogin(provider, store, deps, exchangeFetch, label, enterpriseUrl) {
@@ -21630,13 +22473,14 @@ async function runProviderLogin(provider, store, deps, exchangeFetch, label, ent
   if (provider === "kimi") return loginKimi(store, deps, exchangeFetch, label);
   if (provider === "grok") return loginGrok(store, deps, exchangeFetch, label);
   if (provider === "copilot") return loginCopilot(store, deps, exchangeFetch, label, enterpriseUrl);
+  if (provider === "antigravity") return loginAntigravity(store, deps, exchangeFetch, label);
   return loginGemini(store, deps, exchangeFetch, label);
 }
 async function loginCodex(store, deps, exchangeFetch, label) {
-  const { authUrl, codeVerifier, state } = import_subscriptions13.codexOAuth.generateAuthParams();
+  const { authUrl, codeVerifier, state } = import_subscriptions14.codexOAuth.generateAuthParams();
   await presentUrl(authUrl, deps);
   const code = await deps.awaitLoopback(state);
-  const result = await import_subscriptions13.codexOAuth.exchangeCodeForTokens(
+  const result = await import_subscriptions14.codexOAuth.exchangeCodeForTokens(
     { authorizationCode: code, codeVerifier, state },
     exchangeFetch
   );
@@ -21655,7 +22499,7 @@ async function loginCodex(store, deps, exchangeFetch, label) {
   return expiresAt;
 }
 async function loginClaude(store, deps, exchangeFetch, label) {
-  const { authUrl, codeVerifier, state } = import_subscriptions13.claudeOAuth.generateAuthParams();
+  const { authUrl, codeVerifier, state } = import_subscriptions14.claudeOAuth.generateAuthParams();
   await presentUrl(authUrl, deps);
   const pasted = (await deps.promptPaste("Paste the authorization code (code#state): ")).trim();
   const [code, pastedState] = pasted.split("#");
@@ -21663,7 +22507,7 @@ async function loginClaude(store, deps, exchangeFetch, label) {
   if (pastedState && pastedState !== state) {
     throw new Error("login: pasted state did not match (possible CSRF) \u2014 aborting");
   }
-  const result = await import_subscriptions13.claudeOAuth.exchangeCodeForTokens(
+  const result = await import_subscriptions14.claudeOAuth.exchangeCodeForTokens(
     { authorizationCode: code, codeVerifier, state },
     exchangeFetch
   );
@@ -21682,11 +22526,11 @@ async function loginClaude(store, deps, exchangeFetch, label) {
   return expiresAt;
 }
 async function loginGemini(store, deps, exchangeFetch, label) {
-  const { authUrl, codeVerifier } = import_subscriptions13.geminiOAuth.generateAuthParams();
+  const { authUrl, codeVerifier } = import_subscriptions14.geminiOAuth.generateAuthParams();
   await presentUrl(authUrl, deps);
   const code = (await deps.promptPaste("Paste the authorization code: ")).trim();
   if (!code) throw new Error("login: no authorization code was pasted");
-  const result = await import_subscriptions13.geminiOAuth.exchangeCodeForTokens(code, codeVerifier, exchangeFetch);
+  const result = await import_subscriptions14.geminiOAuth.exchangeCodeForTokens(code, codeVerifier, exchangeFetch);
   const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
   const block = {
     authMethod: "oauth",
@@ -21701,9 +22545,9 @@ async function loginGemini(store, deps, exchangeFetch, label) {
   return expiresAt;
 }
 async function runKimiDeviceFlow(exchangeFetch, openBrowserFn) {
-  const deviceId = import_subscriptions13.kimiOAuth.generateKimiDeviceId();
-  const fingerprint = import_subscriptions13.kimiOAuth.kimiFingerprintHeaders(deviceId);
-  const authorization = await import_subscriptions13.kimiOAuth.requestDeviceAuthorization(exchangeFetch, fingerprint);
+  const deviceId = import_subscriptions14.kimiOAuth.generateKimiDeviceId();
+  const fingerprint = import_subscriptions14.kimiOAuth.kimiFingerprintHeaders(deviceId);
+  const authorization = await import_subscriptions14.kimiOAuth.requestDeviceAuthorization(exchangeFetch, fingerprint);
   const url = authorization.verificationUriComplete ?? authorization.verificationUri;
   console.info("Open this URL in your browser and approve the request:");
   console.info(`  ${url}`);
@@ -21711,14 +22555,14 @@ async function runKimiDeviceFlow(exchangeFetch, openBrowserFn) {
     console.info(`  Then enter this code: ${authorization.userCode}`);
   }
   await openBrowserFn(url).catch(() => false);
-  const result = await import_subscriptions13.kimiOAuth.awaitDeviceToken(authorization, exchangeFetch, {
+  const result = await import_subscriptions14.kimiOAuth.awaitDeviceToken(authorization, exchangeFetch, {
     fingerprint,
     onPending: () => process.stdout.write(".")
   });
   console.info("");
   return {
     ...result,
-    accountId: import_subscriptions13.kimiOAuth.kimiAccountIdFromAccessToken(result.accessToken),
+    accountId: import_subscriptions14.kimiOAuth.kimiAccountIdFromAccessToken(result.accessToken),
     deviceId
   };
 }
@@ -21740,8 +22584,8 @@ async function loginKimi(store, deps, exchangeFetch, label) {
   return expiresAt;
 }
 async function runGrokDeviceFlow(exchangeFetch, openBrowserFn) {
-  const tokenEndpoint = await import_subscriptions13.grokOAuth.resolveGrokTokenEndpoint(exchangeFetch);
-  const authorization = await import_subscriptions13.grokOAuth.requestGrokDeviceAuthorization(exchangeFetch);
+  const tokenEndpoint = await import_subscriptions14.grokOAuth.resolveGrokTokenEndpoint(exchangeFetch);
+  const authorization = await import_subscriptions14.grokOAuth.requestGrokDeviceAuthorization(exchangeFetch);
   const url = authorization.verificationUriComplete ?? authorization.verificationUri;
   console.info("Open this URL in your browser and approve the request:");
   console.info(`  ${url}`);
@@ -21749,13 +22593,13 @@ async function runGrokDeviceFlow(exchangeFetch, openBrowserFn) {
     console.info(`  Then enter this code: ${authorization.userCode}`);
   }
   await openBrowserFn(url).catch(() => false);
-  const result = await import_subscriptions13.grokOAuth.awaitGrokDeviceToken(authorization, tokenEndpoint, exchangeFetch, {
+  const result = await import_subscriptions14.grokOAuth.awaitGrokDeviceToken(authorization, tokenEndpoint, exchangeFetch, {
     onPending: () => process.stdout.write(".")
   });
   console.info("");
   return {
     ...result,
-    accountId: import_subscriptions13.grokOAuth.grokAccountIdFromAccessToken(result.accessToken)
+    accountId: import_subscriptions14.grokOAuth.grokAccountIdFromAccessToken(result.accessToken)
   };
 }
 async function loginGrok(store, deps, exchangeFetch, label) {
@@ -21776,28 +22620,28 @@ async function loginGrok(store, deps, exchangeFetch, label) {
 }
 async function runCopilotDeviceFlow(exchangeFetch, openBrowserFn, enterpriseUrl) {
   if (enterpriseUrl) console.info(`Using GitHub Enterprise host: ${enterpriseUrl}`);
-  const authorization = await import_subscriptions13.copilotOAuth.requestCopilotDeviceAuthorization(exchangeFetch, enterpriseUrl);
+  const authorization = await import_subscriptions14.copilotOAuth.requestCopilotDeviceAuthorization(exchangeFetch, enterpriseUrl);
   const url = authorization.verificationUri;
   console.info("Open this URL in your browser and approve the request:");
   console.info(`  ${url}`);
   console.info(`  Then enter this code: ${authorization.userCode}`);
   await openBrowserFn(url).catch(() => false);
-  const result = await import_subscriptions13.copilotOAuth.awaitCopilotDeviceToken(authorization, exchangeFetch, {
+  const result = await import_subscriptions14.copilotOAuth.awaitCopilotDeviceToken(authorization, exchangeFetch, {
     onPending: () => process.stdout.write("."),
     ...enterpriseUrl ? { enterpriseUrl } : {}
   });
   console.info("");
-  const identity = await import_subscriptions13.copilotOAuth.fetchCopilotIdentity(result.accessToken, exchangeFetch, enterpriseUrl);
-  const apiEndpoint = await import_subscriptions13.copilotOAuth.discoverCopilotApiEndpoint(result.accessToken, exchangeFetch, enterpriseUrl);
+  const identity = await import_subscriptions14.copilotOAuth.fetchCopilotIdentity(result.accessToken, exchangeFetch, enterpriseUrl);
+  const apiEndpoint = await import_subscriptions14.copilotOAuth.discoverCopilotApiEndpoint(result.accessToken, exchangeFetch, enterpriseUrl);
   console.info("Enabling Copilot models (policy)...");
-  await import_subscriptions13.copilotOAuth.enableAllCopilotModels(
+  await import_subscriptions14.copilotOAuth.enableAllCopilotModels(
     result.accessToken,
     { apiEndpoint, ...enterpriseUrl ? { enterpriseUrl } : {} },
     exchangeFetch
   );
   return {
     accessToken: result.accessToken,
-    expiresIn: Math.floor(import_subscriptions13.copilotOAuth.COPILOT_FAR_FUTURE_MS / 1e3),
+    expiresIn: Math.floor(import_subscriptions14.copilotOAuth.COPILOT_FAR_FUTURE_MS / 1e3),
     ...identity,
     ...apiEndpoint ? { apiEndpoint } : {}
   };
@@ -21823,6 +22667,70 @@ async function loginCopilot(store, deps, exchangeFetch, label, enterpriseUrl) {
   logMasked("copilot", result.accessToken);
   return expiresAt;
 }
+async function loginAntigravity(store, deps, exchangeFetch, label) {
+  const { authUrl, state } = import_subscriptions14.antigravityOAuth.generateAuthParams();
+  await presentUrl(authUrl, deps);
+  const code = await captureAntigravityCode(deps, state);
+  const result = await import_subscriptions14.antigravityOAuth.exchangeCodeForTokens(code, exchangeFetch);
+  const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
+  const email = await import_subscriptions14.antigravityOAuth.fetchUserEmail(result.accessToken, exchangeFetch);
+  console.info("Resolving the Antigravity Cloud Code Assist project...");
+  const projectId = await (0, import_GeminiCodeAssistProjectResolver7.getAntigravityProjectResolver)().resolveProject(result.accessToken);
+  const block = {
+    authMethod: "oauth",
+    status: "authorized",
+    accessToken: result.accessToken,
+    refreshToken: result.refreshToken,
+    expiresAt,
+    ...email ? { email } : {},
+    ...projectId ? { projectId } : {},
+    lastRefreshedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await store.appendProviderAccount("antigravity", block, label);
+  logMasked("antigravity", result.accessToken);
+  return expiresAt;
+}
+async function captureAntigravityCode(deps, state) {
+  try {
+    return await deps.awaitLoopback(state, void 0, void 0, {
+      port: 51121,
+      path: "/oauth-callback",
+      label: "antigravity"
+    });
+  } catch (loopbackError) {
+    const reason = loopbackError instanceof Error ? loopbackError.message : String(loopbackError);
+    console.warn(`(loopback capture unavailable: ${reason})`);
+    console.info(
+      "Paste fallback: after authorizing, copy the failing redirect URL (or just its code parameter) here."
+    );
+    const pasted = (await deps.promptPaste("Paste the authorization code (or redirect URL): ")).trim();
+    if (!pasted) throw new Error("login: no authorization code was pasted");
+    const { code, state: pastedState } = parseAntigravityPaste(pasted);
+    if (!code) throw new Error("login: the pasted value carried no authorization code");
+    if (pastedState && pastedState !== state) {
+      throw new Error("login: pasted state did not match (possible CSRF) \u2014 aborting");
+    }
+    return code;
+  }
+}
+function parseAntigravityPaste(pasted) {
+  if (pasted.includes("://")) {
+    try {
+      const url = new URL(pasted);
+      const code = url.searchParams.get("code") ?? "";
+      const state = url.searchParams.get("state") ?? void 0;
+      return { code, ...state ? { state } : {} };
+    } catch {
+    }
+  }
+  if (/^[?]?code=/.test(pasted)) {
+    const params = new URLSearchParams(pasted.replace(/^\?/, ""));
+    const code = params.get("code") ?? "";
+    const state = params.get("state") ?? void 0;
+    return { code, ...state ? { state } : {} };
+  }
+  return { code: pasted };
+}
 function isLoginProvider(value) {
   return PROVIDERS2.includes(value);
 }
@@ -22244,7 +23152,11 @@ var TOKEN_FIELDS2 = {
   claude: ["accessToken", "refreshToken"],
   codex: ["accessToken", "refreshToken", "idToken"],
   gemini: ["accessToken", "refreshToken"],
-  opencodego: ["apiKey"]
+  opencodego: ["apiKey"],
+  kimi: ["accessToken", "refreshToken"],
+  grok: ["accessToken", "refreshToken"],
+  copilot: ["accessToken", "refreshToken"],
+  antigravity: ["accessToken", "refreshToken"]
 };
 function walkTokens(raw, fn) {
   const next = { ...raw };
@@ -22528,7 +23440,7 @@ async function main() {
       process.exitCode = 1;
   }
 }
-main().catch((err8) => {
-  console.error(err8 instanceof Error ? err8.message : String(err8));
+main().catch((err9) => {
+  console.error(err9 instanceof Error ? err9.message : String(err9));
   process.exitCode = 1;
 });