@cortexkit/opencode-antigravity-auth 1.0.0 → 1.1.0

package/dist/index.js

@@ -7,7 +7,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/plugin.ts
 import { exec } from "node:child_process";
-import crypto4 from "node:crypto";
 
 // ../../node_modules/@opencode-ai/plugin/dist/tool.js
 import { z } from "zod";
@@ -67,6 +66,90 @@ function createLogger(module) {
   };
 }
 
+// ../core/dist/fingerprint.js
+import * as crypto from "node:crypto";
+var AGY_CLI_VERSION = "1.1.5";
+var ANTIGRAVITY_API_CLIENT = "antigravity-cli";
+var MAX_FINGERPRINT_HISTORY = 5;
+function normalizeHarnessPlatform(platform = process.platform) {
+  return platform === "win32" ? "windows" : platform || "unknown";
+}
+function normalizeHarnessArch(arch = process.arch) {
+  switch (arch) {
+    case "x64":
+      return "amd64";
+    case "ia32":
+      return "386";
+    default:
+      return arch || "unknown";
+  }
+}
+function buildAntigravityHarnessUserAgent(version = AGY_CLI_VERSION, platform = process.platform, arch = process.arch, authMethod = "consumer") {
+  const osType = normalizeHarnessPlatform(platform);
+  const normalizedArch = normalizeHarnessArch(arch);
+  return `antigravity/cli/${version} (aidev_client; os_type=${osType}; arch=${normalizedArch}; auth_method=${authMethod})`;
+}
+function buildAntigravityHarnessLoadCodeAssistUserAgent(version = AGY_CLI_VERSION) {
+  return buildAntigravityHarnessUserAgent(version);
+}
+function platformToMetadataPlatform(platform = process.platform) {
+  return platform === "win32" ? "WINDOWS" : "MACOS";
+}
+function buildAntigravityLoadCodeAssistMetadata() {
+  return { ideType: "ANTIGRAVITY" };
+}
+function buildAntigravityHarnessBootstrapHeaders(accessToken) {
+  return {
+    "User-Agent": buildAntigravityHarnessLoadCodeAssistUserAgent(),
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+    "Accept-Encoding": "gzip"
+  };
+}
+function generateDeviceId() {
+  return crypto.randomUUID();
+}
+function generateSessionToken() {
+  return crypto.randomBytes(16).toString("hex");
+}
+function generateFingerprint() {
+  return {
+    deviceId: generateDeviceId(),
+    sessionToken: generateSessionToken(),
+    userAgent: buildAntigravityHarnessUserAgent(),
+    apiClient: ANTIGRAVITY_API_CLIENT,
+    clientMetadata: {
+      ideType: "ANTIGRAVITY",
+      platform: platformToMetadataPlatform(),
+      pluginType: "GEMINI"
+    },
+    createdAt: Date.now()
+  };
+}
+function updateFingerprintVersion(fingerprint) {
+  const userAgent = buildAntigravityHarnessUserAgent();
+  if (fingerprint.userAgent === userAgent) {
+    return false;
+  }
+  fingerprint.userAgent = userAgent;
+  return true;
+}
+function buildFingerprintHeaders(fingerprint) {
+  if (!fingerprint) {
+    return {};
+  }
+  return {
+    "User-Agent": fingerprint.userAgent
+  };
+}
+var sessionFingerprint = null;
+function getSessionFingerprint() {
+  if (!sessionFingerprint) {
+    sessionFingerprint = generateFingerprint();
+  }
+  return sessionFingerprint;
+}
+
 // ../core/dist/constants.js
 var ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
 var ANTIGRAVITY_CLIENT_SECRET = "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";
@@ -122,11 +205,6 @@ var GEMINI_CLI_HEADERS = {
   "X-Goog-Api-Client": "gl-node/22.17.0",
   "Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI"
 };
