@omnicross/daemon 0.4.2 → 0.4.4

package/dist/index.js

@@ -18,16 +18,18 @@ import { setSubscriptionRegistryForOutbound } from "@omnicross/core/outbound-api
 import { getSharedAccountHealth as getSharedAccountHealth4 } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
 import {
   __resetSharedAccountAllowanceStoreForTests,
-  AccountAllowanceStore as AccountAllowanceStore9,
+  AccountAllowanceStore as AccountAllowanceStore10,
   setSharedAccountAllowanceStore
 } from "@omnicross/core/pipeline/AccountAllowanceStore";
 import {
   __resetSharedAccountAllowanceSchedulingForTests,
   getSharedAccountAllowanceScheduling as getSharedAccountAllowanceScheduling5
 } from "@omnicross/core/pipeline/AccountAllowanceScheduling";
-import { fetchUpstream as fetchUpstream14, setUpstreamProxyResolver } from "@omnicross/core/pipeline/upstreamFetch";
+import { fetchUpstream as fetchUpstream16, setUpstreamProxyResolver } from "@omnicross/core/pipeline/upstreamFetch";
 import { __resetSharedIdentityStoreForTests } from "@omnicross/core/provider-proxy/identity/SubscriptionIdentityStore";
 import { setGeminiCodeAssistResolver } from "@omnicross/core/ports/gemini-code-assist-resolver";
+import { setAntigravitySandboxFailover } from "@omnicross/core/transformer/transformers/antigravityFailover";
+import { setOpenCodeGoUserAgent } from "@omnicross/core/provider-proxy/identity/openCodeGoHeaders";
 import {
   __resetProviderProxyForTests,
   createNativeResponsesHostedImageIngress,
@@ -411,7 +413,7 @@ function handleCopilotOAuthStatus(sessionId, deps) {
 
 // src/allowance/AccountAllowanceService.ts
 import {
-  getSharedAccountAllowanceStore as getSharedAccountAllowanceStore8
+  getSharedAccountAllowanceStore as getSharedAccountAllowanceStore9
 } from "@omnicross/core/pipeline/AccountAllowanceStore";
 import {
   getSharedAccountAllowanceScheduling
@@ -1801,11 +1803,328 @@ var GeminiAllowanceCollector = class {
   }
 };
 
-// src/allowance/OpenCodeGoAllowanceCollector.ts
+// src/allowance/AntigravityAllowanceCollector.ts
+import { ANTIGRAVITY_CODE_ASSIST_ENDPOINT } from "@omnicross/core/auth/GeminiCodeAssistProjectResolver";
+import {
+  ANTIGRAVITY_COUNTER_TO_MODEL_FAMILY,
+  antigravityCounterFamiliesForBucketId
+} from "@omnicross/core/pipeline/antigravityQuotaFamily";
 import {
   getSharedAccountAllowanceStore as getSharedAccountAllowanceStore7
 } from "@omnicross/core/pipeline/AccountAllowanceStore";
 import { fetchUpstream as fetchUpstream7 } from "@omnicross/core/pipeline/upstreamFetch";
+import { getAntigravityUserAgent } from "@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 = 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: 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: 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 = getSharedAccountAllowanceStore7(), fetchImpl = (url, init, accountId) => fetchUpstream7(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(`${ANTIGRAVITY_CODE_ASSIST_ENDPOINT}${path2}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": 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
+import {
+  getSharedAccountAllowanceStore as getSharedAccountAllowanceStore8
+} from "@omnicross/core/pipeline/AccountAllowanceStore";
+import { fetchUpstream as fetchUpstream8 } from "@omnicross/core/pipeline/upstreamFetch";
+import { getOpenCodeGoUserAgent } from "@omnicross/core/provider-proxy/identity/openCodeGoHeaders";
 import { normalizeOpenCodeGoBaseUrl } from "@omnicross/subscriptions";
 var OPENCODEGO_ALLOWANCE_CACHE_MS = 5 * 6e4;
 var OPENCODEGO_DEFAULT_GO_BASE = "https://opencode.ai/zen/go";
@@ -1819,7 +2138,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));
 }