-function buildAntigravityPlatformArch() {
-  const platform = process.platform === "win32" ? "windows" : process.platform || "unknown";
-  const arch = process.arch === "x64" ? "amd64" : process.arch === "ia32" ? "386" : process.arch || "unknown";
-  return `${platform}/${arch}`;
-}
 function getRandomizedHeaders(style, model) {
   if (style === "gemini-cli") {
     return {
@@ -135,9 +213,8 @@ function getRandomizedHeaders(style, model) {
       "Client-Metadata": GEMINI_CLI_HEADERS["Client-Metadata"]
     };
   }
-  const platform = buildAntigravityPlatformArch();
   return {
-    "User-Agent": `antigravity/cli/1.0.4 ${platform}`
+    "User-Agent": buildAntigravityHarnessUserAgent()
   };
 }
 var ANTIGRAVITY_PROVIDER_ID = "google";
@@ -205,91 +282,6 @@ function calculateTokenExpiry(requestTimeMs, expiresInSeconds) {
   return requestTimeMs + seconds * 1e3;
 }
 
-// ../core/dist/fingerprint.js
-import * as crypto from "node:crypto";
-var AGY_CLI_VERSION = "1.0.4";
-var ANTIGRAVITY_API_CLIENT = "antigravity-cli";
-var MAX_FINGERPRINT_HISTORY = 5;
-function normalizeHarnessPlatform(platform = process.platform) {
-  return platform === "win32" ? "windows" : platform || "unknown";
-}
-function normalizeHarnessArch(arch = process.arch) {
-  switch (arch) {
-    case "x64":
-      return "amd64";
-    case "ia32":
-      return "386";
-    default:
-      return arch || "unknown";
-  }
-}
-function buildAntigravityHarnessPlatformArch(platform = process.platform, arch = process.arch) {
-  return `${normalizeHarnessPlatform(platform)}/${normalizeHarnessArch(arch)}`;
-}
-function buildAntigravityHarnessUserAgent(version = AGY_CLI_VERSION, platform = process.platform, arch = process.arch) {
-  return `antigravity/cli/${version} ${buildAntigravityHarnessPlatformArch(platform, arch)}`;
-}
-function buildAntigravityHarnessLoadCodeAssistUserAgent(version = AGY_CLI_VERSION) {
-  return buildAntigravityHarnessUserAgent(version);
-}
-function platformToMetadataPlatform(platform = process.platform) {
-  return platform === "win32" ? "WINDOWS" : "MACOS";
-}
-function buildAntigravityLoadCodeAssistMetadata() {
-  return { ideType: "ANTIGRAVITY" };
-}
-function buildAntigravityHarnessBootstrapHeaders(accessToken) {
-  return {
-    "User-Agent": buildAntigravityHarnessLoadCodeAssistUserAgent(),
-    Authorization: `Bearer ${accessToken}`,
-    "Content-Type": "application/json",
-    "Accept-Encoding": "gzip"
-  };
-}
-function generateDeviceId() {
-  return crypto.randomUUID();
-}
-function generateSessionToken() {
-  return crypto.randomBytes(16).toString("hex");
-}
-function generateFingerprint() {
-  return {
-    deviceId: generateDeviceId(),
-    sessionToken: generateSessionToken(),
-    userAgent: buildAntigravityHarnessUserAgent(),
-    apiClient: ANTIGRAVITY_API_CLIENT,
-    clientMetadata: {
-      ideType: "ANTIGRAVITY",
-      platform: platformToMetadataPlatform(),
-      pluginType: "GEMINI"
-    },
-    createdAt: Date.now()
-  };
-}
-function updateFingerprintVersion(fingerprint) {
-  const userAgent = buildAntigravityHarnessUserAgent();
-  if (fingerprint.userAgent === userAgent) {
-    return false;
-  }
-  fingerprint.userAgent = userAgent;
-  return true;
-}
-function buildFingerprintHeaders(fingerprint) {
-  if (!fingerprint) {
-    return {};
-  }
-  return {
-    "User-Agent": fingerprint.userAgent
-  };
-}
-var sessionFingerprint = null;
-function getSessionFingerprint() {
-  if (!sessionFingerprint) {
-    sessionFingerprint = generateFingerprint();
-  }
-  return sessionFingerprint;
-}
-
 // ../core/dist/agy-transport.js
 import * as net from "node:net";
 import * as tls from "node:tls";
@@ -299,6 +291,7 @@ import { createGunzip } from "node:zlib";
 var DEFAULT_HTTPS_PORT = 443;
 var DEFAULT_PROXY_PORT = 8080;
 var DEFAULT_AGY_RESPONSE_HEADER_TIMEOUT_MS = 18e4;
+var DEFAULT_AGY_IDLE_TIMEOUT_MS = 18e4;
 function headersToRecord(headers) {
   const result = {};
   if (!headers)
@@ -331,7 +324,7 @@ function buildAgyCliHeaderPairs(url, init = {}) {
   const headers = headersToRecord(init.headers);
   const body = bodyToBuffer(init.body);
   const host = parsedUrl.port ? `${parsedUrl.hostname}:${parsedUrl.port}` : parsedUrl.hostname;
-  const userAgent = getHeader(headers, "User-Agent") ?? "antigravity/cli/1.0.4 darwin/arm64";
+  const userAgent = getHeader(headers, "User-Agent") ?? buildAntigravityHarnessUserAgent();
   const authorization = getHeader(headers, "Authorization");
   const contentType = getHeader(headers, "Content-Type") ?? "application/json";
   const acceptEncoding = getHeader(headers, "Accept-Encoding") ?? "gzip";
@@ -380,7 +373,7 @@ function getHttpsProxy(url) {
   }
 }
 function waitForHead(socket, timeoutMs, onTimeout) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let buffer = Buffer2.alloc(0);
     const timeout = setTimeout(() => {
       onTimeout();
@@ -400,7 +393,7 @@ function waitForHead(socket, timeoutMs, onTimeout) {
         return;
       const head = buffer.subarray(0, marker).toString("latin1");
       const leftover = buffer.subarray(marker + 4);
-      cleanup(() => resolve({ head, leftover }));
+      cleanup(() => resolve2({ head, leftover }));
     };
     socket.on("data", onData);
     socket.once("error", onError);
@@ -411,7 +404,7 @@ async function connectViaProxy(proxyUrl, targetUrl, timeoutMs, onDebug) {
     host: proxyUrl.hostname,
     port: Number(proxyUrl.port || DEFAULT_PROXY_PORT)
   });
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const timeout = setTimeout(() => {
       onDebug?.(`agy transport proxy connect timeout after ${timeoutMs}ms`);
       proxySocket.destroy();
@@ -420,7 +413,7 @@ async function connectViaProxy(proxyUrl, targetUrl, timeoutMs, onDebug) {
     const cleanup = () => clearTimeout(timeout);
     proxySocket.once("connect", () => {
       cleanup();
-      resolve();
+      resolve2();
     });
     proxySocket.once("error", (error) => {
       cleanup();
@@ -445,7 +438,7 @@ Host: ${targetHost}:${targetPort}\r
   if (leftover.length > 0) {
     proxySocket.unshift(leftover);
   }
-  return await new Promise((resolve, reject) => {
+  return await new Promise((resolve2, reject) => {
     const tlsSocket = tls.connect({ socket: proxySocket, servername: targetHost });
     const timeout = setTimeout(() => {
       onDebug?.(`agy transport proxy TLS handshake timeout after ${timeoutMs}ms`);
@@ -455,7 +448,7 @@ Host: ${targetHost}:${targetPort}\r
     const cleanup = () => clearTimeout(timeout);
     tlsSocket.once("secureConnect", () => {
       cleanup();
-      resolve(tlsSocket);
+      resolve2(tlsSocket);
     });
     tlsSocket.once("error", (error) => {
       cleanup();
@@ -464,7 +457,7 @@ Host: ${targetHost}:${targetPort}\r
   });
 }
 async function connectDirect(targetUrl, timeoutMs, onDebug) {
-  return await new Promise((resolve, reject) => {
+  return await new Promise((resolve2, reject) => {
     const socket = tls.connect({
       host: targetUrl.hostname,
       port: Number(targetUrl.port || DEFAULT_HTTPS_PORT),
@@ -478,7 +471,7 @@ async function connectDirect(targetUrl, timeoutMs, onDebug) {
     const cleanup = () => clearTimeout(timeout);
     socket.once("secureConnect", () => {
       cleanup();
-      resolve(socket);
+      resolve2(socket);
     });
     socket.once("error", (error) => {
       cleanup();
@@ -492,9 +485,9 @@ async function connectTls(targetUrl, timeoutMs, onDebug) {
 }
 function serializeRequest(url, init, body) {
   const method = init.method ?? "POST";
-  const path5 = `${url.pathname}${url.search}`;
+  const path4 = `${url.pathname}${url.search}`;
   const headerLines = buildAgyCliHeaderPairs(url.toString(), init).map(([key, value]) => `${key}: ${value}`).join("\r\n");
-  const head = Buffer2.from(`${method} ${path5} HTTP/1.1\r
+  const head = Buffer2.from(`${method} ${path4} HTTP/1.1\r
 ${headerLines}\r
 \r
 `);
@@ -522,6 +515,7 @@ function parseResponseHead(head) {
   const headers = new Headers();
   let chunked = false;
   let gzip = false;
+  let contentLength;
   for (const line of lines) {
     const index = line.indexOf(":");
     if (index <= 0)
@@ -538,8 +532,13 @@ function parseResponseHead(head) {
       gzip = true;
       continue;
     }
-    if (gzip && lowerKey === "content-length") {
-      continue;
+    if (lowerKey === "content-length") {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isFinite(parsed) && parsed >= 0) {
+        contentLength = parsed;
+      }
+      if (gzip)
+        continue;
     }
     headers.append(key, value);
   }
@@ -548,9 +547,34 @@ function parseResponseHead(head) {
     statusText: match[2] ?? "",
     headers,
     chunked,
-    gzip
+    gzip,
+    contentLength
   };
 }
+var ContentLengthStream = class extends Transform {
+  remaining;
+  constructor(contentLength) {
+    super();
+    this.remaining = contentLength;
+  }
+  _transform(chunk, _encoding, callback) {
+    if (this.remaining <= 0) {
+      callback();
+      return;
+    }
+    if (chunk.length <= this.remaining) {
+      this.remaining -= chunk.length;
+      this.push(chunk);
+    } else {
+      this.push(chunk.subarray(0, this.remaining));
+      this.remaining = 0;
+    }
+    if (this.remaining <= 0) {
+      this.push(null);
+    }
+    callback();
+  }
+};
 var ChunkedDecodeStream = class extends Transform {
   buffer = Buffer2.alloc(0);
   _transform(chunk, _encoding, callback) {
@@ -596,7 +620,7 @@ var ChunkedDecodeStream = class extends Transform {
     }
   }
 };
-function buildResponseStream(socket, leftover, head, signal) {
+function buildResponseStream(socket, leftover, head, signal, idleTimeoutMs, onDebug) {
   const source = new PassThrough();
   if (leftover.length > 0) {
     source.write(leftover);
@@ -605,12 +629,36 @@ function buildResponseStream(socket, leftover, head, signal) {
   let responseBody = source;
   if (head.chunked) {
     responseBody = responseBody.pipe(new ChunkedDecodeStream());
+  } else if (typeof head.contentLength === "number") {
+    responseBody = responseBody.pipe(new ContentLengthStream(head.contentLength));
   }
   if (head.gzip) {
     responseBody = responseBody.pipe(createGunzip());
   }
+  let idleTimer;
+  const clearIdle = () => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = void 0;
+    }
+  };
+  const armIdle = () => {
+    if (!idleTimeoutMs || idleTimeoutMs <= 0)
+      return;
+    clearIdle();
+    idleTimer = setTimeout(() => {
+      onDebug?.(`agy transport idle timeout after ${idleTimeoutMs}ms with no body data`);
+      socket.destroy(new Error(`Antigravity response stalled: no data for ${idleTimeoutMs}ms`));
+    }, idleTimeoutMs);
+  };
+  socket.on("data", armIdle);
+  armIdle();
   const abort = () => socket.destroy(new DOMException("The operation was aborted", "AbortError"));
-  const cleanup = () => signal?.removeEventListener("abort", abort);
+  const cleanup = () => {
+    clearIdle();
+    socket.off("data", armIdle);
+    signal?.removeEventListener("abort", abort);
+  };
   if (signal?.aborted) {
     abort();
   } else {
@@ -632,11 +680,15 @@ async function fetchWithAgyCliTransport(url, init = {}, options = {}) {
   if (parsedUrl.protocol !== "https:") {
     throw new Error(`agy transport only supports https URLs: ${url}`);
   }
+  if (options.signal?.aborted) {
+    throw new DOMException("The operation was aborted", "AbortError");
+  }
   const body = bodyToBuffer(init.body);
   const requestBytes = serializeRequest(parsedUrl, init, body);
   const timeoutMs = options.timeoutMs ?? DEFAULT_AGY_RESPONSE_HEADER_TIMEOUT_MS;
+  const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_AGY_IDLE_TIMEOUT_MS;
   options.onDebug?.(`agy transport connecting to ${parsedUrl.hostname} with header timeout ${timeoutMs}ms`);
-  const socket = await connectTls(parsedUrl, timeoutMs, options.onDebug);
+  const socket = await connectTlsWithAbort(parsedUrl, timeoutMs, options.signal, options.onDebug);
   const abort = () => {
     socket.destroy(new DOMException("The operation was aborted", "AbortError"));
   };
@@ -650,7 +702,7 @@ async function fetchWithAgyCliTransport(url, init = {}, options = {}) {
     });
     const parsedHead = parseResponseHead(head);
     options.onDebug?.(`agy transport response headers received: ${parsedHead.status} ${parsedHead.statusText}`);
-    const bodyStream = buildResponseStream(socket, leftover, parsedHead, options.signal);
+    const bodyStream = buildResponseStream(socket, leftover, parsedHead, options.signal, idleTimeoutMs, options.onDebug);
     return new Response(bodyStream, {
       status: parsedHead.status,
       statusText: parsedHead.statusText,
@@ -663,6 +715,199 @@ async function fetchWithAgyCliTransport(url, init = {}, options = {}) {
     options.signal?.removeEventListener("abort", abort);
   }
 }
+async function connectTlsWithAbort(targetUrl, timeoutMs, signal, onDebug) {
+  if (!signal) {
+    return connectTls(targetUrl, timeoutMs, onDebug);
+  }
+  const connectPromise = connectTls(targetUrl, timeoutMs, onDebug);
+  let onAbort;
+  const abortPromise = new Promise((_, reject) => {
+    onAbort = () => reject(new DOMException("The operation was aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([connectPromise, abortPromise]);
+  } catch (error) {
+    void connectPromise.then((socket) => socket.destroy()).catch(() => {
+    });
+    throw error;
+  } finally {
+    if (onAbort)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+
+// ../core/dist/agy-request-metadata.js
+import { Buffer as Buffer3 } from "node:buffer";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var FNV1A_64_OFFSET_BASIS = 0xcbf29ce484222325n;
+var FNV1A_64_PRIME = 0x100000001b3n;
+var DEFAULT_SESSION_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_MAX_SESSION_STATES = 256;
+var AGY_REQUEST_FIELD_ORDER = [
+  "contents",
+  "systemInstruction",
+  "tools",
+  "toolConfig",
+  "labels",
+  "generationConfig",
+  "sessionId"
+];
+var AGY_MODEL_ENUM_BY_WIRE_MODEL = {
+  "gemini-3.5-flash-extra-low": "MODEL_PLACEHOLDER_M187",
+  "gemini-3.5-flash-low": "MODEL_PLACEHOLDER_M20",
+  "gemini-3-flash-agent": "MODEL_PLACEHOLDER_M84",
+  "gemini-3.6-flash-low": "MODEL_PLACEHOLDER_M266",
+  "gemini-3.6-flash-medium": "MODEL_PLACEHOLDER_M265",
+  "gemini-3.6-flash-high": "MODEL_PLACEHOLDER_M264",
+  "gemini-3.1-pro-low": "MODEL_PLACEHOLDER_M36",
+  "gemini-pro-agent": "MODEL_PLACEHOLDER_M16",
+  "claude-sonnet-4-6": "MODEL_PLACEHOLDER_M35",
+  "claude-opus-4-6-thinking": "MODEL_PLACEHOLDER_M26",
+  "gemini-3.1-flash-image": "MODEL_PLACEHOLDER_M21",
+  "gpt-oss-120b-medium": "MODEL_OPENAI_GPT_OSS_120B_MEDIUM"
+};
+function fnv1a64Signed(input2) {
+  let hash = FNV1A_64_OFFSET_BASIS;
+  for (const byte of Buffer3.from(input2, "utf8")) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * FNV1A_64_PRIME);
+  }
+  return BigInt.asIntN(64, hash).toString();
+}
+function createAgyRequestSessionContext(workspaceUri, ids = {}) {
+  return {
+    conversationId: ids.conversationId ?? randomUUID2(),
+    trajectoryId: ids.trajectoryId ?? randomUUID2(),
+    numericSessionId: fnv1a64Signed(workspaceUri)
+  };
+}
+var AgyRequestSessionStore = class {
+  entries = /* @__PURE__ */ new Map();
+  workspaceUri;
+  ttlMs;
+  maxEntries;
+  now;
+  constructor(workspaceUri, options = {}) {
+    this.workspaceUri = workspaceUri;
+    this.ttlMs = options.ttlMs ?? DEFAULT_SESSION_STATE_TTL_MS;
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_SESSION_STATES;
+    this.now = options.now ?? Date.now;
+  }
+  getOrCreate(key) {
+    const timestamp = this.now();
+    this.prune(timestamp, key);
+    const existing = this.entries.get(key);
+    if (existing) {
+      existing.lastAccessedAt = timestamp;
+      return existing.context;
+    }
+    const context = createAgyRequestSessionContext(this.workspaceUri);
+    this.entries.set(key, {
+      context,
+      lastAccessedAt: timestamp,
+      lastRequestTimestamp: 0
+    });
+    return context;
+  }
+  beginRequest(key) {
+    const session = this.getOrCreate(key);
+    const stored = this.entries.get(key);
+    const timestamp = Math.max(stored.lastAccessedAt, stored.lastRequestTimestamp + 1);
+    stored.lastRequestTimestamp = timestamp;
+    return { session, timestamp };
+  }
+  has(key) {
+    return this.entries.has(key);
+  }
+  delete(key) {
+    this.entries.delete(key);
+  }
+  get size() {
+    return this.entries.size;
+  }
+  prune(timestamp, preservedKey) {
+    const expiry = timestamp - this.ttlMs;
+    for (const [key, value] of this.entries) {
+      if (key !== preservedKey && value.lastAccessedAt < expiry) {
+        this.entries.delete(key);
+      }
+    }
+    while (this.entries.size >= this.maxEntries && !this.entries.has(preservedKey)) {
+      let oldestKey = null;
+      let oldestAccess = Number.POSITIVE_INFINITY;
+      for (const [key, value] of this.entries) {
+        if (key !== preservedKey && value.lastAccessedAt < oldestAccess) {
+          oldestKey = key;
+          oldestAccess = value.lastAccessedAt;
+        }
+      }
+      if (!oldestKey) {
+        break;
+      }
+      this.entries.delete(oldestKey);
+    }
+  }
+};
+function getAgyModelEnum(model) {
+  return AGY_MODEL_ENUM_BY_WIRE_MODEL[model.toLowerCase()];
+}
+function orderAgyRequestPayloadInPlace(payload) {
+  const ordered = {};
+  const remaining = new Set(Object.keys(payload));
+  for (const key of AGY_REQUEST_FIELD_ORDER) {
+    if (key in payload) {
+      ordered[key] = payload[key];
+      remaining.delete(key);
+    }
+  }
+  for (const key of remaining) {
+    ordered[key] = payload[key];
+  }
+  for (const key of Object.keys(payload)) {
+    delete payload[key];
+  }
+  Object.assign(payload, ordered);
+}
+function countAgyRequestSteps(payload) {
+  const contents = payload.contents;
+  if (!Array.isArray(contents)) {
+    return 1;
+  }
+  let partCount = 0;
+  for (const content of contents) {
+    if (!content || typeof content !== "object" || Array.isArray(content)) {
+      continue;
+    }
+    const parts = content.parts;
+    if (Array.isArray(parts)) {
+      partCount += parts.length;
+    }
+  }
+  return Math.max(1, partCount);
+}
+function buildAgyAgentRequestMetadata(session, payload, model, timestamp = Date.now()) {
+  const lastStepIndex = countAgyRequestSteps(payload);
+  const isClaude = model.toLowerCase().startsWith("claude-");
+  const isNonGemini = isClaude || model.toLowerCase().startsWith("gpt-");
+  session.usedClaude = session.usedClaude === true || isClaude;
+  session.usedNonGeminiModel = session.usedNonGeminiModel === true || isNonGemini;
+  const modelEnum = getAgyModelEnum(model);
+  const labels = {
+    last_step_index: String(lastStepIndex),
+    ...modelEnum ? { model_enum: modelEnum } : {},
+    trajectory_id: session.trajectoryId,
+    used_claude: session.usedClaude ? "true" : "false",
+    used_claude_conservative: session.usedClaude ? "true" : "false",
+    used_non_gemini_model: session.usedNonGeminiModel ? "true" : "false"
+  };
+  return {
+    requestId: `agent/${session.conversationId}/${timestamp}/${session.trajectoryId}/${lastStepIndex + 1}`,
+    sessionId: session.numericSessionId,
+    labels,
+    lastStepIndex
+  };
+}
 
 // ../core/dist/version.js
 var VERSION_URL = "https://antigravity-auto-updater-974169037036.us-central1.run.app";
@@ -749,8 +994,8 @@ function getDefaultTierId(allowedTiers) {
   return allowedTiers[0]?.id;
 }
 function wait(ms) {
-  return new Promise(function(resolve) {
-    setTimeout(resolve, ms);
+  return new Promise(function(resolve2) {
+    setTimeout(resolve2, ms);
   });
 }
 function extractManagedProjectId(payload) {
@@ -954,6 +1199,16 @@ var ALL_MODEL_DEFINITIONS = {
       high: { thinkingLevel: "high" }
     }
   }),
+  "antigravity-gemini-3.6-flash": defineModel("antigravity-gemini-3.6-flash", {
+    name: "Gemini 3.6 Flash (Antigravity)",
+    reasoning: true,
+    limit: { context: 1048576, output: 65536 },
+    modalities: DEFAULT_MODALITIES,
+    variants: {
+      low: { thinkingLevel: "low" },
+      high: { thinkingLevel: "high" }
+    }
+  }),
   "antigravity-gemini-3.5-flash": defineModel("antigravity-gemini-3.5-flash", {
     name: "Gemini 3.5 Flash (Antigravity)",
     reasoning: true,
@@ -993,14 +1248,11 @@ var ALL_MODEL_DEFINITIONS = {
       output: ["text", "image"]
     }
   }),
-  "antigravity-gpt-oss-120b": defineModel("antigravity-gpt-oss-120b", {
-    name: "GPT-OSS 120B (Antigravity)",
-    reasoning: false,
-    limit: { context: 128e3, output: 16384 },
-    modalities: DEFAULT_MODALITIES,
-    variants: {
-      medium: {}
-    }
+  "antigravity-gpt-oss-120b-medium": defineModel("antigravity-gpt-oss-120b-medium", {
+    name: "GPT-OSS 120B Medium (Antigravity)",
+    reasoning: true,
+    limit: { context: 131072, output: 32768 },
+    modalities: DEFAULT_MODALITIES
   }),
   "gemini-2.5-flash": defineModel("gemini-2.5-flash", {
     name: "Gemini 2.5 Flash (Gemini CLI)",
@@ -1066,6 +1318,9 @@ var RESOLVER_ALIASES = {
   "gemini-3.5-flash-low": "gemini-3.5-flash",
   "gemini-3.5-flash-medium": "gemini-3.5-flash",
   "gemini-3.5-flash-high": "gemini-3.5-flash",
+  "gemini-3.6-flash-low": "gemini-3.6-flash",
+  "gemini-3.6-flash-medium": "gemini-3.6-flash",
+  "gemini-3.6-flash-high": "gemini-3.6-flash",
   "gemini-claude-opus-4-6-thinking-low": "claude-opus-4-6-thinking",
   "gemini-claude-opus-4-6-thinking-medium": "claude-opus-4-6-thinking",
   "gemini-claude-opus-4-6-thinking-high": "claude-opus-4-6-thinking",
@@ -1076,7 +1331,8 @@ var RESOLVER_ALIASES = {
   "claude-sonnet-4-6-thinking": "claude-sonnet-4-6",
   "claude-sonnet-4-6-thinking-low": "claude-sonnet-4-6",
   "claude-sonnet-4-6-thinking-medium": "claude-sonnet-4-6",
-  "claude-sonnet-4-6-thinking-high": "claude-sonnet-4-6"
+  "claude-sonnet-4-6-thinking-high": "claude-sonnet-4-6",
+  "gpt-oss-120b": "gpt-oss-120b-medium"
 };
 var GEMINI_35_FLASH_ROUTES = {
   antigravity: {
@@ -1089,6 +1345,14 @@ var GEMINI_35_FLASH_ROUTES = {
   },
   geminiCliFallbackModel: "gemini-3-flash-preview"
 };
+var GEMINI_36_FLASH_ROUTES = {
+  defaultModel: "gemini-3.6-flash-medium",
+  byTier: {
+    low: "gemini-3.6-flash-low",
+    medium: "gemini-3.6-flash-medium",
+    high: "gemini-3.6-flash-high"
+  }
+};
 var QUOTA_GROUP_BY_MODEL_ID = {
   "claude-opus-4-6-thinking": "claude",
   "claude-opus-4-6": "claude",
@@ -1102,15 +1366,22 @@ var QUOTA_GROUP_BY_MODEL_ID = {
   "gemini-3-flash-agent": "gemini-flash",
   "gemini-3.5-flash-low": "gemini-flash",
   "gemini-3.5-flash-extra-low": "gemini-flash",
+  "gemini-3.6-flash-low": "gemini-flash",
+  "gemini-3.6-flash-medium": "gemini-flash",
+  "gemini-3.6-flash-high": "gemini-flash",
+  "gemini-3.6-flash-tiered": "gemini-flash",
   "gemini-3.1-flash-image": "gemini-flash",
   "gpt-oss-120b": "gpt-oss",
   "gpt-oss-120b-medium": "gpt-oss"
 };
 var ANTIGRAVITY_OPENCODE_MODEL_IDS = [
+  "antigravity-gemini-3.6-flash",
   "antigravity-gemini-3.5-flash",
   "antigravity-gemini-3.1-pro",
   "antigravity-claude-sonnet-4-6-thinking",
-  "antigravity-claude-opus-4-6-thinking"
+  "antigravity-claude-opus-4-6-thinking",
+  "antigravity-gemini-3.1-flash-image",
+  "antigravity-gpt-oss-120b-medium"
 ];
 function pickModelDefinitions(ids) {
   return Object.fromEntries(ids.map((id) => [id, ALL_MODEL_DEFINITIONS[id]]));
@@ -1131,6 +1402,12 @@ function getGemini35FlashAntigravityModel(tier) {
 function getGemini35FlashGeminiCliFallbackModel() {
   return GEMINI_35_FLASH_ROUTES.geminiCliFallbackModel;
 }
+function getGemini36FlashAntigravityModel(tier) {
+  if (!tier) {
+    return GEMINI_36_FLASH_ROUTES.defaultModel;
+  }
+  return GEMINI_36_FLASH_ROUTES.byTier[tier] ?? GEMINI_36_FLASH_ROUTES.defaultModel;
+}
 function getQuotaGroupForModel(modelId) {
   return QUOTA_GROUP_BY_MODEL_ID[modelId.toLowerCase()];
 }
@@ -1187,7 +1464,7 @@ function isGemini35FlashModel(model) {
 function resolveGemini35FlashAntigravityModel(tier) {
   return getGemini35FlashAntigravityModel(tier);
 }
-function getAgyGemini35FlashThinkingBudget(tier) {
+function getAgyGeminiFlashThinkingBudget(tier) {
   switch (tier) {
     case "low":
       return 1e3;
@@ -1220,6 +1497,8 @@ function resolveModelWithTier(requestedModel, options = {}) {
   const isGemini3Flash = isGemini3FlashModel(modelWithoutQuota);
   const isGemini31Pro = /^gemini-3\.1-pro/i.test(baseName);
   const isGemini35Flash = /^gemini-3\.5-flash/i.test(baseName);
+  const isGemini36Flash = /^gemini-3\.6-flash/i.test(baseName);
+  const isGptOss120b = /^gpt-oss-120b(?:-medium)?$/i.test(baseName);
   if (isGemini31Pro && quotaPreference === "antigravity") {
     return {
       actualModel: getAgyGemini31ProModel(tier),
@@ -1233,13 +1512,32 @@ function resolveModelWithTier(requestedModel, options = {}) {
   if (isGemini35Flash && quotaPreference === "antigravity") {
     return {
       actualModel: resolveGemini35FlashAntigravityModel(tier ?? "medium"),
-      thinkingBudget: getAgyGemini35FlashThinkingBudget(tier),
+      thinkingBudget: getAgyGeminiFlashThinkingBudget(tier),
+      tier: tier ?? "medium",
+      isThinkingModel: true,
+      quotaPreference,
+      explicitQuota
+    };
+  }
+  if (isGemini36Flash && quotaPreference === "antigravity") {
+    return {
+      actualModel: getGemini36FlashAntigravityModel(tier ?? "medium"),
+      thinkingBudget: getAgyGeminiFlashThinkingBudget(tier),
       tier: tier ?? "medium",
       isThinkingModel: true,
       quotaPreference,
       explicitQuota
     };
   }
+  if (isGptOss120b && quotaPreference === "antigravity") {
+    return {
+      actualModel: "gpt-oss-120b-medium",
+      thinkingBudget: 8192,
+      isThinkingModel: true,
+      quotaPreference,
+      explicitQuota
+    };
+  }
   let antigravityModel = modelWithoutQuota;
   if (skipAlias) {
     if ((isGemini3Pro || isGemini3Flash) && !tier && !isImageModel) {
@@ -1436,12 +1734,26 @@ var UNSUPPORTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
   "minContains",
   "maxContains"
 ]);
-function toGeminiSchema(schema) {
+var NUMERIC_SCHEMA_CONSTRAINTS = /* @__PURE__ */ new Set([
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "minProperties",
+  "maxProperties",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf"
+]);
+function toGeminiSchema(schema, options = {}) {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
     return schema;
   }
   const inputSchema = schema;
   const result = {};
+  const numericConstraintHints = [];
   const propertyNames = /* @__PURE__ */ new Set();
   if (inputSchema.properties && typeof inputSchema.properties === "object") {
     for (const propName of Object.keys(inputSchema.properties)) {
@@ -1457,15 +1769,19 @@ function toGeminiSchema(schema) {
     } else if (key === "properties" && typeof value === "object" && value !== null) {
       const props = {};
       for (const [propName, propSchema] of Object.entries(value)) {
-        props[propName] = toGeminiSchema(propSchema);
+        props[propName] = toGeminiSchema(propSchema, options);
       }
       result[key] = props;
     } else if (key === "items" && typeof value === "object") {
-      result[key] = toGeminiSchema(value);
+      result[key] = toGeminiSchema(value, options);
     } else if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
-      result[key] = value.map((item) => toGeminiSchema(item));
+      result[key] = value.map((item) => toGeminiSchema(item, options));
     } else if (key === "enum" && Array.isArray(value)) {
       result[key] = value;
+    } else if (options.moveNumericConstraintsToDescription && NUMERIC_SCHEMA_CONSTRAINTS.has(key)) {
+      if (typeof value === "string" || typeof value === "number") {
+        numericConstraintHints.push(`${key}: ${value}`);
+      }
     } else if (key === "default" || key === "examples") {
       result[key] = value;
     } else if (key === "required" && Array.isArray(value)) {
@@ -1481,6 +1797,10 @@ function toGeminiSchema(schema) {
       result[key] = value;
     }
   }
+  if (numericConstraintHints.length > 0) {
+    const hint = numericConstraintHints.join(", ");
+    result.description = typeof result.description === "string" && result.description ? `${result.description} (${hint})` : hint;
+  }
   if (result.type === "ARRAY" && !result.items) {
     result.items = { type: "STRING" };
   }
@@ -1518,7 +1838,7 @@ function buildImageGenerationConfig() {
   console.warn(`[gemini] Invalid aspect ratio "${aspectRatio}". Using default "1:1". Valid values: ${VALID_ASPECT_RATIOS.join(", ")}`);
   return { aspectRatio: "1:1" };
 }
-function normalizeGeminiTools(payload) {
+function normalizeGeminiTools(payload, schemaOptions = {}) {
   let toolDebugMissing = 0;
   const toolDebugSummaries = [];
   if (!Array.isArray(payload.tools)) {
@@ -1529,6 +1849,21 @@ function normalizeGeminiTools(payload) {
     if (t.googleSearch || t.googleSearchRetrieval) {
       return t;
     }
+    if (Array.isArray(t.functionDeclarations)) {
+      return {
+        ...t,
+        functionDeclarations: t.functionDeclarations.map((declaration) => {
+          const normalized = { ...declaration };
+          const rawSchema = normalized.parameters ?? normalized.parametersJsonSchema ?? {
+            type: "OBJECT",
+            properties: {}
+          };
+          normalized.parameters = toGeminiSchema(rawSchema, schemaOptions);
+          delete normalized.parametersJsonSchema;
+          return normalized;
+        })
+      };
+    }
     const newTool = { ...t };
     const schemaCandidates = [
       newTool.function?.input_schema,
@@ -1556,7 +1891,7 @@ function normalizeGeminiTools(payload) {
       schema = placeholderSchema;
       toolDebugMissing += 1;
     } else {
-      schema = toGeminiSchema(schema);
+      schema = toGeminiSchema(schema, schemaOptions);
     }
     const nameCandidate = newTool.name || newTool.function?.name || newTool.custom?.name || `tool-${toolIndex}`;
     if (newTool.function && schema) {
@@ -1621,7 +1956,9 @@ function applyGeminiTransforms(payload, options) {
       googleSearch: {}
     });
   }
-  const result = normalizeGeminiTools(payload);
+  const result = normalizeGeminiTools(payload, {
+    moveNumericConstraintsToDescription: model.toLowerCase().startsWith("gpt-oss-")
+  });
   const wrapResult = wrapToolsAsFunctionDeclarations(payload);
   return {
     ...result,
@@ -2122,7 +2459,7 @@ async function select(items, options) {
     }
     renderedLines = linesWritten;
   };
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const wasRaw = stdin.isRaw ?? false;
     const cleanup = () => {
       if (isCleanedUp) return;
@@ -2143,11 +2480,11 @@ async function select(items, options) {
     };
     const onSignal = () => {
       cleanup();
-      resolve(null);
+      resolve2(null);
     };
     const finishWithValue = (value) => {
       cleanup();
-      resolve(value);
+      resolve2(value);
     };
     const findNextSelectable = (from, direction) => {
       if (items.length === 0) return from;
@@ -2193,7 +2530,7 @@ async function select(items, options) {
       stdin.setRawMode(true);
     } catch {
       cleanup();
-      resolve(null);
+      resolve2(null);
       return;
     }
     stdin.resume();
@@ -2320,7 +2657,7 @@ function classifyOverallQuotaHealth(cachedQuota) {
   if (!cachedQuota) {
     return { health: "unknown" };
   }
-  const QUOTA_KEYS2 = ["claude", "gemini-pro", "gemini-flash"];
+  const QUOTA_KEYS2 = ["claude", "gemini-pro", "gemini-flash", "gpt-oss"];
   let groupsWithData = 0;
   let exhaustedCount = 0;
   let maxResetMs;
@@ -2354,7 +2691,8 @@ function formatCachedQuotaWithStatus(cachedQuota) {
   const entries = [
     { key: "claude", label: "Claude" },
     { key: "gemini-pro", label: "Gemini Pro" },
-    { key: "gemini-flash", label: "Gemini Flash" }
+    { key: "gemini-flash", label: "Gemini Flash" },
+    { key: "gpt-oss", label: "GPT-OSS" }
   ].flatMap(({ key, label }) => {
     const value = cachedQuota[key]?.remainingFraction;
     if (typeof value !== "number" || !Number.isFinite(value)) {
@@ -2414,6 +2752,8 @@ function getStatusBadge(status, account) {
       return ` ${ANSI.red}[expired]${ANSI.reset}`;
     case "verification-required":
       return ` ${ANSI.red}[needs verification]${ANSI.reset}`;
+    case "ineligible":
+      return ` ${ANSI.red}[ineligible]${ANSI.reset}`;
     default:
       return "";
   }
@@ -2445,7 +2785,8 @@ function getHealthLabel(acc) {
 var QUOTA_KEYS = [
   { key: "claude", label: "Claude" },
   { key: "gemini-pro", label: "Gemini Pro" },
-  { key: "gemini-flash", label: "Gemini Flash" }
+  { key: "gemini-flash", label: "Gemini Flash" },
+  { key: "gpt-oss", label: "GPT-OSS" }
 ];
 function parseResetTimeToMs2(resetTime) {
   if (!resetTime) return null;
@@ -3083,11 +3424,13 @@ async function getLockFunction() {
   if (_cachedLock) return _cachedLock;
   const mod = await import("proper-lockfile");
   const fn = (typeof mod.lock === "function" ? mod.lock : void 0) || (mod.default && typeof mod.default.lock === "function" ? mod.default.lock : void 0);
-  _cachedLock = fn || (async () => async () => {
-  });
+  if (typeof fn !== "function") {
+    throw new Error("proper-lockfile did not expose a lock() function; cannot acquire account file lock");
+  }
+  _cachedLock = fn;
   return _cachedLock;
 }
-var lockfile = { lock: (path5, options) => getLockFunction().then((fn) => fn(path5, options)) };
+var lockfile = { lock: (path4, options) => getLockFunction().then((fn) => fn(path4, options)) };
 var log3 = createLogger2("storage");
 var GITIGNORE_ENTRIES = [
   ".gitignore",
@@ -3255,29 +3598,29 @@ var LOCK_OPTIONS = {
     factor: 2
   }
 };
-async function ensureSecurePermissions(path5) {
+async function ensureSecurePermissions(path4) {
   try {
-    await fs.chmod(path5, 384);
+    await fs.chmod(path4, 384);
   } catch {
   }
 }
-async function ensureFileExists(path5) {
+async function ensureFileExists(path4) {
   try {
-    await fs.access(path5);
+    await fs.access(path4);
   } catch {
-    await fs.mkdir(dirname2(path5), { recursive: true });
+    await fs.mkdir(dirname2(path4), { recursive: true });
     await fs.writeFile(
-      path5,
+      path4,
       JSON.stringify({ version: 4, accounts: [], activeIndex: 0 }, null, 2),
       { encoding: "utf-8", mode: 384 }
     );
   }
 }
-async function withFileLock(path5, fn) {
-  await ensureFileExists(path5);
+async function withFileLock(path4, fn) {
+  await ensureFileExists(path4);
   let release = null;
   try {
-    release = await lockfile.lock(path5, LOCK_OPTIONS);
+    release = await lockfile.lock(path4, LOCK_OPTIONS);
     return await fn();
   } finally {
     if (release) {
@@ -3300,7 +3643,8 @@ function mergeAccountStorage(existing, incoming) {
     if (acc.refreshToken) {
       const existingAcc = accountMap.get(acc.refreshToken);
       if (existingAcc) {
-        accountMap.set(acc.refreshToken, {
+        const eligibilitySource = (acc.eligibilityStateUpdatedAt ?? 0) >= (existingAcc.eligibilityStateUpdatedAt ?? 0) ? acc : existingAcc;
+        const merged = {
           ...existingAcc,
           ...acc,
           // Preserve manually configured projectId/managedProjectId if not in incoming
@@ -3310,8 +3654,16 @@ function mergeAccountStorage(existing, incoming) {
             ...existingAcc.rateLimitResetTimes,
             ...acc.rateLimitResetTimes
           },
-          lastUsed: Math.max(existingAcc.lastUsed || 0, acc.lastUsed || 0)
-        });
+          lastUsed: Math.max(existingAcc.lastUsed || 0, acc.lastUsed || 0),
+          accountIneligible: eligibilitySource.accountIneligible,
+          accountIneligibleAt: eligibilitySource.accountIneligibleAt,
+          accountIneligibleReason: eligibilitySource.accountIneligibleReason,
+          eligibilityStateUpdatedAt: eligibilitySource.eligibilityStateUpdatedAt
+        };
+        if (merged.accountIneligible) {
+          merged.enabled = false;
+        }
+        accountMap.set(acc.refreshToken, merged);
       } else {
         accountMap.set(acc.refreshToken, acc);
       }
@@ -3429,9 +3781,9 @@ function migrateV3ToV4(v3) {
 }
 async function loadAccounts() {
   try {
-    const path5 = getStoragePath();
-    await ensureSecurePermissions(path5);
-    const content = await fs.readFile(path5, "utf-8");
+    const path4 = getStoragePath();
+    await ensureSecurePermissions(path4);
+    const content = await fs.readFile(path4, "utf-8");
     const data = JSON.parse(content);
     if (!Array.isArray(data.accounts)) {
       log3.warn("Invalid storage format, ignoring");
@@ -3545,32 +3897,32 @@ async function atomicWriteFile(targetPath, content) {
   }
 }
 async function saveAccounts(storage) {
-  const path5 = getStoragePath();
-  const configDir = dirname2(path5);
+  const path4 = getStoragePath();
+  const configDir = dirname2(path4);
   await fs.mkdir(configDir, { recursive: true });
   await ensureGitignore(configDir);
-  await withFileLock(path5, async () => {
+  await withFileLock(path4, async () => {
     const existing = await loadAccountsUnsafe();
     const merged = existing ? mergeAccountStorage(existing, storage) : storage;
     const content = JSON.stringify(merged, null, 2);
-    await atomicWriteFile(path5, content);
+    await atomicWriteFile(path4, content);
   });
 }
 async function saveAccountsReplace(storage) {
-  const path5 = getStoragePath();
-  const configDir = dirname2(path5);
+  const path4 = getStoragePath();
+  const configDir = dirname2(path4);
   await fs.mkdir(configDir, { recursive: true });
   await ensureGitignore(configDir);
-  await withFileLock(path5, async () => {
+  await withFileLock(path4, async () => {
     const content = JSON.stringify(storage, null, 2);
-    await atomicWriteFile(path5, content);
+    await atomicWriteFile(path4, content);
   });
 }
 async function loadAccountsUnsafe() {
   try {
-    const path5 = getStoragePath();
-    await ensureSecurePermissions(path5);
-    const content = await fs.readFile(path5, "utf-8");
+    const path4 = getStoragePath();
+    await ensureSecurePermissions(path4);
+    const content = await fs.readFile(path4, "utf-8");
     const parsed = JSON.parse(content);
     if (parsed.version === 1) {
       return migrateV3ToV4(migrateV2ToV3(migrateV1ToV2(parsed)));
@@ -3598,9 +3950,11 @@ async function loadAccountsUnsafe() {
   }
 }
 async function clearAccounts() {
+  const path4 = getStoragePath();
   try {
-    const path5 = getStoragePath();
-    await fs.unlink(path5);
+    await withFileLock(path4, async () => {
+      await fs.unlink(path4);
+    });
   } catch (error) {
     const code = error.code;
     if (code !== "ENOENT") {
@@ -3625,7 +3979,7 @@ function getConfigDir2() {
 function getLogsDir(customLogDir) {
   const logsDir = customLogDir || join3(getConfigDir2(), "antigravity-logs");
   try {
-    mkdirSync3(logsDir, { recursive: true });
+    mkdirSync3(logsDir, { recursive: true, mode: 448 });
   } catch {
   }
   return logsDir;
@@ -3661,7 +4015,7 @@ function createLogWriter(filePath) {
     };
   }
   try {
-    const stream = createWriteStream(filePath, { flags: "a" });
+    const stream = createWriteStream(filePath, { flags: "a", mode: 384 });
     stream.on("error", () => {
     });
     return (line) => {
@@ -4844,17 +5198,17 @@ function getUserConfigPath() {
 function getProjectConfigPath(directory) {
   return join5(directory, ".opencode", "antigravity.json");
 }
-function loadConfigFile(path5) {
+function loadConfigFile(path4) {
   try {
-    if (!existsSync4(path5)) {
+    if (!existsSync4(path4)) {
       return null;
     }
-    const content = readFileSync4(path5, "utf-8");
+    const content = readFileSync4(path4, "utf-8");
     const rawConfig = JSON.parse(content);
     const result = AntigravityConfigSchema.partial().safeParse(rawConfig);
     if (!result.success) {
       log4.warn("Config validation error", {
-        path: path5,
+        path: path4,
         issues: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")
       });
       return null;
@@ -4862,9 +5216,9 @@ function loadConfigFile(path5) {
     return result.data;
   } catch (error) {
     if (error instanceof SyntaxError) {
-      log4.warn("Invalid JSON in config file", { path: path5, error: error.message });
+      log4.warn("Invalid JSON in config file", { path: path4, error: error.message });
     } else {
-      log4.warn("Failed to load config file", { path: path5, error: String(error) });
+      log4.warn("Failed to load config file", { path: path4, error: String(error) });
     }
     return null;
   }
@@ -4903,50 +5257,54 @@ function getKeepThinking() {
 }
 
 // src/plugin/image-saver.ts
-import * as fs2 from "fs";
-import * as path from "path";
-import * as os from "os";
-function getImageOutputDir() {
-  const homeDir = os.homedir();
-  const outputDir = path.join(homeDir, ".opencode", "generated-images");
-  if (!fs2.existsSync(outputDir)) {
-    fs2.mkdirSync(outputDir, { recursive: true });
+import {
+  chmodSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync5,
+  writeFileSync as writeFileSync4
+} from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join6 } from "node:path";
+function getImageOutputDir(outputDir) {
+  const resolved = outputDir ?? join6(homedir6(), ".opencode", "generated-images");
+  if (!existsSync5(resolved)) {
+    mkdirSync5(resolved, { recursive: true, mode: 448 });
   }
-  return outputDir;
+  chmodSync(resolved, 448);
+  return resolved;
 }
 function generateImageFilename(mimeType) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const random = Math.random().toString(36).substring(2, 8);
-  let ext = "png";
+  let extension = "png";
   if (mimeType.includes("jpeg") || mimeType.includes("jpg")) {
-    ext = "jpg";
+    extension = "jpg";
   } else if (mimeType.includes("gif")) {
-    ext = "gif";
+    extension = "gif";
   } else if (mimeType.includes("webp")) {
-    ext = "webp";
+    extension = "webp";
   }
-  return `image-${timestamp}-${random}.${ext}`;
+  return `image-${timestamp}-${random}.${extension}`;
 }
-function saveImageToDisk(base64Data, mimeType) {
+function saveImageToDisk(base64Data, mimeType, outputDir) {
   try {
-    const outputDir = getImageOutputDir();
-    const filename = generateImageFilename(mimeType);
-    const filePath = path.join(outputDir, filename);
-    const buffer = Buffer.from(base64Data, "base64");
-    fs2.writeFileSync(filePath, buffer);
+    const resolvedOutputDir = getImageOutputDir(outputDir);
+    const filePath = join6(resolvedOutputDir, generateImageFilename(mimeType));
+    writeFileSync4(filePath, Buffer.from(base64Data, "base64"), { mode: 384 });
+    chmodSync(filePath, 384);
     return filePath;
   } catch (error) {
     console.error("[image-saver] Failed to save image:", error);
     return "";
   }
 }
-function processImageData(inlineData) {
+function processImageData(inlineData, outputDir) {
   const mimeType = inlineData.mimeType || "image/png";
   const data = inlineData.data;
   if (!data) {
     return null;
   }
-  const filePath = saveImageToDisk(data, mimeType);
+  const filePath = saveImageToDisk(data, mimeType, outputDir);
   if (filePath) {
     return `![Generated Image](${filePath})
 
@@ -6995,14 +7353,14 @@ function applyToolPairingFixes(payload, isClaude) {
   }
   return { contentsFixed, messagesFixed };
 }
-function createSyntheticErrorResponse(errorMessage, _requestedModel = "unknown") {
-  const outputTokens = Math.max(1, Math.ceil(errorMessage.length / 4));
+function createSyntheticTextResponse(text, extraHeaders = {}) {
+  const outputTokens = Math.max(1, Math.ceil(text.length / 4));
   const event = {
     candidates: [
       {
         content: {
           role: "model",
-          parts: [{ text: errorMessage }]
+          parts: [{ text }]
         },
         finishReason: "STOP"
       }
@@ -7022,10 +7380,15 @@ function createSyntheticErrorResponse(errorMessage, _requestedModel = "unknown")
       "Cache-Control": "no-cache",
       "Connection": "keep-alive",
       "X-Antigravity-Synthetic": "true",
-      "X-Antigravity-Error-Type": "synthetic_error"
+      ...extraHeaders
     }
   });
 }
+function createSyntheticErrorResponse(errorMessage, _requestedModel = "unknown") {
+  return createSyntheticTextResponse(errorMessage, {
+    "X-Antigravity-Error-Type": "synthetic_error"
+  });
+}
 
 // src/plugin/thinking-recovery.ts
 function isThinkingPart2(part) {
@@ -7644,6 +8007,8 @@ var DUMP_USAGE_TITLE = "## Gemini Dump Usage";
 var DUMP_USAGE = "Usage: `/gemini-dump`, `/gemini-dump on`, or `/gemini-dump off`.";
 var DUMP_DIR_ENV = "OPENCODE_ANTIGRAVITY_GEMINI_DUMP_DIR";
 var DEFAULT_DUMP_DIR = join9(tmpdir2(), "opencode-antigravity-gemini-dumps");
+var DUMP_DIR_MODE = 448;
+var DUMP_FILE_MODE = 384;
 var dumpEnabled = process.env.OPENCODE_ANTIGRAVITY_GEMINI_DUMP === "1";
 var nextDumpId = 0;
 function setGeminiDumpEnabled(enabled) {
@@ -7762,9 +8127,9 @@ function bodyStructureSummary(bodyText) {
     bodyBytes: bodyText.length
   };
 }
-function writeJson(path5, value) {
-  writeFileSync6(path5, `${JSON.stringify(value, null, 2)}
-`, "utf8");
+function writeJson(path4, value) {
+  writeFileSync6(path4, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf8", mode: DUMP_FILE_MODE });
 }
 function updateMetadata(context, patch) {
   context.metadata = {
@@ -7781,7 +8146,7 @@ function dumpGeminiRequest(input2) {
   const id = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${String(nextDumpId).padStart(5, "0")}-${input2.streaming ? "stream" : "json"}`;
   const dumpDir = getGeminiDumpDirectory();
   const prefix = join9(dumpDir, id);
-  mkdirSync7(dumpDir, { recursive: true });
+  mkdirSync7(dumpDir, { recursive: true, mode: DUMP_DIR_MODE });
   const context = {
     id,
     files: {
@@ -7809,8 +8174,8 @@ function dumpGeminiRequest(input2) {
       }
     }
   };
-  writeFileSync6(context.files.request, input2.body, "utf8");
-  writeFileSync6(context.files.response, "", "utf8");
+  writeFileSync6(context.files.request, input2.body, { encoding: "utf8", mode: DUMP_FILE_MODE });
+  writeFileSync6(context.files.response, "", { encoding: "utf8", mode: DUMP_FILE_MODE });
   writeJson(context.files.metadata, context.metadata);
   return context;
 }
@@ -7843,26 +8208,69 @@ function createGeminiDumpResponseTransform(context) {
 // src/plugin/request.ts
 var log6 = createLogger2("request");
 var PLUGIN_SESSION_ID = `-${crypto2.randomUUID()}`;
+var DEFAULT_AGY_REQUEST_SESSION = createAgyRequestSessionContext("");
 var sessionDisplayedThinkingHashes = /* @__PURE__ */ new Set();
 var MIN_SIGNATURE_LENGTH = 50;
+var AGY_CLAUDE_THINKING_BUDGET = 1024;
 var ANTIGRAVITY_ENVELOPE_FIELD_ORDER = [
   "project",
   "requestId",
   "request",
   "model",
   "userAgent",
-  "requestType",
-  "enabledCreditTypes"
+  "requestType"
 ];
-function buildAntigravityRequestId(type = "agent") {
-  if (type === "checkpoint") {
-    return `checkpoint/${crypto2.randomUUID()}`;
+var OPENCODE_TITLE_PROMPT_PREFIX = "Generate a title for this conversation:";
+function getOpenCodeTitleSourceText(payload) {
+  if (!Array.isArray(payload.contents)) {
+    return void 0;
+  }
+  const texts = payload.contents.flatMap((content) => {
+    if (!content || typeof content !== "object") {
+      return [];
+    }
+    const parts = content.parts;
+    if (!Array.isArray(parts)) {
+      return [];
+    }
+    return parts.flatMap(
+      (part) => !!part && typeof part === "object" && typeof part.text === "string" ? [part.text] : []
+    );
+  });
+  const promptIndex = texts.findIndex((text) => text.startsWith(OPENCODE_TITLE_PROMPT_PREFIX));
+  return promptIndex >= 0 ? texts.slice(promptIndex + 1).find((text) => text.trim().length > 0) : void 0;
+}
+function isOpenCodeTitleGenerationRequest(payload) {
+  return getOpenCodeTitleSourceText(payload) !== void 0;
+}
+function formatLocalImageTitle(sourceText) {
+  const normalized = sourceText.trim().replace(/^(["“])(.*)(["”])$/s, "$2").replace(/\s+/g, " ");
+  const characters = Array.from(normalized);
+  if (characters.length <= 50) {
+    return normalized || "Image generation";
+  }
+  return `${characters.slice(0, 47).join("").trimEnd()}...`;
+}
+function getImageModelLocalTitle(input2, init) {
+  const url = fetchInputToUrl(input2);
+  if (!/\/models\/[^/:]*(?:image|imagen)[^/:]*:streamGenerateContent/i.test(url)) {
+    return void 0;
+  }
+  const body = init?.body;
+  const bodyText = typeof body === "string" ? body : body instanceof Uint8Array ? new TextDecoder().decode(body) : "";
+  if (!bodyText) {
+    return void 0;
+  }
+  try {
+    const sourceText = getOpenCodeTitleSourceText(JSON.parse(bodyText));
+    return sourceText === void 0 ? void 0 : formatLocalImageTitle(sourceText);
+  } catch {
+    return void 0;
   }
-  return `agent/${crypto2.randomUUID()}/${Date.now()}/${crypto2.randomUUID()}/2`;
 }
 function getAgyMaxOutputTokens(model) {
   const lower = model.toLowerCase();
-  if (lower === "gemini-3.5-flash-low" || lower === "gemini-3.5-flash-extra-low" || lower === "gemini-3-flash-agent") {
+  if (lower === "gemini-3.5-flash-low" || lower === "gemini-3.5-flash-extra-low" || lower === "gemini-3-flash-agent" || lower === "gemini-3.6-flash-low" || lower === "gemini-3.6-flash-medium" || lower === "gemini-3.6-flash-high") {
     return 65536;
   }
   if (lower === "gemini-3.1-pro-low" || lower === "gemini-pro-agent") {
@@ -7871,6 +8279,9 @@ function getAgyMaxOutputTokens(model) {
   if (lower === "claude-sonnet-4-6" || lower === "claude-opus-4-6-thinking") {
     return 64e3;
   }
+  if (lower === "gpt-oss-120b-medium") {
+    return 32768;
+  }
   return void 0;
 }
 function applyAgyGenerationDefaults(model, generationConfig, headerStyle) {
@@ -7907,7 +8318,7 @@ var JSON_SCHEMA_TYPES = /* @__PURE__ */ new Set(["boolean", "string", "number",
 function thinkingSafeReplacer(key, value) {
   if (key === "thinking" && typeof value === "object" && value !== null) {
     const rec = value;
-    if (typeof rec.type === "string" && JSON_SCHEMA_TYPES.has(rec.type)) {
+    if (typeof rec.type === "string" && JSON_SCHEMA_TYPES.has(rec.type.toLowerCase())) {
       return value;
     }
     return "";
@@ -8110,16 +8521,79 @@ function stripInjectedDebugFromRequestPayload(payload) {
       if (Array.isArray(message.content)) {
         return { ...message, content: stripInjectedDebugFromParts(message.content) };
       }
-      return message;
-    });
+      return message;
+    });
+  }
+}
+function isValidRequestPart(part) {
+  if (!part || typeof part !== "object") {
+    return false;
+  }
+  const record = part;
+  return Object.prototype.hasOwnProperty.call(record, "text") || Object.prototype.hasOwnProperty.call(record, "functionCall") || Object.prototype.hasOwnProperty.call(record, "functionResponse") || Object.prototype.hasOwnProperty.call(record, "inlineData") || Object.prototype.hasOwnProperty.call(record, "fileData") || Object.prototype.hasOwnProperty.call(record, "executableCode") || Object.prototype.hasOwnProperty.call(record, "codeExecutionResult") || Object.prototype.hasOwnProperty.call(record, "thought");
+}
+function stripCacheControlFromParts(parts) {
+  if (!Array.isArray(parts)) {
+    return;
+  }
+  for (const part of parts) {
+    if (!part || typeof part !== "object" || Array.isArray(part)) {
+      continue;
+    }
+    const record = part;
+    delete record.cache_control;
+    delete record.cacheControl;
+  }
+}
+function stripUnsupportedAntigravityFields(payload) {
+  delete payload.providerOptions;
+  delete payload.cached_content;
+  delete payload.cachedContent;
+  delete payload.cache_control;
+  delete payload.cacheControl;
+  const extraBody = payload.extra_body;
+  if (extraBody && typeof extraBody === "object" && !Array.isArray(extraBody)) {
+    const extraBodyRecord = extraBody;
+    delete extraBodyRecord.cached_content;
+    delete extraBodyRecord.cachedContent;
+    delete extraBodyRecord.cache_control;
+    delete extraBodyRecord.cacheControl;
+    if (Object.keys(extraBodyRecord).length === 0) {
+      delete payload.extra_body;
+    }
+  }
+  const stripContentParts = (items) => {
+    if (!Array.isArray(items)) {
+      return;
+    }
+    for (const item of items) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) {
+        continue;
+      }
+      const record = item;
+      stripCacheControlFromParts(record.parts);
+      stripCacheControlFromParts(record.content);
+    }
+  };
+  stripContentParts(payload.contents);
+  stripContentParts(payload.messages);
+  for (const instructionKey of ["systemInstruction", "system_instruction"]) {
+    const instruction = payload[instructionKey];
+    if (instruction && typeof instruction === "object" && !Array.isArray(instruction)) {
+      stripCacheControlFromParts(instruction.parts);
+    }
   }
 }
-function isValidRequestPart(part) {
-  if (!part || typeof part !== "object") {
-    return false;
+function configureAntigravityToolCalling(payload) {
+  if (!Array.isArray(payload.tools) || payload.tools.length === 0) {
+    delete payload.toolConfig;
+    return;
   }
-  const record = part;
-  return Object.prototype.hasOwnProperty.call(record, "text") || Object.prototype.hasOwnProperty.call(record, "functionCall") || Object.prototype.hasOwnProperty.call(record, "functionResponse") || Object.prototype.hasOwnProperty.call(record, "inlineData") || Object.prototype.hasOwnProperty.call(record, "fileData") || Object.prototype.hasOwnProperty.call(record, "executableCode") || Object.prototype.hasOwnProperty.call(record, "codeExecutionResult") || Object.prototype.hasOwnProperty.call(record, "thought");
+  const toolConfig = payload.toolConfig && typeof payload.toolConfig === "object" && !Array.isArray(payload.toolConfig) ? payload.toolConfig : {};
+  const functionCallingConfig = toolConfig.functionCallingConfig && typeof toolConfig.functionCallingConfig === "object" && !Array.isArray(toolConfig.functionCallingConfig) ? toolConfig.functionCallingConfig : {};
+  functionCallingConfig.mode = "VALIDATED";
+  toolConfig.functionCallingConfig = functionCallingConfig;
+  payload.toolConfig = toolConfig;
 }
 function sanitizeRequestPayloadForAntigravity(payload) {
   const anyPayload = payload;
@@ -8421,17 +8895,15 @@ var _lastCacheStats = null;
 function getLastCacheStats() {
   return _lastCacheStats;
 }
-function generateSyntheticProjectId() {
-  const adjectives = ["useful", "bright", "swift", "calm", "bold"];
-  const nouns = ["fuze", "wave", "spark", "flow", "core"];
-  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
-  const noun = nouns[Math.floor(Math.random() * nouns.length)];
-  const randomPart = crypto2.randomUUID().slice(0, 5).toLowerCase();
-  return `${adj}-${noun}-${randomPart}`;
-}
 var STREAM_ACTION = "streamGenerateContent";
+function fetchInputToUrl(input2) {
+  if (typeof input2 === "string") return input2;
+  if (input2 instanceof URL) return input2.href;
+  const url = input2.url;
+  return typeof url === "string" ? url : String(input2);
+}
 function isGenerativeLanguageRequest(input2) {
-  return typeof input2 === "string" && input2.includes("generativelanguage.googleapis.com");
+  return fetchInputToUrl(input2).includes("generativelanguage.googleapis.com");
 }
 function prepareAntigravityRequest(input2, init, accessToken, projectId, endpointOverride, headerStyle = "antigravity", forceThinkingRecovery = false, options) {
   const baseInit = { ...init };
@@ -8455,8 +8927,11 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
   headers.delete("x-api-key");
   headers.delete("x-goog-api-key");
   headers.delete("x-session-affinity");
+  headers.delete("x-session-id");
+  headers.delete("x-parent-session-id");
   headers.delete("x-goog-user-project");
-  const match = input2.match(/\/models\/([^:]+):(\w+)/);
+  const urlString = fetchInputToUrl(input2);
+  const match = urlString.match(/\/models\/([^:]+):(\w+)/);
   if (!match) {
     return {
       request: input2,
@@ -8495,9 +8970,6 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
           model: effectiveModel
         };
         if (headerStyle === "antigravity") {
-          if (typeof wrappedBody.requestId !== "string" || !wrappedBody.requestId) {
-            wrappedBody.requestId = buildAntigravityRequestId("agent");
-          }
           if (typeof wrappedBody.userAgent !== "string" || !wrappedBody.userAgent) {
             wrappedBody.userAgent = "antigravity";
           }
@@ -8521,7 +8993,6 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
           sessionId = signatureSessionKey;
         }
         for (const req of requestObjects) {
-          req.sessionId = signatureSessionKey;
           stripInjectedDebugFromRequestPayload(req);
           if (isClaude) {
             sanitizeCrossModelPayloadInPlace(req, { targetModel: effectiveModel });
@@ -8534,6 +9005,11 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
             }
             applyToolPairingFixes(req, true);
           }
+          if (headerStyle === "antigravity") {
+            sanitizeRequestPayloadForAntigravity(req);
+            stripUnsupportedAntigravityFields(req);
+            configureAntigravityToolCalling(req);
+          }
         }
         if (isClaude) {
           for (const req of requestObjects) {
@@ -8563,9 +9039,31 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
           const hasCachedThinking = defaultSignatureStore.has(signatureSessionKey);
           needsSignedThinkingWarmup = hasToolUse && !hasSignedThinking && !hasCachedThinking;
         }
+        const wireRequest = requestObjects.at(-1);
+        if (wireRequest) {
+          if (headerStyle === "antigravity") {
+            const metadata = buildAgyAgentRequestMetadata(
+              options?.agySession ?? DEFAULT_AGY_REQUEST_SESSION,
+              wireRequest,
+              effectiveModel,
+              options?.agyRequestTimestamp
+            );
+            wrappedBody.requestId = metadata.requestId;
+            wireRequest.sessionId = metadata.sessionId;
+            wireRequest.labels = metadata.labels;
+            orderAgyRequestPayloadInPlace(wireRequest);
+          } else {
+            wireRequest.sessionId = signatureSessionKey;
+          }
+        }
         body = safeStringify(headerStyle === "antigravity" ? orderAntigravityEnvelope(wrappedBody) : wrappedBody);
       } else {
         const requestPayload = { ...parsedBody };
+        if (headerStyle === "antigravity" && isImageGenerationModel(effectiveModel) && isOpenCodeTitleGenerationRequest(requestPayload)) {
+          effectiveModel = "gemini-3.5-flash-low";
+          tierThinkingBudget = 4e3;
+          tierThinkingLevel = void 0;
+        }
         const rawGenerationConfig = requestPayload.generationConfig;
         const extraBody = requestPayload.extra_body;
         const variantConfig = extractVariantThinkingConfig(
@@ -8574,6 +9072,7 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
         );
         const isGemini3 = effectiveModel.toLowerCase().includes("gemini-3");
         log6.debug(`[ThinkingResolution] rawModel=${rawModel} resolvedModel=${effectiveModel} resolvedTier=${tierThinkingLevel ?? "none"} variantLevel=${variantConfig?.thinkingLevel ?? "none"} variantBudget=${variantConfig?.thinkingBudget ?? "none"} providerOptions.google=${JSON.stringify(requestPayload.providerOptions?.google ?? null)} generationConfig.thinkingConfig=${JSON.stringify(rawGenerationConfig?.thinkingConfig ?? null)}`);
+        delete requestPayload.providerOptions;
         if (variantConfig?.thinkingLevel && isGemini3) {
           const variantModelBase = rawModel.replace(/-preview-customtools$/i, "").replace(/-preview$/i, "").replace(/-(minimal|low|medium|high)$/i, "");
           const variantResolved = resolveModelForHeaderStyle(
@@ -8593,20 +9092,6 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
             tierThinkingLevel = void 0;
           }
         }
-        if (isClaude) {
-          if (!requestPayload.toolConfig) {
-            requestPayload.toolConfig = {};
-          }
-          if (typeof requestPayload.toolConfig === "object" && requestPayload.toolConfig !== null) {
-            const toolConfig = requestPayload.toolConfig;
-            if (!toolConfig.functionCallingConfig) {
-              toolConfig.functionCallingConfig = {};
-            }
-            if (typeof toolConfig.functionCallingConfig === "object" && toolConfig.functionCallingConfig !== null) {
-              toolConfig.functionCallingConfig.mode = "VALIDATED";
-            }
-          }
-        }
         const isImageModel = isImageGenerationModel(effectiveModel);
         const userThinkingConfig = isImageModel ? void 0 : extractThinkingConfig(requestPayload, rawGenerationConfig, extraBody);
         const hasAssistantHistory = Array.isArray(requestPayload.contents) && requestPayload.contents.some((c) => c?.role === "model" || c?.role === "assistant");
@@ -8703,17 +9188,19 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
           requestPayload.systemInstruction = requestPayload.system_instruction;
           delete requestPayload.system_instruction;
         }
-        const cachedContentFromExtra = typeof requestPayload.extra_body === "object" && requestPayload.extra_body ? requestPayload.extra_body.cached_content ?? requestPayload.extra_body.cachedContent : void 0;
-        const cachedContent = requestPayload.cached_content ?? requestPayload.cachedContent ?? cachedContentFromExtra;
-        if (cachedContent) {
-          requestPayload.cachedContent = cachedContent;
-        }
-        delete requestPayload.cached_content;
-        if (requestPayload.extra_body && typeof requestPayload.extra_body === "object") {
-          delete requestPayload.extra_body.cached_content;
-          delete requestPayload.extra_body.cachedContent;
-          if (Object.keys(requestPayload.extra_body).length === 0) {
-            delete requestPayload.extra_body;
+        if (headerStyle !== "antigravity") {
+          const cachedContentFromExtra = typeof requestPayload.extra_body === "object" && requestPayload.extra_body ? requestPayload.extra_body.cached_content ?? requestPayload.extra_body.cachedContent : void 0;
+          const cachedContent = requestPayload.cached_content ?? requestPayload.cachedContent ?? cachedContentFromExtra;
+          if (cachedContent) {
+            requestPayload.cachedContent = cachedContent;
+          }
+          delete requestPayload.cached_content;
+          if (requestPayload.extra_body && typeof requestPayload.extra_body === "object") {
+            delete requestPayload.extra_body.cached_content;
+            delete requestPayload.extra_body.cachedContent;
+            if (Object.keys(requestPayload.extra_body).length === 0) {
+              delete requestPayload.extra_body;
+            }
           }
         }
         const hasTools = Array.isArray(requestPayload.tools) && requestPayload.tools.length > 0;
@@ -8909,11 +9396,27 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
         }
         stripInjectedDebugFromRequestPayload(requestPayload);
         sanitizeRequestPayloadForAntigravity(requestPayload);
-        const effectiveProjectId = projectId?.trim() || (headerStyle === "antigravity" ? generateSyntheticProjectId() : "");
+        if (headerStyle === "antigravity") {
+          stripUnsupportedAntigravityFields(requestPayload);
+          configureAntigravityToolCalling(requestPayload);
+        }
+        const effectiveProjectId = projectId?.trim() || (headerStyle === "antigravity" ? ANTIGRAVITY_DEFAULT_PROJECT_ID : "");
         resolvedProjectId = effectiveProjectId;
+        sessionId = signatureSessionKey;
+        const agyMetadata = headerStyle === "antigravity" ? buildAgyAgentRequestMetadata(
+          options?.agySession ?? DEFAULT_AGY_REQUEST_SESSION,
+          requestPayload,
+          effectiveModel,
+          options?.agyRequestTimestamp
+        ) : null;
+        requestPayload.sessionId = agyMetadata?.sessionId ?? signatureSessionKey;
+        if (agyMetadata) {
+          requestPayload.labels = agyMetadata.labels;
+          orderAgyRequestPayloadInPlace(requestPayload);
+        }
         const wrappedBody = headerStyle === "antigravity" ? {
           project: effectiveProjectId,
-          requestId: buildAntigravityRequestId("agent"),
+          requestId: agyMetadata.requestId,
           request: requestPayload,
           model: effectiveModel,
           userAgent: "antigravity",
@@ -8923,10 +9426,6 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
           model: effectiveModel,
           request: requestPayload
         };
-        if (wrappedBody.request && typeof wrappedBody.request === "object") {
-          sessionId = signatureSessionKey;
-          wrappedBody.request.sessionId = signatureSessionKey;
-        }
         body = safeStringify(headerStyle === "antigravity" ? orderAntigravityEnvelope(wrappedBody) : wrappedBody);
       }
     } catch {
@@ -8988,17 +9487,20 @@ function buildThinkingWarmupBody(bodyText, isClaudeThinking) {
     return null;
   }
   const warmupPrompt = "Warmup request for thinking signature.";
+  const wireModel = typeof parsed.model === "string" ? parsed.model : "claude-sonnet-4-6";
+  const requestObjects = [];
   const updateRequest = (req) => {
     req.contents = [{ role: "user", parts: [{ text: warmupPrompt }] }];
     delete req.tools;
     delete req.toolConfig;
     const generationConfig = req.generationConfig ?? {};
     generationConfig.thinkingConfig = {
-      include_thoughts: true,
-      thinking_budget: DEFAULT_THINKING_BUDGET
+      includeThoughts: true,
+      thinkingBudget: AGY_CLAUDE_THINKING_BUDGET
     };
-    generationConfig.maxOutputTokens = computeClaudeMaxOutputTokens(DEFAULT_THINKING_BUDGET);
+    generationConfig.maxOutputTokens = getAgyMaxOutputTokens(wireModel) ?? computeClaudeMaxOutputTokens(AGY_CLAUDE_THINKING_BUDGET);
     req.generationConfig = generationConfig;
+    requestObjects.push(req);
   };
   if (parsed.request && typeof parsed.request === "object") {
     updateRequest(parsed.request);
@@ -9009,6 +9511,20 @@ function buildThinkingWarmupBody(bodyText, isClaudeThinking) {
   } else {
     updateRequest(parsed);
   }
+  const wireRequest = requestObjects.at(-1);
+  if (wireRequest) {
+    const numericSessionId = typeof wireRequest.sessionId === "string" ? wireRequest.sessionId : DEFAULT_AGY_REQUEST_SESSION.numericSessionId;
+    const warmupSession = {
+      conversationId: crypto2.randomUUID(),
+      trajectoryId: crypto2.randomUUID(),
+      numericSessionId
+    };
+    const metadata = buildAgyAgentRequestMetadata(warmupSession, wireRequest, wireModel);
+    parsed.requestId = metadata.requestId;
+    wireRequest.sessionId = metadata.sessionId;
+    wireRequest.labels = metadata.labels;
+    orderAgyRequestPayloadInPlace(wireRequest);
+  }
   return safeStringify(parsed);
 }
 async function transformAntigravityResponse(response, streaming, debugContext, requestedModel, projectId, endpoint, effectiveModel, sessionId, toolDebugMissing, toolDebugSummary, toolDebugPayload, debugLines, dumpContext) {
@@ -9381,12 +9897,12 @@ async function startOAuthListener({ timeoutMs = 5 * 60 * 1e3 } = {}) {
   let resolveCallback;
   let rejectCallback;
   let timeoutHandle;
-  const callbackPromise = new Promise((resolve, reject) => {
+  const callbackPromise = new Promise((resolve2, reject) => {
     resolveCallback = (url) => {
       if (settled) return;
       settled = true;
       if (timeoutHandle) clearTimeout(timeoutHandle);
-      resolve(url);
+      resolve2(url);
     };
     rejectCallback = (error) => {
       if (settled) return;
@@ -9544,7 +10060,7 @@ async function startOAuthListener({ timeoutMs = 5 * 60 * 1e3 } = {}) {
     });
   });
   const bindAddress = getBindAddress();
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const handleError = (error) => {
       server.off("error", handleError);
       if (error.code === "EADDRINUSE") {
@@ -9558,7 +10074,7 @@ async function startOAuthListener({ timeoutMs = 5 * 60 * 1e3 } = {}) {
     server.once("error", handleError);
     server.listen(port, bindAddress, () => {
       server.off("error", handleError);
-      resolve();
+      resolve2();
     });
   });
   server.on("error", (error) => {
@@ -9566,7 +10082,7 @@ async function startOAuthListener({ timeoutMs = 5 * 60 * 1e3 } = {}) {
   });
   return {
     waitForCallback: () => callbackPromise,
-    close: () => new Promise((resolve, reject) => {
+    close: () => new Promise((resolve2, reject) => {
       server.close((error) => {
         if (error && error.code !== "ERR_SERVER_NOT_RUNNING") {
           reject(error);
@@ -9575,7 +10091,7 @@ async function startOAuthListener({ timeoutMs = 5 * 60 * 1e3 } = {}) {
         if (!settled) {
           rejectCallback(new Error("OAuth listener closed before callback"));
         }
-        resolve();
+        resolve2();
       });
     })
   };
@@ -9969,6 +10485,8 @@ function computeSoftQuotaCacheTtlMs(ttlConfig, refreshIntervalMinutes) {
   }
   return ttlConfig * 60 * 1e3;
 }
+var ACCOUNT_SESSION_STATE_TTL_MS = 24 * 60 * 60 * 1e3;
+var MAX_ACCOUNT_SESSION_STATES = 256;
 var AccountManager = class _AccountManager {
   accounts = [];
   cursorByFamily = { claude: 0, gemini: 0 };
@@ -9988,6 +10506,7 @@ var AccountManager = class _AccountManager {
   sessionStartTime = Date.now();
   sessionRequestCounts = /* @__PURE__ */ new Map();
   sessionUsedAccounts = /* @__PURE__ */ new Set();
+  requestSessionStates = /* @__PURE__ */ new Map();
   static async loadFromDisk(authFallback) {
     const stored = await loadAccounts();
     return new _AccountManager(authFallback, stored);
@@ -10032,7 +10551,11 @@ var AccountManager = class _AccountManager {
           verificationRequired: acc.verificationRequired,
           verificationRequiredAt: acc.verificationRequiredAt,
           verificationRequiredReason: acc.verificationRequiredReason,
-          verificationUrl: acc.verificationUrl
+          verificationUrl: acc.verificationUrl,
+          accountIneligible: acc.accountIneligible,
+          accountIneligibleAt: acc.accountIneligibleAt,
+          accountIneligibleReason: acc.accountIneligibleReason,
+          eligibilityStateUpdatedAt: acc.eligibilityStateUpdatedAt
         };
       }).filter((a) => a !== null);
       let fingerprintVersionChanged = false;
@@ -10114,11 +10637,104 @@ var AccountManager = class _AccountManager {
   getEnabledAccounts() {
     return this.accounts.filter((account) => account.enabled !== false);
   }
+  getEffectiveSoftQuotaThreshold(thresholdPercent) {
+    return this.getEnabledAccounts().length > 1 ? thresholdPercent : 100;
+  }
   getAccountsSnapshot() {
     return this.accounts.map((a) => ({ ...a, parts: { ...a.parts }, rateLimitResetTimes: { ...a.rateLimitResetTimes } }));
   }
-  getCurrentAccountForFamily(family) {
-    const currentIndex = this.currentAccountIndexByFamily[family];
+  getRequestSessionState(identity) {
+    const now = nowMs();
+    this.pruneRequestSessionStates(now, identity.id);
+    const existing = this.requestSessionStates.get(identity.id);
+    if (existing) {
+      existing.lastAccessedAt = now;
+      if (identity.parentId) {
+        existing.parentId = identity.parentId;
+      }
+      return existing;
+    }
+    const state = {
+      parentId: identity.parentId ?? null,
+      currentAccountIndexByFamily: { claude: -1, gemini: -1 },
+      cursorByFamily: { ...this.cursorByFamily },
+      offsetAppliedByFamily: { claude: false, gemini: false },
+      usedAccounts: /* @__PURE__ */ new Set(),
+      lastAccessedAt: now
+    };
+    this.requestSessionStates.set(identity.id, state);
+    return state;
+  }
+  pruneRequestSessionStates(now, preservedId) {
+    const expiry = now - ACCOUNT_SESSION_STATE_TTL_MS;
+    for (const [id, state] of this.requestSessionStates) {
+      if (id !== preservedId && state.lastAccessedAt < expiry) {
+        this.requestSessionStates.delete(id);
+      }
+    }
+    if (this.requestSessionStates.size < MAX_ACCOUNT_SESSION_STATES || this.requestSessionStates.has(preservedId)) {
+      return;
+    }
+    let oldestId = null;
+    let oldestAccess = Number.POSITIVE_INFINITY;
+    for (const [id, state] of this.requestSessionStates) {
+      if (id !== preservedId && state.lastAccessedAt < oldestAccess) {
+        oldestId = id;
+        oldestAccess = state.lastAccessedAt;
+      }
+    }
+    if (oldestId) {
+      this.requestSessionStates.delete(oldestId);
+    }
+  }
+  getActiveIndex(family, identity) {
+    return identity ? this.getRequestSessionState(identity).currentAccountIndexByFamily[family] : this.currentAccountIndexByFamily[family];
+  }
+  setActiveIndex(family, index, identity) {
+    if (!identity) {
+      this.currentAccountIndexByFamily[family] = index;
+      return;
+    }
+    const state = this.getRequestSessionState(identity);
+    state.currentAccountIndexByFamily[family] = index;
+    if (!state.parentId) {
+      this.currentAccountIndexByFamily[family] = index;
+    }
+  }
+  getCursor(family, identity) {
+    return identity ? this.getRequestSessionState(identity).cursorByFamily[family] : this.cursorByFamily[family];
+  }
+  advanceCursor(family, identity) {
+    const nextGlobalCursor = this.cursorByFamily[family] + 1;
+    this.cursorByFamily[family] = nextGlobalCursor;
+    if (identity) {
+      this.getRequestSessionState(identity).cursorByFamily[family] += 1;
+    }
+  }
+  getUsedAccounts(identity) {
+    return identity ? this.getRequestSessionState(identity).usedAccounts : this.sessionUsedAccounts;
+  }
+  preferAccountOutsideParent(accounts, family, identity) {
+    if (!identity) {
+      return accounts;
+    }
+    const parentId = this.getRequestSessionState(identity).parentId;
+    if (!parentId) {
+      return accounts;
+    }
+    const parentState = this.requestSessionStates.get(parentId);
+    const parentIndex = parentState?.currentAccountIndexByFamily[family] ?? -1;
+    if (parentIndex < 0) {
+      return accounts;
+    }
+    const isolated = accounts.filter((account) => account.index !== parentIndex);
+    return isolated.length > 0 ? isolated : accounts;
+  }
+  deleteSessionState(sessionId) {
+    this.requestSessionStates.delete(sessionId);
+  }
+  getCurrentAccountForFamily(family, identity) {
+    const currentIndex = this.getActiveIndex(family, identity);
     if (currentIndex >= 0 && currentIndex < this.accounts.length) {
       const account = this.accounts[currentIndex] ?? null;
       if (account && account.enabled !== false) {
@@ -10127,9 +10743,9 @@ var AccountManager = class _AccountManager {
     }
     return null;
   }
-  markSwitched(account, reason, family) {
+  markSwitched(account, reason, family, identity) {
     account.lastSwitchReason = reason;
-    this.currentAccountIndexByFamily[family] = account.index;
+    this.setActiveIndex(family, account.index, identity);
   }
   /**
    * Check if we should show an account switch toast.
@@ -10146,82 +10762,111 @@ var AccountManager = class _AccountManager {
     this.lastToastAccountIndex = accountIndex;
     this.lastToastTime = nowMs();
   }
-  getCurrentOrNextForFamily(family, model, strategy = "sticky", headerStyle = "antigravity", pidOffsetEnabled = false, softQuotaThresholdPercent = 100, softQuotaCacheTtlMs = 10 * 60 * 1e3) {
+  getCurrentOrNextForFamily(family, model, strategy = "sticky", headerStyle = "antigravity", pidOffsetEnabled = false, softQuotaThresholdPercent = 100, softQuotaCacheTtlMs = 10 * 60 * 1e3, identity) {
     const quotaKey = getQuotaKey(family, headerStyle, model);
+    const effectiveSoftQuotaThreshold = this.getEffectiveSoftQuotaThreshold(softQuotaThresholdPercent);
+    if (identity) {
+      const pinned = this.getCurrentAccountForFamily(family, identity);
+      if (pinned) {
+        clearExpiredRateLimits(pinned);
+        const unavailable = isRateLimitedForHeaderStyle(pinned, family, headerStyle, model) || isOverSoftQuotaThreshold(pinned, family, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, model) || this.isAccountCoolingDown(pinned);
+        if (!unavailable) {
+          this.markTouchedForQuota(pinned, quotaKey);
+          return pinned;
+        }
+      }
+    }
     if (strategy === "round-robin") {
-      const next2 = this.getNextForFamily(family, model, headerStyle, softQuotaThresholdPercent, softQuotaCacheTtlMs);
+      const next2 = this.getNextForFamily(family, model, headerStyle, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, identity);
       if (next2) {
         this.markTouchedForQuota(next2, quotaKey);
-        this.currentAccountIndexByFamily[family] = next2.index;
+        this.setActiveIndex(family, next2.index, identity);
       }
       return next2;
     }
     if (strategy === "hybrid") {
       const healthTracker = getHealthTracker();
       const tokenTracker = getTokenTracker();
-      const accountsWithMetrics = this.accounts.filter((acc) => acc.enabled !== false).map((acc) => {
+      const eligibleAccounts = this.preferAccountOutsideParent(
+        this.accounts.filter((acc) => acc.enabled !== false),
+        family,
+        identity
+      );
+      const accountsWithMetrics = eligibleAccounts.map((acc) => {
         clearExpiredRateLimits(acc);
         return {
           index: acc.index,
           lastUsed: acc.lastUsed,
           healthScore: healthTracker.getScore(acc.index),
-          isRateLimited: isRateLimitedForFamily(acc, family, model) || isOverSoftQuotaThreshold(acc, family, softQuotaThresholdPercent, softQuotaCacheTtlMs, model),
+          isRateLimited: isRateLimitedForFamily(acc, family, model) || isOverSoftQuotaThreshold(acc, family, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, model),
           isCoolingDown: this.isAccountCoolingDown(acc)
         };
       });
-      const currentIndex = this.currentAccountIndexByFamily[family] ?? null;
+      const currentIndex = this.getActiveIndex(family, identity);
       const selectedIndex = selectHybridAccount(accountsWithMetrics, tokenTracker, currentIndex);
       if (selectedIndex !== null) {
         const selected = this.accounts[selectedIndex];
         if (selected) {
           selected.lastUsed = nowMs();
           this.markTouchedForQuota(selected, quotaKey);
-          this.currentAccountIndexByFamily[family] = selected.index;
+          this.setActiveIndex(family, selected.index, identity);
           return selected;
         }
       }
     }
-    if (pidOffsetEnabled && !this.sessionOffsetApplied[family] && this.accounts.length > 1) {
+    const offsetApplied = identity ? this.getRequestSessionState(identity).offsetAppliedByFamily : this.sessionOffsetApplied;
+    if (pidOffsetEnabled && !offsetApplied[family] && this.accounts.length > 1) {
       const pidOffset = process.pid % this.accounts.length;
-      const baseIndex = this.currentAccountIndexByFamily[family] ?? 0;
+      const activeIndex = this.getActiveIndex(family, identity);
+      const baseIndex = activeIndex >= 0 ? activeIndex : this.getCursor(family, identity);
       const newIndex = (baseIndex + pidOffset) % this.accounts.length;
       debugLogToFile(`[Account] Applying PID offset: pid=${process.pid} offset=${pidOffset} family=${family} index=${baseIndex}->${newIndex}`);
-      this.currentAccountIndexByFamily[family] = newIndex;
-      this.sessionOffsetApplied[family] = true;
+      this.setActiveIndex(family, newIndex, identity);
+      offsetApplied[family] = true;
     }
-    const current = this.getCurrentAccountForFamily(family);
+    const current = this.getCurrentAccountForFamily(family, identity);
     if (current) {
       clearExpiredRateLimits(current);
       const isLimitedForRequestedStyle = isRateLimitedForHeaderStyle(current, family, headerStyle, model);
-      const isOverThreshold = isOverSoftQuotaThreshold(current, family, softQuotaThresholdPercent, softQuotaCacheTtlMs, model);
+      const isOverThreshold = isOverSoftQuotaThreshold(current, family, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, model);
       if (!isLimitedForRequestedStyle && !isOverThreshold && !this.isAccountCoolingDown(current)) {
         this.markTouchedForQuota(current, quotaKey);
         return current;
       }
     }
-    const next = this.getNextForFamily(family, model, headerStyle, softQuotaThresholdPercent, softQuotaCacheTtlMs);
+    const next = this.getNextForFamily(
+      family,
+      model,
+      headerStyle,
+      effectiveSoftQuotaThreshold,
+      softQuotaCacheTtlMs,
+      identity
+    );
     if (next) {
       this.markTouchedForQuota(next, quotaKey);
-      this.currentAccountIndexByFamily[family] = next.index;
+      this.setActiveIndex(family, next.index, identity);
     }
     return next;
   }
-  getNextForFamily(family, model, headerStyle = "antigravity", softQuotaThresholdPercent = 100, softQuotaCacheTtlMs = 10 * 60 * 1e3) {
-    const available = this.accounts.filter((a) => {
-      clearExpiredRateLimits(a);
-      return a.enabled !== false && !isRateLimitedForHeaderStyle(a, family, headerStyle, model) && !isOverSoftQuotaThreshold(a, family, softQuotaThresholdPercent, softQuotaCacheTtlMs, model) && !this.isAccountCoolingDown(a);
+  getNextForFamily(family, model, headerStyle = "antigravity", softQuotaThresholdPercent = 100, softQuotaCacheTtlMs = 10 * 60 * 1e3, identity) {
+    const effectiveSoftQuotaThreshold = this.getEffectiveSoftQuotaThreshold(softQuotaThresholdPercent);
+    const allAvailable = this.accounts.filter((account2) => {
+      clearExpiredRateLimits(account2);
+      return account2.enabled !== false && !isRateLimitedForHeaderStyle(account2, family, headerStyle, model) && !isOverSoftQuotaThreshold(account2, family, effectiveSoftQuotaThreshold, softQuotaCacheTtlMs, model) && !this.isAccountCoolingDown(account2);
     });
+    const available = this.preferAccountOutsideParent(allAvailable, family, identity);
     if (available.length === 0) {
       return null;
     }
-    const sessionUsed = available.filter((a) => this.sessionUsedAccounts.has(a.index));
+    const usedAccounts = this.getUsedAccounts(identity);
+    const sessionUsed = available.filter((account2) => usedAccounts.has(account2.index));
     const candidates = sessionUsed.length > 0 ? sessionUsed : available;
-    const cursor = this.cursorByFamily[family];
+    const cursor = this.getCursor(family, identity);
     const account = candidates[cursor % candidates.length];
     if (!account) {
       return null;
     }
-    this.cursorByFamily[family] = cursor + 1;
+    this.advanceCursor(family, identity);
     return account;
   }
   markRateLimited(account, retryAfterMs, family, headerStyle = "antigravity", model) {
@@ -10239,15 +10884,15 @@ var AccountManager = class _AccountManager {
       account.lastUsed = nowMs();
     }
   }
-  recordSessionUsage(accountIndex) {
-    this.sessionUsedAccounts.add(accountIndex);
+  recordSessionUsage(accountIndex, identity) {
+    this.getUsedAccounts(identity).add(accountIndex);
   }
-  wasUsedInSession(accountIndex) {
-    return this.sessionUsedAccounts.has(accountIndex);
+  wasUsedInSession(accountIndex, identity) {
+    return this.getUsedAccounts(identity).has(accountIndex);
   }
-  shouldProactivelyRotate(family, model, thresholdPercent, cacheTtlMs) {
+  shouldProactivelyRotate(family, model, thresholdPercent, cacheTtlMs, identity) {
     if (thresholdPercent <= 0) return false;
-    const current = this.getCurrentAccountForFamily(family);
+    const current = this.getCurrentAccountForFamily(family, identity);
     if (!current || !current.cachedQuota || current.cachedQuotaUpdatedAt == null) return false;
     const age = nowMs() - current.cachedQuotaUpdatedAt;
     if (age > cacheTtlMs) return false;
@@ -10257,9 +10902,9 @@ var AccountManager = class _AccountManager {
     const remainingPercent = Math.max(0, Math.min(100, groupData.remainingFraction * 100));
     return remainingPercent < thresholdPercent;
   }
-  proactivelyRotateForFamily(family, model, headerStyle, softQuotaThresholdPercent, softQuotaCacheTtlMs) {
-    const currentIndex = this.currentAccountIndexByFamily[family];
-    const candidates = this.accounts.filter((acc) => {
+  proactivelyRotateForFamily(family, model, headerStyle, softQuotaThresholdPercent, softQuotaCacheTtlMs, identity) {
+    const currentIndex = this.getActiveIndex(family, identity);
+    const candidates = this.preferAccountOutsideParent(this.accounts.filter((acc) => {
       if (acc.enabled === false) return false;
       if (acc.index === currentIndex) return false;
       clearExpiredRateLimits(acc);
@@ -10267,9 +10912,10 @@ var AccountManager = class _AccountManager {
       if (isOverSoftQuotaThreshold(acc, family, softQuotaThresholdPercent, softQuotaCacheTtlMs, model)) return false;
       if (this.isAccountCoolingDown(acc)) return false;
       return true;
-    });
+    }), family, identity);
     if (candidates.length === 0) return null;
-    const warmCandidates = candidates.filter((a) => this.sessionUsedAccounts.has(a.index));
+    const usedAccounts = this.getUsedAccounts(identity);
+    const warmCandidates = candidates.filter((account) => usedAccounts.has(account.index));
     const pool = warmCandidates.length > 0 ? warmCandidates : candidates;
     const quotaGroup = resolveQuotaGroup(family, model);
     pool.sort((a, b) => {
@@ -10281,7 +10927,7 @@ var AccountManager = class _AccountManager {
     if (!selected) return null;
     const quotaKey = getQuotaKey(family, headerStyle, model);
     this.markTouchedForQuota(selected, quotaKey);
-    this.currentAccountIndexByFamily[family] = selected.index;
+    this.setActiveIndex(family, selected.index, identity);
     return selected;
   }
   markRateLimitedWithReason(account, family, headerStyle, model, reason, retryAfterMs, failureTtlMs = 36e5) {
@@ -10407,6 +11053,9 @@ var AccountManager = class _AccountManager {
     if (!account) {
       return false;
     }
+    if (enabled && account.accountIneligible) {
+      return false;
+    }
     account.enabled = enabled;
     if (!enabled) {
       for (const family of Object.keys(this.currentAccountIndexByFamily)) {
@@ -10424,9 +11073,16 @@ var AccountManager = class _AccountManager {
     if (!account) {
       return false;
     }
+    const timestamp = nowMs();
     account.verificationRequired = true;
-    account.verificationRequiredAt = nowMs();
+    account.verificationRequiredAt = timestamp;
     account.verificationRequiredReason = reason?.trim() || void 0;
+    if (account.accountIneligible === true || account.accountIneligibleAt !== void 0 || account.accountIneligibleReason !== void 0) {
+      account.accountIneligible = false;
+      account.accountIneligibleAt = void 0;
+      account.accountIneligibleReason = void 0;
+      account.eligibilityStateUpdatedAt = timestamp;
+    }
     const normalizedVerifyUrl = verifyUrl?.trim();
     if (normalizedVerifyUrl) {
       account.verificationUrl = normalizedVerifyUrl;
@@ -10438,20 +11094,48 @@ var AccountManager = class _AccountManager {
     }
     return true;
   }
-  clearAccountVerificationRequired(accountIndex, enableAccount = false) {
+  markAccountIneligible(accountIndex, reason) {
+    const account = this.accounts[accountIndex];
+    if (!account) {
+      return false;
+    }
+    const timestamp = nowMs();
+    account.accountIneligible = true;
+    account.accountIneligibleAt = timestamp;
+    account.accountIneligibleReason = reason?.trim() || "Google marked this account as ineligible.";
+    account.eligibilityStateUpdatedAt = timestamp;
+    account.verificationRequired = false;
+    account.verificationRequiredAt = void 0;
+    account.verificationRequiredReason = void 0;
+    account.verificationUrl = void 0;
+    if (account.enabled !== false) {
+      this.setAccountEnabled(accountIndex, false);
+    } else {
+      this.requestSaveToDisk();
+    }
+    return true;
+  }
+  clearAccountAccessBlocks(accountIndex, enableAccount = false) {
     const account = this.accounts[accountIndex];
     if (!account) {
       return false;
     }
     const wasVerificationRequired = account.verificationRequired === true;
-    const hadMetadata = account.verificationRequiredAt !== void 0 || account.verificationRequiredReason !== void 0 || account.verificationUrl !== void 0;
+    const wasIneligible = account.accountIneligible === true;
+    const hadMetadata = wasVerificationRequired || wasIneligible || account.verificationRequiredAt !== void 0 || account.verificationRequiredReason !== void 0 || account.verificationUrl !== void 0 || account.accountIneligibleAt !== void 0 || account.accountIneligibleReason !== void 0 || account.eligibilityStateUpdatedAt !== void 0;
     account.verificationRequired = false;
     account.verificationRequiredAt = void 0;
     account.verificationRequiredReason = void 0;
     account.verificationUrl = void 0;
-    if (enableAccount && wasVerificationRequired && account.enabled === false) {
+    account.accountIneligible = false;
+    account.accountIneligibleAt = void 0;
+    account.accountIneligibleReason = void 0;
+    if (wasIneligible || account.eligibilityStateUpdatedAt !== void 0) {
+      account.eligibilityStateUpdatedAt = nowMs();
+    }
+    if (enableAccount && (wasVerificationRequired || wasIneligible) && account.enabled === false) {
       this.setAccountEnabled(accountIndex, true);
-    } else if (wasVerificationRequired || hadMetadata) {
+    } else if (hadMetadata) {
       this.requestSaveToDisk();
     }
     return true;
@@ -10479,6 +11163,7 @@ var AccountManager = class _AccountManager {
       this.cursorByFamily = { claude: 0, gemini: 0 };
       this.currentAccountIndexByFamily.claude = -1;
       this.currentAccountIndexByFamily.gemini = -1;
+      this.requestSessionStates.clear();
       return true;
     }
     for (const family of ["claude", "gemini"]) {
@@ -10492,6 +11177,23 @@ var AccountManager = class _AccountManager {
       if (this.currentAccountIndexByFamily[family] >= this.accounts.length) {
         this.currentAccountIndexByFamily[family] = -1;
       }
+      for (const state of this.requestSessionStates.values()) {
+        const currentIndex = state.currentAccountIndexByFamily[family];
+        if (currentIndex === idx) {
+          state.currentAccountIndexByFamily[family] = -1;
+        } else if (currentIndex > idx) {
+          state.currentAccountIndexByFamily[family] -= 1;
+        }
+        if (state.cursorByFamily[family] > idx) {
+          state.cursorByFamily[family] -= 1;
+        }
+        state.cursorByFamily[family] %= this.accounts.length;
+      }
+    }
+    for (const state of this.requestSessionStates.values()) {
+      state.usedAccounts = new Set(
+        [...state.usedAccounts].filter((accountIndex) => accountIndex !== idx).map((accountIndex) => accountIndex > idx ? accountIndex - 1 : accountIndex)
+      );
     }
     return true;
   }
@@ -10547,10 +11249,10 @@ var AccountManager = class _AccountManager {
   getAccounts() {
     return [...this.accounts];
   }
-  async saveToDisk() {
+  buildStorageSnapshot() {
     const claudeIndex = Math.max(0, this.currentAccountIndexByFamily.claude);
     const geminiIndex = Math.max(0, this.currentAccountIndexByFamily.gemini);
-    const storage = {
+    return {
       version: 4,
       accounts: this.accounts.map((a) => ({
         email: a.email,
@@ -10569,7 +11271,11 @@ var AccountManager = class _AccountManager {
         verificationRequired: a.verificationRequired,
         verificationRequiredAt: a.verificationRequiredAt,
         verificationRequiredReason: a.verificationRequiredReason,
-        verificationUrl: a.verificationUrl
+        verificationUrl: a.verificationUrl,
+        accountIneligible: a.accountIneligible,
+        accountIneligibleAt: a.accountIneligibleAt,
+        accountIneligibleReason: a.accountIneligibleReason,
+        eligibilityStateUpdatedAt: a.eligibilityStateUpdatedAt
       })),
       activeIndex: claudeIndex,
       activeIndexByFamily: {
@@ -10577,7 +11283,17 @@ var AccountManager = class _AccountManager {
         gemini: geminiIndex
       }
     };
-    await saveAccounts(storage);
+  }
+  async saveToDisk() {
+    await saveAccounts(this.buildStorageSnapshot());
+  }
+  /**
+   * Persist via full-file replace (no merge). Required after destructive
+   * operations (account removal) so a deleted account is not resurrected by
+   * mergeAccountStorage re-reading it from disk.
+   */
+  async saveToDiskReplace() {
+    await saveAccountsReplace(this.buildStorageSnapshot());
   }
   requestSaveToDisk() {
     if (this.savePending) {
@@ -10592,8 +11308,8 @@ var AccountManager = class _AccountManager {
     if (!this.savePending) {
       return;
     }
-    return new Promise((resolve, reject) => {
-      this.savePromiseResolvers.push({ resolve, reject });
+    return new Promise((resolve2, reject) => {
+      this.savePromiseResolvers.push({ resolve: resolve2, reject });
     });
   }
   async executeSave() {
@@ -10603,14 +11319,14 @@ var AccountManager = class _AccountManager {
     this.savePromiseResolvers = [];
     try {
       await this.saveToDisk();
-      for (const { resolve } of resolvers) {
-        resolve();
+      for (const { resolve: resolve2 } of resolvers) {
+        resolve2();
       }
     } catch (error) {
       if (isStorageLockContention(error)) {
         debugLogToFile(`[Account] Skipped account-state persist because another plugin instance holds the storage lock: ${String(error)}`);
-        for (const { resolve } of resolvers) {
-          resolve();
+        for (const { resolve: resolve2 } of resolvers) {
+          resolve2();
         }
         return;
       }
@@ -10788,7 +11504,13 @@ var AccountManager = class _AccountManager {
     };
   }
   isAccountOverSoftQuota(account, family, thresholdPercent, cacheTtlMs, model) {
-    return isOverSoftQuotaThreshold(account, family, thresholdPercent, cacheTtlMs, model);
+    return isOverSoftQuotaThreshold(
+      account,
+      family,
+      this.getEffectiveSoftQuotaThreshold(thresholdPercent),
+      cacheTtlMs,
+      model
+    );
   }
   getAccountsForQuotaCheck() {
     return this.accounts.map((a) => ({
@@ -10814,7 +11536,7 @@ var AccountManager = class _AccountManager {
   areAllAccountsOverSoftQuota(family, thresholdPercent, cacheTtlMs, model) {
     if (thresholdPercent >= 100) return false;
     const enabled = this.accounts.filter((a) => a.enabled !== false);
-    if (enabled.length === 0) return false;
+    if (enabled.length <= 1) return false;
     return enabled.every((a) => isOverSoftQuotaThreshold(a, family, thresholdPercent, cacheTtlMs, model));
   }
   /**
@@ -10827,6 +11549,7 @@ var AccountManager = class _AccountManager {
     if (thresholdPercent >= 100) return 0;
     const enabled = this.accounts.filter((a) => a.enabled !== false);
     if (enabled.length === 0) return null;
+    if (enabled.length === 1) return 0;
     const available = enabled.filter((a) => !isOverSoftQuotaThreshold(a, family, thresholdPercent, cacheTtlMs, model));
     if (available.length > 0) return 0;
     if (!model && family !== "claude") return null;
@@ -10849,24 +11572,24 @@ var AccountManager = class _AccountManager {
 };
 
 // src/hooks/auto-update-checker/checker.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/hooks/auto-update-checker/constants.ts
-import * as path2 from "node:path";
-import * as os2 from "node:os";
+import * as path from "node:path";
+import * as os from "node:os";
 var PACKAGE_NAME = "@cortexkit/opencode-antigravity-auth";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
 var NPM_FETCH_TIMEOUT = 5e3;
 function getCacheDir() {
   if (process.platform === "win32") {
-    return path2.join(process.env.LOCALAPPDATA ?? os2.homedir(), "opencode");
+    return path.join(process.env.LOCALAPPDATA ?? os.homedir(), "opencode");
   }
-  return path2.join(os2.homedir(), ".cache", "opencode");
+  return path.join(os.homedir(), ".cache", "opencode");
 }
 var CACHE_DIR = getCacheDir();
-var INSTALLED_PACKAGE_JSON = path2.join(
+var INSTALLED_PACKAGE_JSON = path.join(
   CACHE_DIR,
   "node_modules",
   PACKAGE_NAME,
@@ -10874,13 +11597,13 @@ var INSTALLED_PACKAGE_JSON = path2.join(
 );
 function getUserConfigDir() {
   if (process.platform === "win32") {
-    return process.env.APPDATA ?? path2.join(os2.homedir(), "AppData", "Roaming");
+    return process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
   }
-  return process.env.XDG_CONFIG_HOME ?? path2.join(os2.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
 }
 var USER_CONFIG_DIR = getUserConfigDir();
-var USER_OPENCODE_CONFIG = path2.join(USER_CONFIG_DIR, "opencode", "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = path2.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc");
+var USER_OPENCODE_CONFIG = path.join(USER_CONFIG_DIR, "opencode", "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = path.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc");
 
 // src/hooks/auto-update-checker/logging.ts
 var AUTO_UPDATE_LOG_PREFIX = "[auto-update-checker]";
@@ -10897,9 +11620,9 @@ function stripJsonComments(json) {
 }
 function getConfigPaths(directory) {
   return [
-    path3.join(directory, ".opencode", "opencode.json"),
-    path3.join(directory, ".opencode", "opencode.jsonc"),
-    path3.join(directory, ".opencode.json"),
+    path2.join(directory, ".opencode", "opencode.json"),
+    path2.join(directory, ".opencode", "opencode.jsonc"),
+    path2.join(directory, ".opencode.json"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -10907,8 +11630,8 @@ function getConfigPaths(directory) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs3.existsSync(configPath)) continue;
-      const content = fs3.readFileSync(configPath, "utf-8");
+      if (!fs2.existsSync(configPath)) continue;
+      const content = fs2.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -10928,20 +11651,20 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = fs3.statSync(startPath);
-    let dir = stat.isDirectory() ? startPath : path3.dirname(startPath);
+    const stat = fs2.statSync(startPath);
+    let dir = stat.isDirectory() ? startPath : path2.dirname(startPath);
     for (let i = 0; i < 10; i++) {
-      const pkgPath = path3.join(dir, "package.json");
-      if (fs3.existsSync(pkgPath)) {
+      const pkgPath = path2.join(dir, "package.json");
+      if (fs2.existsSync(pkgPath)) {
         try {
-          const content = fs3.readFileSync(pkgPath, "utf-8");
+          const content = fs2.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(content);
           if (pkg.name === PACKAGE_NAME) return pkgPath;
         } catch {
           continue;
         }
       }
-      const parent = path3.dirname(dir);
+      const parent = path2.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -10956,7 +11679,7 @@ function getLocalDevVersion(directory) {
   try {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath) return null;
-    const content = fs3.readFileSync(pkgPath, "utf-8");
+    const content = fs2.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version ?? null;
   } catch {
@@ -10966,8 +11689,8 @@ function getLocalDevVersion(directory) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs3.existsSync(configPath)) continue;
-      const content = fs3.readFileSync(configPath, "utf-8");
+      if (!fs2.existsSync(configPath)) continue;
+      const content = fs2.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -10991,8 +11714,8 @@ function findPluginEntry(directory) {
 }
 function getCachedVersion() {
   try {
-    if (fs3.existsSync(INSTALLED_PACKAGE_JSON)) {
-      const content = fs3.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+    if (fs2.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs2.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version) return pkg.version;
     }
@@ -11000,10 +11723,10 @@ function getCachedVersion() {
     return null;
   }
   try {
-    const currentDir = path3.dirname(fileURLToPath(import.meta.url));
+    const currentDir = path2.dirname(fileURLToPath(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
     if (pkgPath) {
-      const content = fs3.readFileSync(pkgPath, "utf-8");
+      const content = fs2.readFileSync(pkgPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version) return pkg.version;
     }
@@ -11014,7 +11737,7 @@ function getCachedVersion() {
 }
 function updatePinnedVersion(configPath, oldEntry, newVersion) {
   try {
-    const content = fs3.readFileSync(configPath, "utf-8");
+    const content = fs2.readFileSync(configPath, "utf-8");
     const newEntry = `${PACKAGE_NAME}@${newVersion}`;
     const pluginMatch = content.match(/"plugin"\s*:\s*\[/);
     if (!pluginMatch || pluginMatch.index === void 0) {
@@ -11044,7 +11767,7 @@ function updatePinnedVersion(configPath, oldEntry, newVersion) {
       logAutoUpdate(`No changes made to ${configPath}`);
       return false;
     }
-    fs3.writeFileSync(configPath, updatedContent, "utf-8");
+    fs2.writeFileSync(configPath, updatedContent, "utf-8");
     logAutoUpdate(`Updated ${configPath}: ${oldEntry} \u2192 ${newEntry}`);
     return true;
   } catch (err) {
@@ -11071,16 +11794,16 @@ async function getLatestVersion() {
 }
 
 // src/hooks/auto-update-checker/cache.ts
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
 function stripTrailingCommas(json) {
   return json.replace(/,(\s*[}\]])/g, "$1");
 }
 function removeFromBunLock(packageName) {
-  const lockPath = path4.join(CACHE_DIR, "bun.lock");
-  if (!fs4.existsSync(lockPath)) return false;
+  const lockPath = path3.join(CACHE_DIR, "bun.lock");
+  if (!fs3.existsSync(lockPath)) return false;
   try {
-    const content = fs4.readFileSync(lockPath, "utf-8");
+    const content = fs3.readFileSync(lockPath, "utf-8");
     const lock = JSON.parse(stripTrailingCommas(content));
     let modified = false;
     if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
@@ -11092,7 +11815,7 @@ function removeFromBunLock(packageName) {
       modified = true;
     }
     if (modified) {
-      fs4.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+      fs3.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
       console.log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
     }
     return modified;
@@ -11102,22 +11825,22 @@ function removeFromBunLock(packageName) {
 }
 function invalidatePackage(packageName = PACKAGE_NAME) {
   try {
-    const pkgDir = path4.join(CACHE_DIR, "node_modules", packageName);
-    const pkgJsonPath = path4.join(CACHE_DIR, "package.json");
+    const pkgDir = path3.join(CACHE_DIR, "node_modules", packageName);
+    const pkgJsonPath = path3.join(CACHE_DIR, "package.json");
     let packageRemoved = false;
     let dependencyRemoved = false;
     let lockRemoved = false;
-    if (fs4.existsSync(pkgDir)) {
-      fs4.rmSync(pkgDir, { recursive: true, force: true });
+    if (fs3.existsSync(pkgDir)) {
+      fs3.rmSync(pkgDir, { recursive: true, force: true });
       console.log(`[auto-update-checker] Package removed: ${pkgDir}`);
       packageRemoved = true;
     }
-    if (fs4.existsSync(pkgJsonPath)) {
-      const content = fs4.readFileSync(pkgJsonPath, "utf-8");
+    if (fs3.existsSync(pkgJsonPath)) {
+      const content = fs3.readFileSync(pkgJsonPath, "utf-8");
       const pkgJson = JSON.parse(content);
       if (pkgJson.dependencies?.[packageName]) {
         delete pkgJson.dependencies[packageName];
-        fs4.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        fs3.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
         console.log(`[auto-update-checker] Dependency removed from package.json: ${packageName}`);
         dependencyRemoved = true;
       }
@@ -11419,6 +12142,15 @@ function createAuthDoctorReport(input2) {
       }
     }
     for (const account of storage.accounts) {
+      if (account.accountIneligible) {
+        findings.push({
+          code: "account-ineligible",
+          severity: "warning",
+          message: account.accountIneligibleReason ?? "Google marked this account as ineligible for Antigravity.",
+          repair: "verify-account",
+          accountEmail: account.email
+        });
+      }
       if (account.verificationRequired) {
         findings.push({
           code: "verification-required",
@@ -12199,6 +12931,69 @@ async function resolvePromptContext(client, sessionId) {
   return result;
 }
 
+// src/plugin/session-context.ts
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+var FALLBACK_SESSION_KEY = "__default__";
+function extractOpenCodeSessionIdentity(headers) {
+  const normalized = new Headers(headers);
+  return {
+    sessionId: normalized.get("x-session-affinity") ?? normalized.get("x-session-id"),
+    parentSessionId: normalized.get("x-parent-session-id")
+  };
+}
+var AgySessionRegistry = class {
+  requestSessions;
+  parentSessionIds = /* @__PURE__ */ new Map();
+  constructor(directory, options = {}) {
+    const workspaceUri = directory ? pathToFileURL(resolve(directory)).href : "";
+    this.requestSessions = new AgyRequestSessionStore(workspaceUri, options);
+  }
+  getOrCreate(identity) {
+    const key = identity.sessionId ?? FALLBACK_SESSION_KEY;
+    const request = this.requestSessions.getOrCreate(key);
+    this.recordParent(key, identity.parentSessionId);
+    this.pruneParentRelationships();
+    return request;
+  }
+  beginRequest(identity) {
+    const key = identity.sessionId ?? FALLBACK_SESSION_KEY;
+    const scope = this.requestSessions.beginRequest(key);
+    this.recordParent(key, identity.parentSessionId);
+    this.pruneParentRelationships();
+    return scope;
+  }
+  register(sessionId, parentSessionId = null) {
+    this.getOrCreate({ sessionId, parentSessionId });
+  }
+  getParentSessionId(sessionId) {
+    if (!this.requestSessions.has(sessionId)) {
+      this.parentSessionIds.delete(sessionId);
+      return null;
+    }
+    return this.parentSessionIds.get(sessionId) ?? null;
+  }
+  delete(sessionId) {
+    this.requestSessions.delete(sessionId);
+    this.parentSessionIds.delete(sessionId);
+  }
+  get size() {
+    return this.requestSessions.size;
+  }
+  recordParent(key, parentSessionId) {
+    if (parentSessionId || !this.parentSessionIds.has(key)) {
+      this.parentSessionIds.set(key, parentSessionId);
+    }
+  }
+  pruneParentRelationships() {
+    for (const sessionId of this.parentSessionIds.keys()) {
+      if (!this.requestSessions.has(sessionId)) {
+        this.parentSessionIds.delete(sessionId);
+      }
+    }
+  }
+};
+
 // src/plugin.ts
 var MAX_OAUTH_ACCOUNTS = 10;
 var MAX_WARMUP_SESSIONS = 1e3;
@@ -12209,8 +13004,6 @@ function isCapacityRetryBudgetExhausted(totalCapacityRetries) {
 }
 var warmupAttemptedSessionIds = /* @__PURE__ */ new Set();
 var warmupSucceededSessionIds = /* @__PURE__ */ new Set();
-var isChildSession = false;
-var childSessionParentID = void 0;
 var log10 = createLogger2("plugin");
 var rateLimitToastCooldowns = /* @__PURE__ */ new Map();
 var RATE_LIMIT_TOAST_COOLDOWN_MS = 5e3;
@@ -12401,10 +13194,12 @@ function selectBestVerificationUrl(urls) {
   });
   return unique[0];
 }
-function extractVerificationErrorDetails(bodyText) {
+function extractAccountAccessErrorDetails(bodyText) {
   const decodedBody = decodeEscapedText(bodyText);
   const lowerBody = decodedBody.toLowerCase();
   let validationRequired = lowerBody.includes("validation_required");
+  const ineligiblePattern = /(^|[^a-z0-9_])account_ineligible([^a-z0-9_]|$)/i;
+  let accountIneligible = ineligiblePattern.test(decodedBody);
   let message;
   const verificationUrls = /* @__PURE__ */ new Set();
   const collectUrlsFromText = (text) => {
@@ -12447,6 +13242,9 @@ function extractVerificationErrorDetails(bodyText) {
       if (lowerValue.includes("validation_required")) {
         validationRequired = true;
       }
+      if (ineligiblePattern.test(normalizedValue)) {
+        accountIneligible = true;
+      }
       if (!message && (lowerKey.includes("message") || lowerKey.includes("detail") || lowerKey.includes("description"))) {
         message = normalizedValue;
       }
@@ -12477,17 +13275,72 @@ function extractVerificationErrorDetails(bodyText) {
     validationRequired = lowerBody.includes("verification required") || lowerBody.includes("verify your account") || lowerBody.includes("account verification");
   }
   if (!message) {
-    const fallback = decodedBody.split("\n").map((line) => line.trim()).find((line) => line && !line.startsWith("data:") && /(verify|validation|required)/i.test(line));
+    const fallback = decodedBody.split("\n").map((line) => line.trim()).find((line) => line && !line.startsWith("data:") && /(verify|validation|required|ineligible)/i.test(line));
     if (fallback) {
       message = fallback;
     }
   }
   return {
     validationRequired,
+    accountIneligible,
     message,
     verifyUrl: selectBestVerificationUrl([...verificationUrls])
   };
 }
+function buildAccountAccessProbeRequest(projectId) {
+  const wireModel = "gemini-3.5-flash-low";
+  const request = {
+    contents: [{ role: "user", parts: [{ text: "ping" }] }],
+    generationConfig: { maxOutputTokens: 1, temperature: 0 }
+  };
+  const requestMetadata = buildAgyAgentRequestMetadata(
+    createAgyRequestSessionContext(""),
+    request,
+    wireModel
+  );
+  request.labels = requestMetadata.labels;
+  request.sessionId = requestMetadata.sessionId;
+  orderAgyRequestPayloadInPlace(request);
+  return {
+    project: projectId,
+    requestId: requestMetadata.requestId,
+    request,
+    model: wireModel,
+    userAgent: "antigravity",
+    requestType: "agent"
+  };
+}
+async function interpretAccountAccessProbeResponse(response) {
+  if (response.ok) {
+    await response.body?.cancel().catch(() => {
+    });
+    return { status: "ok", message: "Account verification check passed." };
+  }
+  let responseBody = "";
+  try {
+    responseBody = await response.text();
+  } catch {
+    responseBody = "";
+  }
+  const extracted = extractAccountAccessErrorDetails(responseBody);
+  if (response.status === 403 && extracted.accountIneligible) {
+    return {
+      status: "ineligible",
+      message: extracted.message ?? "Google marked this account as ineligible for Antigravity."
+    };
+  }
+  if (response.status === 403 && extracted.validationRequired) {
+    return {
+      status: "verification-required",
+      message: extracted.message ?? "Google requires additional account verification.",
+      verifyUrl: extracted.verifyUrl
+    };
+  }
+  return {
+    status: "error",
+    message: extracted.message ?? `Request failed (${response.status} ${response.statusText}).`
+  };
+}
 async function verifyAccountAccess(account, client, providerId) {
   const parsed = parseRefreshParts(account.refreshToken);
   if (!parsed.refreshToken) {
@@ -12523,18 +13376,7 @@ async function verifyAccountAccess(account, client, providerId) {
     "Content-Type": "application/json",
     "Accept-Encoding": "gzip"
   };
-  const requestBody = {
-    project: projectId,
-    requestId: `agent/${crypto4.randomUUID()}/${Date.now()}/${crypto4.randomUUID()}/2`,
-    request: {
-      model: "gemini-3-flash",
-      contents: [{ role: "user", parts: [{ text: "ping" }] }],
-      generationConfig: { maxOutputTokens: 1, temperature: 0 }
-    },
-    model: "gemini-3-flash",
-    userAgent: "antigravity",
-    requestType: "agent"
-  };
+  const requestBody = buildAccountAccessProbeRequest(projectId);
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), 2e4);
   let response;
@@ -12552,28 +13394,7 @@ async function verifyAccountAccess(account, client, providerId) {
   } finally {
     clearTimeout(timeoutId);
   }
-  let responseBody = "";
-  try {
-    responseBody = await response.text();
-  } catch {
-    responseBody = "";
-  }
-  if (response.ok) {
-    return { status: "ok", message: "Account verification check passed." };
-  }
-  const extracted = extractVerificationErrorDetails(responseBody);
-  if (response.status === 403 && extracted.validationRequired) {
-    return {
-      status: "blocked",
-      message: extracted.message ?? "Google requires additional account verification.",
-      verifyUrl: extracted.verifyUrl
-    };
-  }
-  const fallbackMessage = extracted.message ?? `Request failed (${response.status} ${response.statusText}).`;
-  return {
-    status: "error",
-    message: fallbackMessage
-  };
+  return interpretAccountAccessProbeResponse(response);
 }
 async function promptAccountIndexForVerification(accounts) {
   const { createInterface: createInterface2 } = await import("node:readline/promises");
@@ -12615,12 +13436,20 @@ async function promptOpenVerificationUrl() {
 function markStoredAccountVerificationRequired(account, reason, verifyUrl) {
   let changed = false;
   const wasVerificationRequired = account.verificationRequired === true;
+  const timestamp = Date.now();
   if (!wasVerificationRequired) {
     account.verificationRequired = true;
     changed = true;
   }
   if (!wasVerificationRequired || account.verificationRequiredAt === void 0) {
-    account.verificationRequiredAt = Date.now();
+    account.verificationRequiredAt = timestamp;
+    changed = true;
+  }
+  if (account.accountIneligible === true || account.accountIneligibleAt !== void 0 || account.accountIneligibleReason !== void 0) {
+    account.accountIneligible = false;
+    account.accountIneligibleAt = void 0;
+    account.accountIneligibleReason = void 0;
+    account.eligibilityStateUpdatedAt = timestamp;
     changed = true;
   }
   const normalizedReason = reason.trim();
@@ -12639,8 +13468,25 @@ function markStoredAccountVerificationRequired(account, reason, verifyUrl) {
   }
   return changed;
 }
-function clearStoredAccountVerificationRequired(account, enableIfRequired = false) {
+function markStoredAccountIneligible(account, reason) {
+  const timestamp = Date.now();
+  const normalizedReason = reason.trim() || "Google marked this account as ineligible.";
+  const changed = account.accountIneligible !== true || account.accountIneligibleReason !== normalizedReason || account.verificationRequired === true || account.verificationRequiredAt !== void 0 || account.verificationRequiredReason !== void 0 || account.verificationUrl !== void 0 || account.enabled !== false;
+  account.accountIneligible = true;
+  account.accountIneligibleAt = timestamp;
+  account.accountIneligibleReason = normalizedReason;
+  account.eligibilityStateUpdatedAt = timestamp;
+  account.verificationRequired = false;
+  account.verificationRequiredAt = void 0;
+  account.verificationRequiredReason = void 0;
+  account.verificationUrl = void 0;
+  account.enabled = false;
+  return changed;
+}
+function clearStoredAccountAccessBlocks(account, enableIfBlocked = false) {
   const wasVerificationRequired = account.verificationRequired === true;
+  const wasIneligible = account.accountIneligible === true;
+  const wasAccessBlocked = wasVerificationRequired || wasIneligible;
   let changed = false;
   if (account.verificationRequired !== false) {
     account.verificationRequired = false;
@@ -12658,11 +13504,27 @@ function clearStoredAccountVerificationRequired(account, enableIfRequired = fals
     account.verificationUrl = void 0;
     changed = true;
   }
-  if (enableIfRequired && wasVerificationRequired && account.enabled === false) {
+  if (account.accountIneligible !== false) {
+    account.accountIneligible = false;
+    changed = true;
+  }
+  if (account.accountIneligibleAt !== void 0) {
+    account.accountIneligibleAt = void 0;
+    changed = true;
+  }
+  if (account.accountIneligibleReason !== void 0) {
+    account.accountIneligibleReason = void 0;
+    changed = true;
+  }
+  if (wasIneligible || account.eligibilityStateUpdatedAt !== void 0) {
+    account.eligibilityStateUpdatedAt = Date.now();
+    changed = true;
+  }
+  if (enableIfBlocked && wasAccessBlocked && account.enabled === false) {
     account.enabled = true;
     changed = true;
   }
-  return { changed, wasVerificationRequired };
+  return { changed, wasAccessBlocked };
 }
 async function promptOAuthCallbackValue(message) {
   const { createInterface: createInterface2 } = await import("node:readline/promises");
@@ -13054,14 +13916,14 @@ function throwHandledCommandSentinel() {
   throw new Error(HANDLED_COMMAND_SENTINEL);
 }
 function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
       reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted"));
       return;
     }
     const timeout = setTimeout(() => {
       cleanup();
-      resolve();
+      resolve2();
     }, ms);
     const onAbort = () => {
       cleanup();
@@ -13077,6 +13939,7 @@ function sleep(ms, signal) {
 var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
   const config = loadConfig(directory);
   initRuntimeConfig(config);
+  const agySessionRegistry = new AgySessionRegistry(directory);
   let cachedGetAuth = null;
   initializeDebug(config);
   initLogger(client);
@@ -13110,25 +13973,34 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
   const eventHandler = async (input2) => {
     await updateChecker.event(input2);
     if (input2.event.type === "session.created") {
-      const prevSummary = activeAccountManager?.getSessionSummary();
-      if (prevSummary && (prevSummary.totalClaude > 0 || prevSummary.totalGemini > 0)) {
-        log10.debug("prev-session-quota-summary", {
-          durationMinutes: prevSummary.durationMinutes,
-          totalClaude: prevSummary.totalClaude,
-          totalGemini: prevSummary.totalGemini,
-          requestsPerHour: prevSummary.requestsPerHour,
-          accountsUsed: prevSummary.accountsUsed
-        });
-      }
       const props = input2.event.properties;
-      if (props?.info?.parentID) {
-        isChildSession = true;
-        childSessionParentID = props.info.parentID;
-        log10.debug("child-session-detected", { parentID: props.info.parentID });
+      const sessionId = props?.info?.id;
+      const parentSessionId = props?.info?.parentID ?? null;
+      if (sessionId) {
+        agySessionRegistry.register(sessionId, parentSessionId);
+      }
+      if (parentSessionId) {
+        log10.debug("child-session-detected", { sessionId, parentID: parentSessionId });
       } else {
-        isChildSession = false;
-        childSessionParentID = void 0;
-        log10.debug("root-session-detected", {});
+        const prevSummary = activeAccountManager?.getSessionSummary();
+        if (prevSummary && (prevSummary.totalClaude > 0 || prevSummary.totalGemini > 0)) {
+          log10.debug("prev-session-quota-summary", {
+            durationMinutes: prevSummary.durationMinutes,
+            totalClaude: prevSummary.totalClaude,
+            totalGemini: prevSummary.totalGemini,
+            requestsPerHour: prevSummary.requestsPerHour,
+            accountsUsed: prevSummary.accountsUsed
+          });
+        }
+        log10.debug("root-session-detected", { sessionId });
+      }
+    }
+    if (input2.event.type === "session.deleted") {
+      const props = input2.event.properties;
+      const sessionId = props?.sessionID ?? props?.info?.id;
+      if (sessionId) {
+        agySessionRegistry.delete(sessionId);
+        activeAccountManager?.deleteSessionState(sessionId);
       }
     }
     if (sessionRecovery && input2.event.type === "session.error") {
@@ -13152,8 +14024,13 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
           }).catch(() => {
           });
           const successToast = getRecoverySuccessToast();
-          log10.debug("recovery-toast", { ...successToast, isChildSession, toastScope: config.toast_scope });
-          if (!(config.toast_scope === "root_only" && isChildSession)) {
+          const isChildRecovery = agySessionRegistry.getParentSessionId(sessionID) !== null;
+          log10.debug("recovery-toast", {
+            ...successToast,
+            isChildSession: isChildRecovery,
+            toastScope: config.toast_scope
+          });
+          if (!(config.toast_scope === "root_only" && isChildRecovery)) {
             await client.tui.showToast({
               body: {
                 title: successToast.title,
@@ -13318,6 +14195,39 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
             if (!isOAuthAuth(latestAuth)) {
               return fetch(input2, init);
             }
+            if (typeof input2 !== "string") {
+              if (input2 instanceof Request) {
+                const req = input2;
+                const headers = new Headers(req.headers);
+                if (init?.headers) {
+                  new Headers(init.headers).forEach((v, k) => headers.set(k, v));
+                }
+                const bodyBuffer = req.body ? await req.clone().arrayBuffer() : void 0;
+                init = {
+                  method: init?.method ?? req.method,
+                  headers,
+                  body: init?.body ?? (bodyBuffer ? Buffer.from(bodyBuffer) : void 0),
+                  signal: init?.signal ?? req.signal
+                };
+                input2 = req.url;
+              } else {
+                input2 = String(input2.href ?? input2);
+              }
+            }
+            const localImageTitle = getImageModelLocalTitle(input2, init);
+            if (localImageTitle !== void 0) {
+              return createSyntheticTextResponse(localImageTitle, {
+                "X-Antigravity-Response-Type": "local_title"
+              });
+            }
+            const requestSessionIdentity = extractOpenCodeSessionIdentity(init?.headers);
+            const agyRequestScope = agySessionRegistry.beginRequest(requestSessionIdentity);
+            const agyRequestSession = agyRequestScope.session;
+            const accountSessionIdentity = requestSessionIdentity.sessionId ? {
+              id: requestSessionIdentity.sessionId,
+              parentId: requestSessionIdentity.parentSessionId
+            } : void 0;
+            const isChildRequest = requestSessionIdentity.parentSessionId !== null;
             if (accountManager.getAccountCount() === 0) {
               return createSyntheticErrorResponse(
                 "No Antigravity accounts configured. Run `opencode auth login`.",
@@ -13333,6 +14243,11 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
               debugLines.push(line);
             };
             pushDebug(`request=${urlString}`);
+            if (requestSessionIdentity.sessionId) {
+              pushDebug(
+                `[Session] id=${requestSessionIdentity.sessionId} parent=${requestSessionIdentity.parentSessionId ?? "none"} child=${isChildRequest}`
+              );
+            }
             const cachedStats = getLastCacheStats();
             if (cachedStats) {
               const label = cachedStats.hitRate > 0 ? "HIT" : "MISS";
@@ -13349,11 +14264,15 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
             const quietMode = config.quiet_mode;
             const toastScope = config.toast_scope;
             const showToast = async (message, variant) => {
-              log10.debug("toast", { message, variant, isChildSession, toastScope });
+              log10.debug("toast", { message, variant, isChildSession: isChildRequest, toastScope });
               if (quietMode) return;
               if (abortSignal?.aborted) return;
-              if (toastScope === "root_only" && isChildSession) {
-                log10.debug("toast-suppressed-child-session", { message, variant, parentID: childSessionParentID });
+              if (toastScope === "root_only" && isChildRequest) {
+                log10.debug("toast-suppressed-child-session", {
+                  message,
+                  variant,
+                  parentID: requestSessionIdentity.parentSessionId
+                });
                 return;
               }
               if (variant === "warning" && message.toLowerCase().includes("rate")) {
@@ -13403,7 +14322,8 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                 preferredHeaderStyle,
                 config.pid_offset_enabled,
                 config.soft_quota_threshold_percent,
-                softQuotaCacheTtlMs
+                softQuotaCacheTtlMs,
+                accountSessionIdentity
               );
               if (!account && allowQuotaFallback) {
                 const alternateHeaderStyle = preferredHeaderStyle === "antigravity" ? "gemini-cli" : "antigravity";
@@ -13414,7 +14334,8 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                   alternateHeaderStyle,
                   config.pid_offset_enabled,
                   config.soft_quota_threshold_percent,
-                  softQuotaCacheTtlMs
+                  softQuotaCacheTtlMs,
+                  accountSessionIdentity
                 );
                 if (account) {
                   pushDebug(
@@ -13492,7 +14413,7 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                 pushDebug(`account-switch: ${previousAccountIndex} \u2192 ${account.index}, warmup=${needsCacheWarmup}`);
               }
               previousAccountIndex = account.index;
-              accountManager.recordSessionUsage(account.index);
+              accountManager.recordSessionUsage(account.index, accountSessionIdentity);
               if (isDebugEnabled()) {
                 logAccountContext("Selected", {
                   index: account.index,
@@ -13542,7 +14463,7 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                     if (removed) {
                       log10.warn("Removed revoked account from pool - reauthenticate via `opencode auth login`");
                       try {
-                        await accountManager.saveToDisk();
+                        await accountManager.saveToDiskReplace();
                       } catch (persistError) {
                         log10.error("Failed to persist revoked account removal", { error: String(persistError) });
                       }
@@ -13785,7 +14706,9 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                       {
                         claudeToolHardening: config.claude_tool_hardening,
                         claudePromptAutoCaching: config.claude_prompt_auto_caching,
-                        fingerprint: account.fingerprint
+                        fingerprint: account.fingerprint,
+                        agySession: agyRequestSession,
+                        agyRequestTimestamp: agyRequestScope.timestamp
                       }
                     );
                     const originalUrl = toUrlString(input2);
@@ -14013,7 +14936,24 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                     resetAccountFailureState(account.index);
                     if (response.status === 403) {
                       const errorBodyText = await response.clone().text().catch(() => "");
-                      const extracted = extractVerificationErrorDetails(errorBodyText);
+                      const extracted = extractAccountAccessErrorDetails(errorBodyText);
+                      if (extracted.accountIneligible) {
+                        const ineligibleReason = extracted.message ?? "Google marked this account as ineligible for Antigravity.";
+                        accountManager.markAccountIneligible(account.index, ineligibleReason);
+                        const label = account.email || `Account ${account.index + 1}`;
+                        if (accountManager.shouldShowAccountToast(account.index, 6e4)) {
+                          await showToast(
+                            `${label} is not eligible for Antigravity and has been disabled. Recheck it from opencode auth login > Verify accounts.`,
+                            "warning"
+                          );
+                          accountManager.markToastShown(account.index);
+                        }
+                        pushDebug(`account-ineligible: disabled account ${account.index}`);
+                        getHealthTracker().recordFailure(account.index);
+                        lastFailure = createFailureContext(response);
+                        shouldSwitchAccount = true;
+                        break;
+                      }
                       if (extracted.validationRequired) {
                         const verificationReason = extracted.message ?? "Google requires account verification.";
                         const cooldownMs = 10 * 60 * 1e3;
@@ -14057,20 +14997,24 @@ var createAntigravityPlugin = (providerId) => async ({ client, directory }) => {
                         family,
                         model,
                         proactiveThreshold,
-                        softQuotaCacheTtlMs
+                        softQuotaCacheTtlMs,
+                        accountSessionIdentity
                       )) {
                         const rotated = accountManager.proactivelyRotateForFamily(
                           family,
                           model,
                           headerStyle,
                           config.soft_quota_threshold_percent,
-                          softQuotaCacheTtlMs
+                          softQuotaCacheTtlMs,
+                          accountSessionIdentity
                         );
                         if (rotated) {
                           const remaining = account.cachedQuota?.[resolveQuotaGroup(family, model)]?.remainingFraction;
                           const remainingPct = remaining != null ? `${(remaining * 100).toFixed(1)}%` : "?";
                           pushDebug(`[ProactiveRotation] account ${account.index} quota ${remainingPct} < ${proactiveThreshold}%, pre-switched to account ${rotated.index} for next request`);
-                          pushDebug(`[ProactiveRotation] ${account.index} \u2192 ${rotated.index} (warm=${accountManager.wasUsedInSession(rotated.index)})`);
+                          pushDebug(
+                            `[ProactiveRotation] ${account.index} \u2192 ${rotated.index} (warm=${accountManager.wasUsedInSession(rotated.index, accountSessionIdentity)})`
+                          );
                         }
                       }
                     }
@@ -14169,7 +15113,7 @@ Alternatively, you can:
                     pushDebug(`[Quota] Total ${family} requests today (all accounts): ${totalToday}`);
                     const cachedQuota = account.cachedQuota;
                     if (cachedQuota) {
-                      const quotaFamily = family === "claude" ? "claude" : "gemini-flash";
+                      const quotaFamily = resolveQuotaGroup(family, model);
                       const groupQuota = cachedQuota[quotaFamily];
                       if (groupQuota?.remainingFraction != null) {
                         const pct = Math.round(groupQuota.remainingFraction * 100);
@@ -14324,7 +15268,9 @@ Alternatively, you can:
                   const now = Date.now();
                   const existingAccounts = existingStorage2.accounts.map((acc, idx) => {
                     let status = "unknown";
-                    if (acc.verificationRequired) {
+                    if (acc.accountIneligible) {
+                      status = "ineligible";
+                    } else if (acc.verificationRequired) {
                       status = "verification-required";
                     } else {
                       const rateLimits = acc.rateLimitResetTimes;
@@ -14460,7 +15406,8 @@ Alternatively, you can:
                         const groupEntries = [
                           { name: "Claude", data: groups.claude },
                           { name: "Gemini 3 Pro", data: groups["gemini-pro"] },
-                          { name: "Gemini 3 Flash", data: groups["gemini-flash"] }
+                          { name: "Gemini 3 Flash", data: groups["gemini-flash"] },
+                          { name: "GPT-OSS", data: groups["gpt-oss"] }
                         ].filter((g) => g.data);
                         groupEntries.forEach((g, idx) => {
                           const isLast = idx === groupEntries.length - 1;
@@ -14519,7 +15466,16 @@ ${formatAuthDoctorReport(report)}
                     if (menuResult.toggleAccountIndex !== void 0) {
                       const acc = existingStorage2.accounts[menuResult.toggleAccountIndex];
                       if (acc) {
-                        acc.enabled = acc.enabled === false;
+                        const shouldEnable = acc.enabled === false;
+                        if (shouldEnable && acc.accountIneligible) {
+                          console.log(
+                            `
+${acc.email || `Account ${menuResult.toggleAccountIndex + 1}`} remains disabled. Use Verify accounts to recheck eligibility.
+`
+                          );
+                          continue;
+                        }
+                        acc.enabled = shouldEnable;
                         await saveAccounts(existingStorage2);
                         activeAccountManager?.setAccountEnabled(menuResult.toggleAccountIndex, acc.enabled);
                         console.log(`
@@ -14541,6 +15497,7 @@ Checking verification status for ${existingStorage2.accounts.length} account(s).
 `);
                       let okCount = 0;
                       let blockedCount = 0;
+                      let ineligibleCount = 0;
                       let errorCount = 0;
                       let storageUpdated = false;
                       const blockedResults = [];
@@ -14551,16 +15508,16 @@ Checking verification status for ${existingStorage2.accounts.length} account(s).
                         process.stdout.write(`- [${i + 1}/${existingStorage2.accounts.length}] ${label2} ... `);
                         const verification2 = await verifyAccountAccess(account2, client, providerId);
                         if (verification2.status === "ok") {
-                          const { changed, wasVerificationRequired } = clearStoredAccountVerificationRequired(account2, true);
+                          const { changed, wasAccessBlocked } = clearStoredAccountAccessBlocks(account2, true);
                           if (changed) {
                             storageUpdated = true;
                           }
-                          activeAccountManager?.clearAccountVerificationRequired(i, wasVerificationRequired);
+                          activeAccountManager?.clearAccountAccessBlocks(i, wasAccessBlocked);
                           okCount += 1;
                           console.log("ok");
                           continue;
                         }
-                        if (verification2.status === "blocked") {
+                        if (verification2.status === "verification-required") {
                           const changed = markStoredAccountVerificationRequired(
                             account2,
                             verification2.message,
@@ -14580,14 +15537,26 @@ Checking verification status for ${existingStorage2.accounts.length} account(s).
                           });
                           continue;
                         }
+                        if (verification2.status === "ineligible") {
+                          const changed = markStoredAccountIneligible(account2, verification2.message);
+                          if (changed) {
+                            storageUpdated = true;
+                          }
+                          activeAccountManager?.markAccountIneligible(i, verification2.message);
+                          ineligibleCount += 1;
+                          console.log("ineligible");
+                          continue;
+                        }
                         errorCount += 1;
                         console.log(`error (${verification2.message})`);
                       }
                       if (storageUpdated) {
                         await saveAccounts(existingStorage2);
                       }
-                      console.log(`
-Verification summary: ${okCount} ready, ${blockedCount} need verification, ${errorCount} errors.`);
+                      console.log(
+                        `
+Verification summary: ${okCount} ready, ${blockedCount} need verification, ${ineligibleCount} ineligible, ${errorCount} errors.`
+                      );
                       if (blockedResults.length > 0) {
                         console.log("\nAccounts needing verification:");
                         for (const result of blockedResults) {
@@ -14627,12 +15596,12 @@ Checking verification status for ${label}...
 `);
                     const verification = await verifyAccountAccess(account, client, providerId);
                     if (verification.status === "ok") {
-                      const { changed, wasVerificationRequired } = clearStoredAccountVerificationRequired(account, true);
+                      const { changed, wasAccessBlocked } = clearStoredAccountAccessBlocks(account, true);
                       if (changed) {
                         await saveAccounts(existingStorage2);
                       }
-                      activeAccountManager?.clearAccountVerificationRequired(verifyAccountIndex, wasVerificationRequired);
-                      if (wasVerificationRequired) {
+                      activeAccountManager?.clearAccountAccessBlocks(verifyAccountIndex, wasAccessBlocked);
+                      if (wasAccessBlocked) {
                         console.log(`\u2713 ${label} is ready for requests and has been re-enabled.
 `);
                       } else {
@@ -14641,7 +15610,7 @@ Checking verification status for ${label}...
                       }
                       continue;
                     }
-                    if (verification.status === "blocked") {
+                    if (verification.status === "verification-required") {
                       const changed = markStoredAccountVerificationRequired(
                         account,
                         verification.message,
@@ -14679,6 +15648,20 @@ ${verifyUrl}
                       }
                       continue;
                     }
+                    if (verification.status === "ineligible") {
+                      const changed = markStoredAccountIneligible(account, verification.message);
+                      if (changed) {
+                        await saveAccounts(existingStorage2);
+                      }
+                      activeAccountManager?.markAccountIneligible(
+                        verifyAccountIndex,
+                        verification.message
+                      );
+                      console.log(`\u26A0 ${label} is not eligible for Antigravity and has been disabled.`);
+                      console.log(`${verification.message}
+`);
+                      continue;
+                    }
                     console.log(`\u2717 ${label}: ${verification.message}
 `);
                     continue;