@@ -1834,12 +2153,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 = getSharedAccountAllowanceStore7(), fetchImpl = (url, init, accountId) => fetchUpstream7(url, init, { providerId: "opencodego", accountId, redactBodies: true }), now = Date.now) {
+  constructor(credentials, store = getSharedAccountAllowanceStore8(), fetchImpl = (url, init, accountId) => fetchUpstream8(url, init, { providerId: "opencodego", accountId, redactBodies: true }), now = Date.now) {
     this.credentials = credentials;
     this.store = store;
     this.fetchImpl = fetchImpl;
@@ -1872,7 +2191,14 @@ var OpenCodeGoAllowanceCollector = class {
     const base = account.tokens.baseUrl ? 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": getOpenCodeGoUserAgent()
+      },
       signal: AbortSignal.timeout(15e3)
     }, account.id);
     if (response.status === 401 || response.status === 403) {
@@ -1944,7 +2270,7 @@ function codexUnavailable(accountId, now) {
   };
 }
 var AccountAllowanceService = class {
-  constructor(credentials, store = getSharedAccountAllowanceStore8(), collector, codexCollector, kimiCollector, opencodegoCollector, grokCollector, copilotCollector, geminiCollector, now = Date.now) {
+  constructor(credentials, store = getSharedAccountAllowanceStore9(), collector, codexCollector, kimiCollector, opencodegoCollector, grokCollector, copilotCollector, geminiCollector, antigravityCollector, now = Date.now) {
     this.credentials = credentials;
     this.store = store;
     this.now = now;
@@ -1955,6 +2281,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;
@@ -1966,6 +2293,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
@@ -2014,6 +2342,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}`);
@@ -2022,6 +2355,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) {
@@ -2032,7 +2366,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. */
@@ -2102,6 +2437,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
@@ -2119,6 +2463,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) {
@@ -2555,7 +2900,7 @@ import {
 } from "@omnicross/contracts/image-generation-types";
 import { getSharedAccountAllowanceScheduling as getSharedAccountAllowanceScheduling2 } from "@omnicross/core/pipeline/AccountAllowanceScheduling";
 import { getSharedAccountHealth } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
-import { fetchUpstream as fetchUpstream8 } from "@omnicross/core/pipeline/upstreamFetch";
+import { fetchUpstream as fetchUpstream10 } from "@omnicross/core/pipeline/upstreamFetch";
 import { mergeExtraHeaders } from "@omnicross/core";
 
 // src/image-generation/imagesConfigValidation.ts
@@ -3172,7 +3517,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 };
@@ -3244,6 +3593,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;
@@ -3537,7 +3899,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) {
@@ -4642,6 +5006,167 @@ function createUpstreamProxyResolver(src = {}) {
   };
 }
 
+// src/admin/accountsAntigravityOAuth.ts
+import { getAntigravityProjectResolver } from "@omnicross/core/auth/GeminiCodeAssistProjectResolver";
+import { antigravityOAuth } from "@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 } = 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 antigravityOAuth.exchangeCodeForTokens(code, exchangeFetch);
+    if (!isPending()) return;
+    const expiresAt = new Date(Date.now() + result.expiresIn * 1e3).toISOString();
+    const email = await antigravityOAuth.fetchUserEmail(result.accessToken, exchangeFetch);
+    if (!isPending()) return;
+    const projectId = await 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
+import { lookupCanonicalCapabilities } from "@omnicross/contracts/canonical-models";
+import { SUBSCRIPTION_MODEL_CATALOG } from "@omnicross/contracts/subscription-model-catalog";
+import { ANTIGRAVITY_CODE_ASSIST_ENDPOINT as ANTIGRAVITY_CODE_ASSIST_ENDPOINT2 } from "@omnicross/core/auth/GeminiCodeAssistProjectResolver";
+import { fetchUpstream as fetchUpstream9 } from "@omnicross/core/pipeline/upstreamFetch";
+import { getAntigravityUserAgent as getAntigravityUserAgent2 } from "@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 = SUBSCRIPTION_MODEL_CATALOG.antigravity) {
+  const entries = staticIds.map((id) => {
+    const capabilities = 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) => fetchUpstream9(url, init, { providerId: "antigravity", redactBodies: true })) {
+  let response;
+  try {
+    response = await fetchImpl(`${ANTIGRAVITY_CODE_ASSIST_ENDPOINT2}/v1internal:fetchAvailableModels`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": getAntigravityUserAgent2()
+      },
+      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
 import { claudeOAuth, geminiOAuth } from "@omnicross/subscriptions";
 
@@ -4653,7 +5178,8 @@ var VALID_PROVIDER_IDS = [
   "opencodego",
   "kimi",
   "grok",
-  "copilot"
+  "copilot",
+  "antigravity"
 ];
 function asSubscriptionProviderId(id) {
   return VALID_PROVIDER_IDS.includes(id) ? id : null;
@@ -4835,7 +5361,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;
@@ -4869,7 +5395,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":
@@ -4905,12 +5431,12 @@ 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" ? claudeOAuth : geminiOAuth;
   const { authUrl, codeVerifier, state } = flow.generateAuthParams();
@@ -4919,23 +5445,23 @@ function handleOAuthStart(providerId, deps) {
 }
 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;
   }
@@ -4945,7 +5471,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;
@@ -5283,8 +5809,8 @@ function errBody(message) {
   return { error: { type: "admin_api_error", message } };
 }
 var defaultCommandRunner = (command) => new Promise((resolve10) => {
-  exec(command, { timeout: 18e4 }, (err8, _stdout, stderr) => {
-    if (err8) resolve10({ ok: false, error: stderr.trim() || err8.message });
+  exec(command, { timeout: 18e4 }, (err9, _stdout, stderr) => {
+    if (err9) resolve10({ ok: false, error: stderr.trim() || err9.message });
     else resolve10({ ok: true });
   });
 });
@@ -5330,8 +5856,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 = randomUUID2();
   let leaseId2;
@@ -5359,9 +5885,9 @@ async function handleCliLaunch(cli, body, ctx) {
     } else {
       launch = await buildLaunchEnv(cli, ctx.llmConfig, target);
     }
-  } catch (err8) {
-    const status = err8 instanceof RouteLeaseError2 ? err8.status : 400;
-    return { status, body: errBody(err8 instanceof Error ? err8.message : "failed to build launch env") };
+  } catch (err9) {
+    const status = err9 instanceof RouteLeaseError2 ? 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;
@@ -5389,9 +5915,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?.();
@@ -5940,7 +6466,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) {
@@ -5990,13 +6516,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;
     }
@@ -6074,7 +6600,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) {
@@ -6094,7 +6620,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;
     }
@@ -6123,12 +6649,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`);
@@ -6143,7 +6669,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`);
       }
     }
@@ -6456,7 +6982,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));
@@ -6978,7 +7509,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) {
@@ -6988,30 +7519,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
 import { getSharedUsageThroughputTracker } from "@omnicross/core/usage";
-var err7 = (status, message) => ({
+var err8 = (status, message) => ({
   status,
   body: { error: { type: "admin_api_error", message } }
 });
@@ -7024,7 +7555,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 };
 }
@@ -7049,14 +7580,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`
           );
@@ -7079,7 +7610,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) {
@@ -7128,7 +7659,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 } };
@@ -7137,7 +7668,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();
@@ -7157,13 +7688,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(
@@ -7173,21 +7704,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)) {
@@ -7232,7 +7763,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");
@@ -7309,6 +7840,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");
@@ -7466,7 +8007,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":
@@ -7492,8 +8033,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) {
@@ -7668,7 +8209,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 fetchUpstream8(url, { method: "GET", headers }, { providerId: "byo" });
+    const response = await fetchUpstream10(url, { method: "GET", headers }, { providerId: "byo" });
     if (!response.ok) {
       const text = await response.text().catch(() => "");
       let message = text.slice(0, 300);
@@ -7685,8 +8226,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}` });
   }
 }
@@ -7728,7 +8269,7 @@ async function handleTestModel(req, res, id, cfg) {
   Object.assign(headers, expandRowExtraHeaders(row));
   const startedAt = Date.now();
   try {
-    const response = await fetchUpstream8(
+    const response = await fetchUpstream10(
       url,
       { method: "POST", headers, body: JSON.stringify(payload) },
       { providerId: "byo" }
@@ -7750,8 +8291,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 });
   }
 }
@@ -8336,8 +8877,8 @@ function imageConfigurationAuditFields(previous, next) {
   const after = next ?? 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");
@@ -8541,6 +9082,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();
@@ -8566,12 +9113,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") {
@@ -8641,6 +9188,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);
     }
@@ -9003,7 +9554,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 loadServerConfig3(deps.settingsStore);
+  const images = serverConfig.images ?? 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");
   }
@@ -9018,14 +9603,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,
@@ -9035,7 +9620,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
@@ -9046,6 +9631,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),
@@ -9135,12 +9721,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) {
@@ -9169,8 +9755,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();
       resolve10();
     });
@@ -9275,7 +9861,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";
@@ -9318,13 +9904,13 @@ var AdminServer = class {
       const server = http2.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(resolve10, reject);
           return;
         }
-        reject(err8);
+        reject(err9);
       };
       server.on("error", onError);
       server.listen(port, bindAddr, () => {
@@ -9342,8 +9928,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" });
@@ -9566,7 +10152,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((resolve10, reject) => {
     let settled = false;
     const finish = (server2, fn) => {
@@ -9577,8 +10166,8 @@ function awaitLoopbackCode(expectedState, timeoutMs = DEFAULT_TIMEOUT_MS, signal
       server2.close();
     };
     const server = createServer2((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;
@@ -9607,25 +10196,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);
   });
 }
 
@@ -9695,7 +10284,7 @@ function createPoolKeysLoader(getProviderRow, autoDisabled) {
 
 // src/allowance/ProviderKeyQuotaService.ts
 import { mergeExtraHeaders as mergeExtraHeaders2 } from "@omnicross/core";
-import { fetchUpstream as fetchUpstream9 } from "@omnicross/core/pipeline/upstreamFetch";
+import { fetchUpstream as fetchUpstream11 } from "@omnicross/core/pipeline/upstreamFetch";
 
 // src/allowance/ProviderKeyQuota.ts
 var MINUTE_MS3 = 6e4;
@@ -9724,11 +10313,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) {
@@ -9795,17 +10384,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);
@@ -9824,7 +10413,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);
@@ -9838,7 +10427,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) => {
@@ -9865,14 +10454,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) {
@@ -9905,11 +10494,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"]);
@@ -9930,15 +10519,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"]);
@@ -9952,7 +10541,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"
     });
   }
@@ -9967,7 +10556,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"
     });
   }
@@ -9979,12 +10568,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"]);
@@ -9997,7 +10586,7 @@ function parseClinePassUsageLimitsPayload(payload, now) {
       usedPercent,
       windowMinutes: config.minutes,
       ...resetsAt !== void 0 ? { resetsAt } : {},
-      remainingSeconds: secondsUntil8(resetsAt, now),
+      remainingSeconds: secondsUntil9(resetsAt, now),
       state: "fresh"
     });
   }
@@ -10036,7 +10625,7 @@ function rowKeyEntries(row) {
   return [];
 }
 var ProviderKeyQuotaService = class {
-  constructor(box, fetchImpl = (url, init) => fetchUpstream9(url, init, { redactBodies: true }), now = Date.now) {
+  constructor(box, fetchImpl = (url, init) => fetchUpstream11(url, init, { redactBodies: true }), now = Date.now) {
     this.box = box;
     this.fetchImpl = fetchImpl;
     this.now = now;
@@ -10643,12 +11232,12 @@ function createImageDoctorService(options) {
     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;
@@ -10686,6 +11275,7 @@ function createImageDoctorService(options) {
       } catch {
         storesValid = false;
       }
+      const antigravityAccount = await readAccount("antigravity");
       const rows = await options.keyDb.outboundApiKeysList();
       let legacyRows = 0;
       let invalidRows = 0;
@@ -10702,7 +11292,7 @@ function createImageDoctorService(options) {
           invalidRows += 1;
         }
       }
-      const account = await readAccount();
+      const account = await readAccount("codex");
       let evidence;
       let evidenceStore;
       try {
@@ -10716,10 +11306,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,
@@ -10744,12 +11335,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" });
       }
@@ -11010,6 +11602,7 @@ import {
   validateImagesServerConfig as validateImagesServerConfig3
 } from "@omnicross/core/outbound-api";
 import {
+  createAntigravitySubscriptionImageProvider,
   createCodexSubscriptionImageProvider
 } from "@omnicross/subscriptions";
 
@@ -11041,10 +11634,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,
@@ -11065,6 +11659,7 @@ function createTrustedImageApiRuntimeResolver(options) {
         providerId,
         defaultModel,
         modelAliases,
+        modelRoutes,
         limits,
         ...preferredAccountId ? { preferredAccountId } : {},
         ...preferredAccountGroup ? { preferredAccountGroup } : {},
@@ -11469,7 +12064,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 },
@@ -11503,10 +12100,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, randomBytes6);
   if (privateHmacKey.byteLength !== 32) {
     privateHmacKey.fill(0);
@@ -11541,23 +12143,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
-    }) : createCodexSubscriptionImageProvider({
-      authStrategy,
+    })] : routedProviders.map((providerId) => providerId === "codex-subscription" ? createCodexSubscriptionImageProvider({
+      authStrategy: codexStrategy,
       evidenceSource: generationEvidenceSource,
       executionScheduler: scheduler,
       generationTimeoutMs: config.queue.generationTimeoutMs,
+      now: options.now,
+      wire: {
+        imageModel: config.codex.imageModel,
+        carrierModel: config.codex.carrierModel
+      }
+    }) : 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 ImageProviderRegistry([provider]);
+    const providerRegistry = new ImageProviderRegistry(providers);
     const orchestrator = new ImageOrchestrator({
       registry: providerRegistry,
       referenceStore: options.storage.referenceStore,
@@ -11579,35 +12190,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 ImageGenerationError4 && (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 ImageGenerationError4 && (error.code === "upstream_auth_required" || error.code === "invalid_api_key") ? "account_unverified" : "runtime_unavailable"
+          routedModels,
+          providers: providers2,
+          reason: defaultProviderError instanceof ImageGenerationError4 && (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;
@@ -11645,7 +12293,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,
@@ -14642,6 +15290,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() {
@@ -16857,11 +17508,13 @@ var JsonVoucherDb = class {
 // src/ports/JsonSubscriptionCredentialStore.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync6, readFileSync as readFileSync18, renameSync as renameSync12 } from "fs";
 import { dirname as dirname15 } from "path";
+import { getAntigravityProjectResolver as getAntigravityProjectResolver2 } from "@omnicross/core/auth/GeminiCodeAssistProjectResolver";
 import { getSharedAccountHealth as getSharedAccountHealth2 } from "@omnicross/core/pipeline/SubscriptionAccountHealth";
 import { getSharedAccountAllowanceScheduling as getSharedAccountAllowanceScheduling3 } from "@omnicross/core/pipeline/AccountAllowanceScheduling";
-import { fetchUpstream as fetchUpstream10 } from "@omnicross/core/pipeline/upstreamFetch";
+import { fetchUpstream as fetchUpstream12 } from "@omnicross/core/pipeline/upstreamFetch";
 import { getSharedIdentityStore as getSharedIdentityStore2 } from "@omnicross/core/provider-proxy/identity/SubscriptionIdentityStore";
 import {
+  antigravityOAuth as antigravityOAuth2,
   claudeOAuth as claudeOAuth2,
   codexOAuth as codexOAuth2,
   geminiOAuth as geminiOAuth2,
@@ -17015,7 +17668,7 @@ var JsonSubscriptionCredentialStore = class {
    * a plaintext token pair into `upstream-trace.jsonl`.
    */
   buildRefreshFetch(providerId, accountId) {
-    return this.fetchImpl ?? ((url, init) => fetchUpstream10(url, init, { providerId, accountId, redactBodies: true }));
+    return this.fetchImpl ?? ((url, init) => fetchUpstream12(url, init, { providerId, accountId, redactBodies: true }));
   }
   /**
    * In-flight refresh coalescing. OAuth refresh tokens are
@@ -17056,7 +17709,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);
@@ -17075,7 +17728,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) {
@@ -17334,6 +17987,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 antigravityOAuth2.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 getAntigravityProjectResolver2().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
@@ -17362,6 +18085,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);
@@ -17386,7 +18110,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) {
@@ -17502,6 +18226,13 @@ var JsonSubscriptionCredentialStore = class {
     if (provider === "copilot") {
       throw new Error("GitHub Copilot tokens cannot be refreshed \u2014 re-authenticate the account");
     }
+    if (provider === "antigravity") {
+      const r2 = await antigravityOAuth2.refreshAccessToken(refreshToken, refreshFetch);
+      return {
+        accessToken: r2.accessToken,
+        expiresAt: new Date(Date.now() + r2.expiresIn * 1e3).toISOString()
+      };
+    }
     const flow = provider === "claude" ? claudeOAuth2 : provider === "codex" ? codexOAuth2 : geminiOAuth2;
     const r = await flow.refreshAccessToken(refreshToken, refreshFetch);
     return {
@@ -17745,7 +18476,7 @@ var JsonSubscriptionCredentialStore = class {
 };
 
 // src/AccountHealthProbeScheduler.ts
-import { fetchUpstream as fetchUpstream11 } from "@omnicross/core/pipeline/upstreamFetch";
+import { fetchUpstream as fetchUpstream13 } from "@omnicross/core/pipeline/upstreamFetch";
 
 // src/probe/CodexGenerationProbe.ts
 import {
@@ -17900,7 +18631,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" };
@@ -17922,7 +18657,7 @@ var AccountHealthProbeScheduler = class {
     this.logger = logger;
     this.config = config;
     this.now = opts.now ?? Date.now;
-    this.fetchImpl = opts.fetchImpl ?? fetchUpstream11;
+    this.fetchImpl = opts.fetchImpl ?? fetchUpstream13;
     this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     this.planFor = opts.planFor ?? probePlanFor;
   }
@@ -19627,7 +20362,7 @@ var AuditWriter = class {
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync8 } from "fs";
 import { createHmac as createHmac5 } from "crypto";
 import { join as join26 } from "path";
-import { fetchUpstream as fetchUpstream12 } from "@omnicross/core/pipeline/upstreamFetch";
+import { fetchUpstream as fetchUpstream14 } from "@omnicross/core/pipeline/upstreamFetch";
 
 // src/billing/billingFiles.ts
 var BILLING_FILE_RE = /^billing-(\d{4})-(\d{2})-(\d{2})\.jsonl$/;
@@ -19650,7 +20385,7 @@ var BillingPublisher = class {
   constructor(billingDir, logger, opts = {}) {
     this.billingDir = billingDir;
     this.logger = logger;
-    this.fetchImpl = opts.fetchImpl ?? ((url, init) => fetchUpstream12(url, init));
+    this.fetchImpl = opts.fetchImpl ?? ((url, init) => fetchUpstream14(url, init));
     this.defer = opts.defer ?? ((fn) => setTimeout(fn, 0));
     this.timeoutMs = opts.timeoutMs ?? BILLING_POST_TIMEOUT_MS;
     this.now = opts.now ?? Date.now;
@@ -19900,7 +20635,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;
@@ -19991,6 +20726,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();
     }
   }
 };
@@ -20069,7 +20806,7 @@ function createRouteLeaseSubscriptionPreflight(credentials) {
 
 // src/webhook/WebhookDispatcher.ts
 import { createHmac as createHmac6 } from "crypto";
-import { fetchUpstream as fetchUpstream13 } from "@omnicross/core/pipeline/upstreamFetch";
+import { fetchUpstream as fetchUpstream15 } from "@omnicross/core/pipeline/upstreamFetch";
 var WEBHOOK_MAX_ATTEMPTS = 3;
 var WEBHOOK_QUEUE_MAX = 1e3;
 var WEBHOOK_SEND_TIMEOUT_MS = 1e4;
@@ -20089,7 +20826,7 @@ var WebhookDispatcher = class {
   sleep;
   now;
   constructor(opts = {}) {
-    this.fetchImpl = opts.fetchImpl ?? ((url, init) => fetchUpstream13(url, init));
+    this.fetchImpl = opts.fetchImpl ?? ((url, init) => fetchUpstream15(url, init));
     this.logger = opts.logger;
     this.maxAttempts = opts.maxAttempts ?? WEBHOOK_MAX_ATTEMPTS;
     this.queueMax = opts.queueMax ?? WEBHOOK_QUEUE_MAX;
@@ -20175,8 +20912,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) };
     }
   }
   /**
@@ -20318,7 +21055,7 @@ function buildDaemon(config, paths) {
   setSecretBox(secretBox3);
   setSecretBox2(secretBox3);
   const decryptedConfig = decryptConfigSecrets(config, secretBox3);
-  const accountAllowanceStore = new AccountAllowanceStore9(
+  const accountAllowanceStore = new AccountAllowanceStore10(
     Date.now,
     void 0,
     new JsonAccountAllowancePersistence(defaultAccountAllowancePath(paths.configPath))
@@ -20362,6 +21099,8 @@ function buildDaemon(config, paths) {
     })
   );
   setGeminiCodeAssistResolver(getGeminiCodeAssistProjectResolver2());
+  setAntigravitySandboxFailover(decryptedConfig.antigravity?.sandboxFailover === true);
+  setOpenCodeGoUserAgent(decryptedConfig.opencodego?.userAgent ?? null);
   const autoDisableStore = new AutoDisableStore();
   const providerKeyQuotaService = new ProviderKeyQuotaService(secretBox3);
   const apiKeyPool = new ApiKeyPoolService(
@@ -20380,7 +21119,7 @@ function buildDaemon(config, paths) {
   const pricingEngine = new 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) => fetchUpstream14(String(input), init ?? {}))
+    fetchImpl: ((input, init) => fetchUpstream16(String(input), init ?? {}))
   });
   const pricingRefreshScheduler = new PricingRefreshScheduler(
     pricingEngine,
@@ -20622,6 +21361,7 @@ function buildDaemon(config, paths) {
     outboundApiServer,
     imageRuntimeConfig,
     imageRuntimeStatus: paths.imageRuntimeStatus ?? imageRuntimeManager,
+    imageLiveVerifier: paths.imageLiveVerifier ?? imageDoctor,
     imageConfigAudit: paths.imageConfigAudit ?? ((record) => {
       imageObservability.recordConfigurationAudit(record);
     }),
@@ -20665,7 +21405,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) => fetchUpstream14(url, init, { providerId, redactBodies: true }),
+    oauthExchangeFetch: paths.oauthExchangeFetch ? () => paths.oauthExchangeFetch : (providerId) => (url, init) => fetchUpstream16(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;
@@ -20680,6 +21420,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-
@@ -20738,7 +21493,7 @@ function buildDaemon(config, paths) {
   });
   const webhookDispatcher = new WebhookDispatcher({
     logger,
-    fetchImpl: (url, init) => fetchUpstream14(url, init)
+    fetchImpl: (url, init) => fetchUpstream16(url, init)
   });
   setWebhookRuntime(webhookDispatcher, getSharedAccountHealth4());
   const auditWriter = new AuditWriter(auditDir, logger);