@cortexkit/opencode-antigravity-auth 3.0.1 → 3.0.2

package/dist/index.js

@@ -27149,7 +27149,7 @@ async function replacePoolLogins(repository, results, options = {}) {
 }
 
 // src/sidebar-state.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync2 } from "node:fs";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { dirname as dirname14, join as join12 } from "node:path";
 
@@ -27173,7 +27173,7 @@ if (xdgConfig) {
 }
 
 // src/sidebar-state.ts
-var SIDEBAR_STATE_VERSION = 1;
+var SIDEBAR_STATE_VERSION = 2;
 var DEFAULT_SIDEBAR_STATE = {
   version: SIDEBAR_STATE_VERSION,
   checkedAt: 0,
@@ -27234,7 +27234,7 @@ function normalizeSidebarState(input2) {
   }
   const record2 = input2;
   const version = record2.version;
-  if (version !== SIDEBAR_STATE_VERSION) {
+  if (version !== 1 && version !== SIDEBAR_STATE_VERSION) {
     return {
       ...DEFAULT_SIDEBAR_STATE,
       lastError: `unsupported-version:${stringifySafe(version)}`
@@ -27289,6 +27289,7 @@ function normalizeAccount(input2) {
   return {
     id,
     label,
+    ...typeof record2.email === "string" ? { email: record2.email } : {},
     enabled,
     health,
     current,
@@ -27310,6 +27311,7 @@ function normalizeQuota(input2) {
   if (!isObject(input2)) return null;
   const record2 = input2;
   const remaining = toFiniteNumber(record2.remainingPercent);
+  const fraction = toFiniteNumber(record2.remainingFraction);
   if (remaining === null) return null;
   const resetAt = toFiniteNumber(record2.resetAt) ?? void 0;
   const checkedAt = toFiniteNumber(record2.checkedAt) ?? void 0;
@@ -27323,10 +27325,12 @@ function normalizeQuota(input2) {
       );
       const ra = toFiniteNumber(w.resetAt);
       const ca = toFiniteNumber(w.checkedAt);
+      const rf = toFiniteNumber(w.remainingFraction);
       if (win !== "weekly" && win !== "5h" || rp === null) return null;
       return {
         window: win,
         remainingPercent: clampNumber(rp, 0, 100),
+        ...rf !== null ? { remainingFraction: clampNumber(rf, 0, 1) } : {},
         resetAt: ra ?? void 0,
         ...ca !== null && ca >= 0 ? { checkedAt: ca } : {}
       };
@@ -27335,6 +27339,7 @@ function normalizeQuota(input2) {
   }
   return {
     remainingPercent: clampNumber(remaining, 0, 100),
+    ...fraction !== null ? { remainingFraction: clampNumber(fraction, 0, 1) } : {},
     resetAt,
     ...checkedAt !== void 0 ? { checkedAt } : {},
     windows
@@ -27386,6 +27391,7 @@ function stringifySafe(value) {
 }
 function ensureSidebarStateDir(path5 = getSidebarStateFile()) {
   mkdirSync3(dirname14(path5), { recursive: true, mode: SIDEBAR_STATE_DIR_MODE });
+  chmodSync3(dirname14(path5), SIDEBAR_STATE_DIR_MODE);
 }
 function pruneActiveRouting(map, now) {
   const cutoff = now - ACTIVE_ROUTING_MAX_AGE_MS;
@@ -27464,6 +27470,7 @@ function projectQuotaPoolForSidebar(source, checkedAt) {
       0,
       100
     ),
+    remainingFraction: clampNumber(w.remainingFraction, 0, 1),
     resetAt: typeof w.resetTime === "string" && w.resetTime.length > 0 ? (() => {
       const parsed = Date.parse(w.resetTime);
       return Number.isFinite(parsed) ? parsed : void 0;
@@ -27471,6 +27478,7 @@ function projectQuotaPoolForSidebar(source, checkedAt) {
   })) : void 0;
   return {
     remainingPercent,
+    remainingFraction: clampNumber(fraction, 0, 1),
     resetAt,
     windows,
     ...readingAt !== void 0 ? { checkedAt: readingAt } : {}
@@ -27507,6 +27515,7 @@ function redactAccountForSidebar(source) {
   return {
     id,
     label,
+    ...typeof source.email === "string" ? { email: source.email } : {},
     enabled,
     health,
     current,
@@ -28108,6 +28117,7 @@ async function pushSidebarQuotaSnapshot(getAccounts, backoffUntil = 0, getActive
         accounts.map((entry) => ({
           index: entry.index,
           label: entry.label,
+          email: entry.email,
           enabled: entry.enabled,
           current: activeByFamily ? isAccountCurrent(entry.index, activeByFamily) : false,
           coolingDownUntil: entry.coolingDownUntil,
@@ -35826,7 +35836,7 @@ function clearSignatureCache(sessionId) {
 }
 
 // src/plugin/image-saver.ts
-import { chmodSync as chmodSync3, existsSync as existsSync11, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { chmodSync as chmodSync4, existsSync as existsSync11, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import { join as join22 } from "node:path";
 function getImageOutputDir(outputDir) {
@@ -35834,7 +35844,7 @@ function getImageOutputDir(outputDir) {
   if (!existsSync11(resolved)) {
     mkdirSync6(resolved, { recursive: true, mode: 448 });
   }
-  chmodSync3(resolved, 448);
+  chmodSync4(resolved, 448);
   return resolved;
 }
 function generateImageFilename(mimeType) {
@@ -35855,7 +35865,7 @@ function saveImageToDisk(base64Data, mimeType, outputDir) {
     const resolvedOutputDir = getImageOutputDir(outputDir);
     const filePath = join22(resolvedOutputDir, generateImageFilename(mimeType));
     writeFileSync6(filePath, Buffer.from(base64Data, "base64"), { mode: 384 });
-    chmodSync3(filePath, 384);
+    chmodSync4(filePath, 384);
     return filePath;
   } catch (error) {
     console.error("[image-saver] Failed to save image:", error);
@@ -41008,6 +41018,7 @@ function createAuthLoader({
             return {
               index: entry.index,
               label: entry.label,
+              email: entry.email,
               enabled: entry.enabled,
               current: isAccountCurrent(entry.index, activeByFamily),
               coolingDownUntil: entry.coolingDownUntil,
@@ -41540,494 +41551,1017 @@ var BackgroundQuotaRefresh = class {
   }
 };
 
-// src/plugin/operator-settings.ts
-import { createHash as createHash18 } from "node:crypto";
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "node:fs";
-import { z as z4 } from "zod";
-
-// src/plugin/config/operator-settings-schema.ts
-import { z as z2 } from "zod";
-var OperatorSettingsSchema = z2.object({
-  routing: z2.object({
-    cli_first: z2.boolean(),
-    quota_style_fallback: z2.boolean()
-  }),
-  killswitch: z2.object({
-    enabled: z2.boolean(),
-    minimum_remaining_percent: z2.number().min(0).max(100),
-    accounts: z2.record(z2.string(), z2.number().min(0).max(100)).optional()
-  }),
-  log_level: z2.enum(["error", "warn", "info", "debug", "trace"])
-});
-function emptyOperatorSettings() {
+// src/plugin/shared/vault-request-credentials.ts
+function vaultAccountRows(routes) {
+  return routes.map((route, index) => ({
+    index,
+    enabled: true,
+    lastUsed: 0,
+    rateLimitResetTimes: {},
+    touchedForQuota: {},
+    route,
+    ...route.email !== void 0 ? { email: route.email } : {}
+  }));
+}
+function vaultAccountRowKey(row) {
+  return JSON.stringify([
+    row.route.routeId,
+    row.route.credentialId,
+    row.route.accountIdentity
+  ]);
+}
+function refreshVaultAccountRow(prior, fresh) {
+  prior.route = fresh.route;
+  if (fresh.email === void 0) delete prior.email;
+  else prior.email = fresh.email;
+}
+var VaultSendGrant = class {
+  credentialId;
+  accountIdentity;
+  recordVersion;
+  projectId;
+  report401;
+  constructor(admission, report) {
+    Object.defineProperty(this, "accessToken", {
+      value: admission.accessToken,
+      enumerable: false
+    });
+    this.credentialId = admission.credentialId;
+    this.accountIdentity = admission.accountIdentity;
+    this.recordVersion = admission.recordVersion;
+    this.projectId = admission.projectId;
+    this.report401 = report;
+  }
+};
+function createVaultRequestCredentials(source, onAdmitted) {
   return {
-    routing: { cli_first: false, quota_style_fallback: false },
-    killswitch: { enabled: false, minimum_remaining_percent: 5 },
-    log_level: "info"
+    domain: "vault",
+    async admit({ account, signal }) {
+      const admission = await source.admit(account.route, signal);
+      if (onAdmitted)
+        onAdmitted.admitted(account, onAdmitted.source.attribution(admission));
+      return new VaultSendGrant(
+        admission,
+        (status) => source.reportServedStatus(admission, status)
+      );
+    }
   };
 }
-
-// src/plugin/config/writer.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
-import { z as z3 } from "zod";
-async function writeOperatorConfig(options) {
-  const target = existsSync13(options.projectConfigPath) ? options.projectConfigPath : options.userConfigPath;
-  await writeOperatorConfigAt(target, options.operator);
+function present4(value) {
+  return value === null ? void 0 : value;
 }
-async function writeOperatorConfigAt(target, settings) {
-  const operator = OperatorSettingsSchema.parse(settings);
-  const lock = await acquireFencedFileLock({
-    path: target,
-    name: "antigravity-operator",
-    ttlMs: 5e3,
-    renew: false
-  });
-  if (!lock) {
-    throw new Error(
-      `Could not acquire operator-config lock at ${target} (already held by another writer).`
-    );
-  }
-  try {
-    const existing = readExistingConfig(target);
-    const merged = mergeOperator(existing, operator);
-    await writeJsonAtomic(target, merged);
-  } finally {
-    await lock.release().catch(() => {
-    });
+function storedResets(resets) {
+  const stored = {};
+  for (const [key, at] of Object.entries(resets))
+    if (typeof at === "number") stored[key] = at;
+  return stored;
+}
+function cachedQuotaOf(quota) {
+  const groups = quota.cachedQuota;
+  if (groups == null) return void 0;
+  const out = {};
+  for (const name of ["gemini", "non-gemini"]) {
+    const group = groups[name];
+    if (group === void 0) continue;
+    out[name] = {
+      modelCount: group.modelCount,
+      ...group.remainingFraction != null ? { remainingFraction: group.remainingFraction } : {},
+      ...group.resetTime != null ? { resetTime: group.resetTime } : {},
+      ...group.windows != null ? {
+        windows: group.windows.map((window) => ({
+          window: window.window,
+          remainingFraction: window.remainingFraction,
+          resetTime: window.resetTime
+        }))
+      } : {}
+    };
   }
+  return out;
 }
-function readExistingConfig(target) {
-  if (!existsSync13(target)) return {};
-  try {
-    const raw = readFileSync11(target, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-    return {};
-  } catch {
-    return {};
+function durableSelectionOf(row) {
+  return {
+    lastUsed: row.lastUsed,
+    ...row.lastSwitchReason !== void 0 ? { lastSwitchReason: row.lastSwitchReason } : {},
+    rateLimitResetTimes: storedResets(row.rateLimitResetTimes),
+    ...row.coolingDownUntil !== void 0 ? { coolingDownUntil: row.coolingDownUntil } : {},
+    ...row.cooldownReason !== void 0 ? { cooldownReason: row.cooldownReason } : {},
+    ...row.fingerprint !== void 0 ? { fingerprint: structuredClone(row.fingerprint) } : {},
+    ...row.fingerprintHistory !== void 0 ? { fingerprintHistory: structuredClone(row.fingerprintHistory) } : {},
+    ...row.verificationRequired !== void 0 ? { verificationRequired: row.verificationRequired } : {},
+    ...row.verificationRequiredAt !== void 0 ? { verificationRequiredAt: row.verificationRequiredAt } : {},
+    ...row.verificationRequiredReason !== void 0 ? { verificationRequiredReason: row.verificationRequiredReason } : {},
+    ...row.verificationUrl !== void 0 ? { verificationUrl: row.verificationUrl } : {},
+    ...row.accountIneligible !== void 0 ? { accountIneligible: row.accountIneligible } : {},
+    ...row.accountIneligibleAt !== void 0 ? { accountIneligibleAt: row.accountIneligibleAt } : {},
+    ...row.accountIneligibleReason !== void 0 ? { accountIneligibleReason: row.accountIneligibleReason } : {},
+    ...row.eligibilityStateUpdatedAt !== void 0 ? { eligibilityStateUpdatedAt: row.eligibilityStateUpdatedAt } : {},
+    ...row.dailyRequestCounts !== void 0 ? { dailyRequestCounts: { ...row.dailyRequestCounts } } : {}
+  };
+}
+function applyDurableSelection(row, metadata) {
+  row.lastUsed = metadata.lastUsed;
+  const reason = present4(metadata.lastSwitchReason);
+  if (reason !== void 0) row.lastSwitchReason = reason;
+  const resets = present4(metadata.rateLimitResetTimes);
+  if (resets !== void 0) {
+    const copy = {};
+    for (const [key, at] of Object.entries(resets))
+      if (typeof at === "number") copy[key] = at;
+    row.rateLimitResetTimes = copy;
+  }
+  const until = present4(metadata.coolingDownUntil);
+  const cooldownReason = present4(metadata.cooldownReason);
+  if (until !== void 0 && cooldownReason !== void 0) {
+    row.coolingDownUntil = until;
+    row.cooldownReason = cooldownReason;
   }
+  const fingerprint = present4(metadata.fingerprint);
+  if (fingerprint !== void 0) row.fingerprint = structuredClone(fingerprint);
+  const history = present4(metadata.fingerprintHistory);
+  if (history !== void 0) row.fingerprintHistory = structuredClone(history);
+  const verification = present4(metadata.verificationRequired);
+  if (verification !== void 0) row.verificationRequired = verification;
+  const verificationAt = present4(metadata.verificationRequiredAt);
+  if (verificationAt !== void 0) row.verificationRequiredAt = verificationAt;
+  const verificationReason = present4(metadata.verificationRequiredReason);
+  if (verificationReason !== void 0)
+    row.verificationRequiredReason = verificationReason;
+  const verificationUrl = present4(metadata.verificationUrl);
+  if (verificationUrl !== void 0) row.verificationUrl = verificationUrl;
+  const ineligible = present4(metadata.accountIneligible);
+  if (ineligible !== void 0) row.accountIneligible = ineligible;
+  const ineligibleAt = present4(metadata.accountIneligibleAt);
+  if (ineligibleAt !== void 0) row.accountIneligibleAt = ineligibleAt;
+  const ineligibleReason = present4(metadata.accountIneligibleReason);
+  if (ineligibleReason !== void 0)
+    row.accountIneligibleReason = ineligibleReason;
+  const eligibilityAt = present4(metadata.eligibilityStateUpdatedAt);
+  if (eligibilityAt !== void 0) row.eligibilityStateUpdatedAt = eligibilityAt;
+  const counts = present4(metadata.dailyRequestCounts);
+  if (counts !== void 0) row.dailyRequestCounts = { ...counts };
 }
-function mergeOperator(existing, operator) {
-  const next = { ...existing };
-  next.operator = operator;
-  return next;
+function stateBelongsTo(state, row) {
+  return state.observed.routeId === row.route.routeId && state.observed.credentialId === row.route.credentialId;
 }
-
-// src/plugin/operator-settings.ts
-var PartialOperatorSettingsSchema = z4.object({
-  routing: z4.object({
-    cli_first: z4.boolean().optional(),
-    quota_style_fallback: z4.boolean().optional()
-  }).optional(),
-  killswitch: z4.object({
-    enabled: z4.boolean().optional(),
-    minimum_remaining_percent: z4.number().min(0).max(100).optional(),
-    accounts: z4.record(z4.string(), z4.number().min(0).max(100)).optional()
-  }).optional(),
-  log_level: z4.enum(["error", "warn", "info", "debug", "trace"]).optional()
-});
-function createOperatorSettingsController(options) {
-  let cached = null;
-  let disposed = false;
-  let pending = null;
-  const loadFromDisk = () => {
-    const existing = readOperatorFile(options.projectConfigPath);
-    if (existing) return existing;
-    const fromUser = readOperatorFile(options.userConfigPath);
-    if (fromUser) return fromUser;
-    return emptyOperatorSettings();
+function createVaultSelectionState(options) {
+  const now = options.now ?? (() => Date.now());
+  const attributions = /* @__PURE__ */ new WeakMap();
+  const changed = /* @__PURE__ */ new Set();
+  let writing = Promise.resolve();
+  const mark = (row) => {
+    changed.add(row);
   };
-  const persist = async (next) => {
-    if (pending) await pending;
-    pending = writeOperatorConfig({
-      projectConfigPath: options.projectConfigPath,
-      userConfigPath: options.userConfigPath,
-      operator: next
-    });
+  const report = (error) => {
     try {
-      await pending;
-    } finally {
-      pending = null;
+      options.onError?.(error);
+    } catch {
     }
   };
-  return {
-    get() {
-      if (!cached) cached = loadFromDisk();
-      return cached;
+  const writeRow = async (row) => {
+    const attribution = attributions.get(row);
+    if (attribution === void 0) return;
+    changed.delete(row);
+    const selection = durableSelectionOf(row);
+    try {
+      await options.source.commitState(attribution, (current) => ({
+        metadata: {
+          ...current?.metadata ?? { addedAt: now() },
+          ...selection
+        },
+        ...current?.quota !== void 0 ? { quota: current.quota } : {},
+        ...current?.extensions !== void 0 ? { extensions: current.extensions } : {}
+      }));
+    } catch (error) {
+      report(error);
+    }
+  };
+  const flush = () => {
+    writing = writing.then(async () => {
+      for (const row of [...changed]) await writeRow(row);
+    });
+    return writing;
+  };
+  return {
+    sink: {
+      rateLimit: mark,
+      cooldown: mark,
+      switched: mark,
+      lastUsed: mark,
+      usage: mark,
+      accessVerdict: mark,
+      fingerprint: mark,
+      requestSave: () => {
+        void flush();
+      }
     },
-    async update(mutator) {
-      if (disposed) throw new Error("OperatorSettingsController is disposed");
-      const current = cached ?? loadFromDisk();
-      const draft = JSON.parse(
-        JSON.stringify(current)
-      );
-      mutator(draft);
-      const validated = OperatorSettingsSchema.parse(draft);
-      cached = validated;
-      await persist(validated);
+    admitted(row, attribution) {
+      attributions.set(row, attribution);
     },
-    async dispose() {
-      if (disposed) return;
-      disposed = true;
-      if (pending) {
-        try {
-          await pending;
-        } catch {
+    async hydrate(rows) {
+      const file = await options.readState();
+      for (const row of rows) {
+        const identity = row.route.accountIdentity;
+        if (!Object.hasOwn(file.accounts, identity)) continue;
+        const state = file.accounts[identity];
+        if (state === void 0 || !stateBelongsTo(state, row)) continue;
+        if (state.metadata !== void 0)
+          applyDurableSelection(row, state.metadata);
+        if (state.quota !== void 0) {
+          const cached = cachedQuotaOf(state.quota);
+          if (cached !== void 0) row.cachedQuota = cached;
+          const updatedAt = present4(state.quota.cachedQuotaUpdatedAt);
+          if (updatedAt !== void 0) row.cachedQuotaUpdatedAt = updatedAt;
         }
       }
+    },
+    flush,
+    recordQuota(attribution, quota) {
+      return options.source.commitState(attribution, (current) => ({
+        ...current?.metadata !== void 0 ? { metadata: current.metadata } : {},
+        quota,
+        ...current?.extensions !== void 0 ? { extensions: current.extensions } : {}
+      }));
     }
   };
 }
-function createOperatorSettingsRegistry() {
-  const entries = /* @__PURE__ */ new Map();
-  const createEntry = (path5) => {
-    let state;
-    let chain = Promise.resolve();
-    const read = () => {
-      if (state === void 0) state = readOperatorFile(path5);
-      return state;
-    };
-    return {
-      path: path5,
-      refs: 0,
-      read,
-      update(seed, mutator) {
-        const run = chain.then(async () => {
-          const draft = cloneSettings(read() ?? seed());
-          mutator(draft);
-          const validated = OperatorSettingsSchema.parse(draft);
-          state = validated;
-          await writeOperatorConfigAt(path5, validated);
-        });
-        chain = run.catch(() => {
-        });
-        return run;
-      }
-    };
+function createVaultAccountPool(options) {
+  const { source, durable } = options;
+  const state = durable ? createVaultSelectionState({
+    source: durable.source,
+    readState: durable.readState,
+    ...options.now ? { now: options.now } : {},
+    ...durable.onError ? { onError: durable.onError } : {}
+  }) : void 0;
+  const selector = new AccountSelector({
+    ...options.now ? { now: options.now } : {},
+    ...state ? { sink: state.sink } : {}
+  });
+  const credentials = createVaultRequestCredentials(
+    source,
+    state && durable ? {
+      source: durable.source,
+      admitted: (row, attribution) => state.admitted(row, attribution)
+    } : void 0
+  );
+  const rowsFromSource = async () => {
+    const rows = vaultAccountRows(source.routes());
+    if (state) {
+      const kept = new Set(selector.rows.map(vaultAccountRowKey));
+      const added = rows.filter((row) => !kept.has(vaultAccountRowKey(row)));
+      if (added.length > 0) await state.hydrate(added);
+    }
+    return rows;
   };
-  const registry = {
-    livePaths: () => [...entries.keys()],
-    acquire(path5) {
-      const key = canonicalizeOwnedPath(path5);
-      let entry = entries.get(key);
-      if (!entry) {
-        entry = createEntry(key);
-        entries.set(key, entry);
-      }
-      entry.refs++;
-      return entry;
+  const replace = async () => {
+    selector.replaceAccounts(await rowsFromSource(), {
+      keyOf: vaultAccountRowKey,
+      refresh: refreshVaultAccountRow
+    });
+  };
+  let firstRead = null;
+  const readOnce = () => {
+    firstRead ??= (async () => {
+      await source.refresh();
+      selector.resetAccounts(await rowsFromSource());
+    })().catch((error) => {
+      firstRead = null;
+      throw error;
+    });
+    return firstRead;
+  };
+  return {
+    selector,
+    credentials,
+    state,
+    async sync() {
+      const pending = firstRead;
+      await readOnce();
+      if (pending !== null) await replace();
     },
-    release(entry) {
-      entry.refs--;
-      if (entry.refs <= 0 && entries.get(entry.path) === entry) {
-        entries.delete(entry.path);
-      }
+    async refresh() {
+      await readOnce();
+      await source.refresh();
+      await replace();
+    },
+    flush: async () => {
+      await state?.flush();
     }
   };
-  return registry;
-}
-var processOperatorSettingsRegistry = createOperatorSettingsRegistry();
-function cloneSettings(settings) {
-  return JSON.parse(JSON.stringify(settings));
 }
-function readOperatorFile(path5) {
-  try {
-    const raw = readFileSync12(path5, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== "object" || !("operator" in parsed)) {
-      return null;
-    }
-    const partial = PartialOperatorSettingsSchema.safeParse(
-      parsed.operator
-    );
-    if (!partial.success) return null;
-    return mergeWithDefaults(partial.data);
-  } catch {
-    return null;
+function vaultQuotaState(quota, at) {
+  const cachedQuota = {};
+  for (const [name, group] of Object.entries(quota.groups)) {
+    if (group === void 0) continue;
+    cachedQuota[name] = {
+      modelCount: group.modelCount,
+      ...group.remainingFraction !== void 0 ? { remainingFraction: group.remainingFraction } : {},
+      ...group.resetTime !== void 0 ? { resetTime: group.resetTime } : {},
+      ...group.windows !== void 0 ? { windows: group.windows.map((window) => ({ ...window })) } : {}
+    };
   }
+  return { schemaVersion: 1, cachedQuota, cachedQuotaUpdatedAt: at };
 }
-function mergeWithDefaults(partial) {
-  const defaults = emptyOperatorSettings();
-  return {
-    routing: { ...defaults.routing, ...partial.routing ?? {} },
-    killswitch: {
-      ...defaults.killswitch,
-      ...partial.killswitch ?? {},
-      accounts: {
-        ...defaults.killswitch.accounts ?? {},
-        ...partial.killswitch?.accounts ?? {}
+async function checkVaultQuota(input2) {
+  const state = input2.pool.state;
+  const rows = [...input2.pool.selector.rows];
+  const now = input2.now ?? (() => Date.now());
+  let checked = 0;
+  for (const row of rows) {
+    if (input2.signal.aborted || state === void 0) break;
+    try {
+      const answer = await input2.fetchReading(row.route, input2.signal);
+      const attribution = answer.quotaAttribution;
+      if (attribution === void 0 || answer.quota.error !== void 0)
+        continue;
+      const reading = vaultQuotaState(answer.quota, now());
+      const result = await state.recordQuota(attribution, reading);
+      if (result.status !== "written") continue;
+      checked += 1;
+      const live = input2.pool.selector.rows.find(
+        (candidate) => candidate.route.routeId === attribution.routeId && candidate.route.credentialId === attribution.credentialId && candidate.route.accountIdentity === attribution.accountIdentity
+      );
+      if (live !== void 0) {
+        const cached = cachedQuotaOf(reading);
+        if (cached !== void 0) live.cachedQuota = cached;
+        live.cachedQuotaUpdatedAt = reading.cachedQuotaUpdatedAt ?? void 0;
       }
-    },
-    log_level: partial.log_level ?? defaults.log_level
-  };
+    } catch (error) {
+      try {
+        input2.onError?.(error);
+      } catch {
+      }
+    }
+  }
+  return { checked, notChecked: rows.length - checked };
 }
-function accountKeyForRefreshToken(refreshToken) {
-  return createHash18("sha256").update(refreshToken).digest("hex").slice(0, 12);
+
+// src/plugin/vault-quota-refresh.ts
+async function checkAndPublishVaultQuota(input2, publishSidebar) {
+  const report = await checkVaultQuota(input2);
+  if (report.checked > 0 && !input2.signal.aborted) await publishSidebar();
+  return report;
 }
 
-// src/plugin/command-apply.ts
-function operatorMenuSettings(settings) {
-  return {
-    read() {
-      const current = settings.get();
+// src/plugin/vault-sidebar-projection.ts
+function quotaReadingForVaultRoute(route, state) {
+  const stored = state.accounts[route.accountIdentity];
+  return stored?.observed.routeId === route.routeId && stored.observed.credentialId === route.credentialId ? stored.quota : void 0;
+}
+function buildVaultSidebarProjection(pool, state, checkedAt = Date.now()) {
+  const projection = buildSidebarMachineStateFromAccounts(
+    pool.selector.rows.map((row) => {
+      const quota = quotaReadingForVaultRoute(row.route, state);
       return {
-        routing: {
-          cliFirst: current.routing.cli_first,
-          quotaStyleFallback: current.routing.quota_style_fallback
-        },
-        killswitch: {
-          enabled: current.killswitch.enabled,
-          minimumRemainingPercent: current.killswitch.minimum_remaining_percent
-        }
+        index: row.index,
+        email: row.route.email,
+        enabled: row.enabled,
+        current: false,
+        coolingDownUntil: row.coolingDownUntil,
+        healthScore: pool.selector.healthTracker.getScore(row.index),
+        cachedQuota: quota ? cachedQuotaOf(quota) : void 0,
+        cachedQuotaUpdatedAt: quota?.cachedQuotaUpdatedAt ?? void 0
       };
-    },
-    updateRouting: (next) => settings.update((draft) => {
-      draft.routing.cli_first = next.cliFirst;
-      draft.routing.quota_style_fallback = next.quotaStyleFallback;
     }),
-    updateKillswitch: (next) => settings.update((draft) => {
-      draft.killswitch.enabled = next.enabled;
-      draft.killswitch.minimum_remaining_percent = next.minimumRemainingPercent;
-    })
+    { checkedAt }
+  );
+  return {
+    ...projection,
+    accounts: projection.accounts.map((account) => ({
+      ...account,
+      id: `vault-${account.id}`
+    }))
   };
 }
-var LOG_LEVEL_CHOICES = ["error", "warn", "info", "debug", "trace"];
-function diagnosticsMenuSection(options) {
-  return {
-    title: "Diagnostics",
-    build() {
-      const level = options.settings.get().log_level;
-      const dumping = options.dump.isEnabled();
-      return {
-        lines: [
-          `Gemini request dump: ${dumping ? "on" : "off"}`,
-          `Log level: ${level}`
-        ],
-        actions: [
-          {
-            id: "dump",
-            label: dumping ? "Stop dumping requests" : "Dump requests",
-            run: async () => {
-              options.dump.setEnabled(!dumping);
-              return `Gemini request dump ${dumping ? "off" : "on"}`;
-            }
-          },
-          {
-            id: "logging",
-            label: "Change log level",
-            knobs: [
-              {
-                kind: "choice",
-                id: "level",
-                label: "Level",
-                choices: LOG_LEVEL_CHOICES.map((value) => ({
-                  value,
-                  label: value
-                })),
-                value: level
+
+// src/plugin/background-vault-quota-refresh.ts
+var BackgroundVaultQuotaRefresh = class {
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.random = options.random ?? Math.random;
+    this.acquireLock = options.acquireLock ?? acquireFencedFileLock;
+  }
+  options;
+  timer = null;
+  inFlight = null;
+  controller = null;
+  disposed = false;
+  started = false;
+  now;
+  random;
+  acquireLock;
+  start() {
+    if (this.disposed || this.started) return;
+    this.started = true;
+    this.schedule(Math.floor(this.random() * 3e4));
+  }
+  /** Custody notifications cancel admitted work as soon as authority changes. */
+  abortTick() {
+    this.controller?.abort();
+  }
+  async dispose() {
+    this.disposed = true;
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    this.abortTick();
+    await this.inFlight;
+  }
+  schedule(delay) {
+    if (this.disposed || !this.started) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.tick();
+    }, delay);
+    this.timer.unref?.();
+  }
+  /** One serialized tick; also used by deterministic composition tests. */
+  tick() {
+    if (this.disposed) return Promise.resolve();
+    if (this.inFlight) return this.inFlight;
+    const controller = new AbortController();
+    this.controller = controller;
+    let extraJitter = 0;
+    this.inFlight = this.runTick(controller).catch(() => {
+      extraJitter = 15e3;
+    }).finally(() => {
+      this.inFlight = null;
+      this.controller = null;
+      this.schedule(
+        this.options.intervalMs + Math.floor(this.random() * this.options.intervalMs * 0.1) + extraJitter
+      );
+    });
+    return this.inFlight;
+  }
+  async assertActive(controller) {
+    if (this.disposed || await this.options.readAuthority() !== "vault")
+      controller.abort();
+    controller.signal.throwIfAborted();
+  }
+  async runTick(controller) {
+    await this.assertActive(controller);
+    ensureSidebarStateDir(this.options.sidebarStateFile);
+    const lock = await this.acquireLock({
+      path: this.options.sidebarStateFile,
+      name: "bg-vault-quota-poll",
+      ttlMs: 6e4,
+      renew: true
+    });
+    if (!lock) return;
+    let released = false;
+    void lock.whenLost().then(() => {
+      if (!released) controller.abort();
+    });
+    try {
+      await this.assertActive(controller);
+      await lock.assertOwned();
+      const { source, pool } = await this.options.currentVaultPool();
+      await this.assertActive(controller);
+      await pool.sync();
+      await this.assertActive(controller);
+      const state = await this.options.readProviderState();
+      await this.assertActive(controller);
+      await lock.assertOwned();
+      const threshold = Math.max(
+        this.options.intervalMs - 6e4,
+        Math.floor(this.options.intervalMs / 2)
+      );
+      const now = this.now();
+      const due = pool.selector.rows.some((row) => {
+        const quota = quotaReadingForVaultRoute(row.route, state);
+        const at = quota?.cachedQuotaUpdatedAt;
+        return quota?.cachedQuota == null || typeof at !== "number" || !Number.isFinite(at) || at < 0 || now - at >= threshold;
+      });
+      if (!due) return;
+      await checkAndPublishVaultQuota(
+        {
+          pool,
+          signal: controller.signal,
+          now: this.now,
+          fetchReading: async (ref, signal) => {
+            await this.assertActive(controller);
+            const reading = await fetchVaultAccountQuota({
+              source,
+              ref,
+              signal,
+              logger: this.options.logger,
+              transport: async (url, init, extra) => {
+                await this.assertActive(controller);
+                await lock.assertOwned();
+                controller.signal.throwIfAborted();
+                return this.options.transport(
+                  url,
+                  { ...init, signal: extra.signal ?? controller.signal },
+                  extra
+                );
               }
-            ],
-            run: async ({ values }) => {
-              const next = LOG_LEVEL_CHOICES.find(
-                (candidate) => candidate === values.level
-              );
-              if (next === void 0)
-                return {
-                  ok: false,
-                  text: "Choose a log level",
-                  code: "invalid-input"
-                };
-              await options.settings.update((draft) => {
-                draft.log_level = next;
-              });
-              options.applyLogLevel(next);
-              return `Log level set to ${next}`;
-            }
+            });
+            await this.assertActive(controller);
+            await lock.assertOwned();
+            return reading;
           }
-        ]
-      };
+        },
+        async () => {
+          await this.assertActive(controller);
+          await lock.assertOwned();
+          await this.options.publishSidebar();
+        }
+      );
+    } finally {
+      released = true;
+      await lock.release().catch(() => {
+      });
     }
-  };
-}
-var STALE_FAILURES = /* @__PURE__ */ new Set(["attribution", "unknown-row", "id-removed"]);
-function createStoreAccountLimits(input2) {
+  }
+};
+
+// src/plugin/operator-settings.ts
+import { createHash as createHash18 } from "node:crypto";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "node:fs";
+import { z as z4 } from "zod";
+
+// src/plugin/config/operator-settings-schema.ts
+import { z as z2 } from "zod";
+var OperatorSettingsSchema = z2.object({
+  routing: z2.object({
+    cli_first: z2.boolean(),
+    quota_style_fallback: z2.boolean()
+  }),
+  killswitch: z2.object({
+    enabled: z2.boolean(),
+    minimum_remaining_percent: z2.number().min(0).max(100),
+    accounts: z2.record(z2.string(), z2.number().min(0).max(100)).optional()
+  }),
+  log_level: z2.enum(["error", "warn", "info", "debug", "trace"])
+});
+function emptyOperatorSettings() {
   return {
-    async read(ref) {
-      const read = await input2.repository.read();
-      if (read.status !== "ready") return null;
-      const row = read.rows.find((candidate) => sameRowRef(candidate.ref, ref));
-      const token2 = row?.credential?.refreshToken;
-      if (token2 === void 0) return null;
-      return input2.settings.get().killswitch.accounts?.[accountKeyForRefreshToken(token2)] ?? null;
-    },
-    async write(ref, minimumRemainingPercent) {
-      try {
-        await input2.repository.updateMetadata(ref, async (_current, row) => {
-          const token2 = row.credential?.refreshToken;
-          if (token2 === void 0)
-            throw new Error("The account holds no stored credential");
-          const key = accountKeyForRefreshToken(token2);
-          await input2.settings.update((draft) => {
-            const accounts = { ...draft.killswitch.accounts ?? {} };
-            if (minimumRemainingPercent === null) delete accounts[key];
-            else accounts[key] = minimumRemainingPercent;
-            draft.killswitch.accounts = accounts;
-          });
-          return { kind: "keep" };
-        });
-      } catch (error) {
-        if (error instanceof AccountRepositoryError && STALE_FAILURES.has(error.failure.kind))
-          return "stale";
-        throw error;
-      }
-      return "applied";
-    }
+    routing: { cli_first: false, quota_style_fallback: false },
+    killswitch: { enabled: false, minimum_remaining_percent: 5 },
+    log_level: "info"
   };
 }
 
-// src/plugin/prompt-context.ts
-function isRecord15(value) {
-  return typeof value === "object" && value !== null;
+// src/plugin/config/writer.ts
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import { z as z3 } from "zod";
+async function writeOperatorConfig(options) {
+  const target = existsSync13(options.projectConfigPath) ? options.projectConfigPath : options.userConfigPath;
+  await writeOperatorConfigAt(target, options.operator);
 }
-function extractMessages(response) {
-  if (Array.isArray(response)) return response;
-  if (isRecord15(response) && Array.isArray(response.data)) return response.data;
-  return [];
+async function writeOperatorConfigAt(target, settings) {
+  const operator = OperatorSettingsSchema.parse(settings);
+  const lock = await acquireFencedFileLock({
+    path: target,
+    name: "antigravity-operator",
+    ttlMs: 5e3,
+    renew: false
+  });
+  if (!lock) {
+    throw new Error(
+      `Could not acquire operator-config lock at ${target} (already held by another writer).`
+    );
+  }
+  try {
+    const existing = readExistingConfig(target);
+    const merged = mergeOperator(existing, operator);
+    await writeJsonAtomic(target, merged);
+  } finally {
+    await lock.release().catch(() => {
+    });
+  }
 }
-function getRole(message) {
-  if (!isRecord15(message) || !isRecord15(message.info)) return void 0;
-  return typeof message.info.role === "string" ? message.info.role : void 0;
+function readExistingConfig(target) {
+  if (!existsSync13(target)) return {};
+  try {
+    const raw = readFileSync11(target, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
 }
-function extractFromMessage(message) {
-  if (!isRecord15(message) || !isRecord15(message.info)) return null;
-  const info = message.info;
-  const modelInfo = isRecord15(info.model) ? info.model : void 0;
-  const agent = typeof info.agent === "string" ? info.agent : void 0;
-  const providerID = typeof modelInfo?.providerID === "string" ? modelInfo.providerID : typeof info.providerID === "string" ? info.providerID : void 0;
-  const modelID = typeof modelInfo?.modelID === "string" ? modelInfo.modelID : typeof info.modelID === "string" ? info.modelID : void 0;
-  const variant = typeof modelInfo?.variant === "string" ? modelInfo.variant : typeof info.variant === "string" ? info.variant : void 0;
-  if (!agent && (!providerID || !modelID) && !variant) return null;
-  const context = {};
-  if (agent) context.agent = agent;
-  if (providerID && modelID) context.model = { providerID, modelID };
-  if (variant) context.variant = variant;
-  return context;
+function mergeOperator(existing, operator) {
+  const next = { ...existing };
+  next.operator = operator;
+  return next;
 }
-function mergeContexts(base, patch) {
-  return {
-    agent: base.agent ?? patch.agent,
-    model: base.model ?? patch.model,
-    variant: base.variant ?? patch.variant
+
+// src/plugin/operator-settings.ts
+var PartialOperatorSettingsSchema = z4.object({
+  routing: z4.object({
+    cli_first: z4.boolean().optional(),
+    quota_style_fallback: z4.boolean().optional()
+  }).optional(),
+  killswitch: z4.object({
+    enabled: z4.boolean().optional(),
+    minimum_remaining_percent: z4.number().min(0).max(100).optional(),
+    accounts: z4.record(z4.string(), z4.number().min(0).max(100)).optional()
+  }).optional(),
+  log_level: z4.enum(["error", "warn", "info", "debug", "trace"]).optional()
+});
+function createOperatorSettingsController(options) {
+  let cached = null;
+  let disposed = false;
+  let pending = null;
+  const loadFromDisk = () => {
+    const existing = readOperatorFile(options.projectConfigPath);
+    if (existing) return existing;
+    const fromUser = readOperatorFile(options.userConfigPath);
+    if (fromUser) return fromUser;
+    return emptyOperatorSettings();
+  };
+  const persist = async (next) => {
+    if (pending) await pending;
+    pending = writeOperatorConfig({
+      projectConfigPath: options.projectConfigPath,
+      userConfigPath: options.userConfigPath,
+      operator: next
+    });
+    try {
+      await pending;
+    } finally {
+      pending = null;
+    }
+  };
+  return {
+    get() {
+      if (!cached) cached = loadFromDisk();
+      return cached;
+    },
+    async update(mutator) {
+      if (disposed) throw new Error("OperatorSettingsController is disposed");
+      const current = cached ?? loadFromDisk();
+      const draft = JSON.parse(
+        JSON.stringify(current)
+      );
+      mutator(draft);
+      const validated = OperatorSettingsSchema.parse(draft);
+      cached = validated;
+      await persist(validated);
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (pending) {
+        try {
+          await pending;
+        } catch {
+        }
+      }
+    }
   };
 }
-function isComplete(context) {
-  return Boolean(context.agent && context.model && context.variant);
+function createOperatorSettingsRegistry() {
+  const entries = /* @__PURE__ */ new Map();
+  const createEntry = (path5) => {
+    let state;
+    let chain = Promise.resolve();
+    const read = () => {
+      if (state === void 0) state = readOperatorFile(path5);
+      return state;
+    };
+    return {
+      path: path5,
+      refs: 0,
+      read,
+      update(seed, mutator) {
+        const run = chain.then(async () => {
+          const draft = cloneSettings(read() ?? seed());
+          mutator(draft);
+          const validated = OperatorSettingsSchema.parse(draft);
+          state = validated;
+          await writeOperatorConfigAt(path5, validated);
+        });
+        chain = run.catch(() => {
+        });
+        return run;
+      }
+    };
+  };
+  const registry = {
+    livePaths: () => [...entries.keys()],
+    acquire(path5) {
+      const key = canonicalizeOwnedPath(path5);
+      let entry = entries.get(key);
+      if (!entry) {
+        entry = createEntry(key);
+        entries.set(key, entry);
+      }
+      entry.refs++;
+      return entry;
+    },
+    release(entry) {
+      entry.refs--;
+      if (entry.refs <= 0 && entries.get(entry.path) === entry) {
+        entries.delete(entry.path);
+      }
+    }
+  };
+  return registry;
 }
-async function resolvePromptContext(client, sessionId) {
-  if (!client || !sessionId) return null;
-  const typedClient = client;
-  if (typeof typedClient.session?.messages !== "function") return null;
-  let messages = [];
+var processOperatorSettingsRegistry = createOperatorSettingsRegistry();
+function cloneSettings(settings) {
+  return JSON.parse(JSON.stringify(settings));
+}
+function readOperatorFile(path5) {
   try {
-    messages = extractMessages(
-      await Promise.resolve(
-        typedClient.session.messages({
-          path: { id: sessionId },
-          query: { limit: 100 }
-        })
-      )
+    const raw = readFileSync12(path5, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || !("operator" in parsed)) {
+      return null;
+    }
+    const partial = PartialOperatorSettingsSchema.safeParse(
+      parsed.operator
     );
+    if (!partial.success) return null;
+    return mergeWithDefaults(partial.data);
   } catch {
     return null;
   }
-  if (messages.length === 0) return null;
-  let result = {};
-  for (let index = messages.length - 1; index >= 0; index--) {
-    if (getRole(messages[index]) !== "assistant") continue;
-    const context = extractFromMessage(messages[index]);
-    if (!context) continue;
-    result = mergeContexts(result, context);
-    if (isComplete(result)) return result;
-  }
-  for (let index = messages.length - 1; index >= 0; index--) {
-    const context = extractFromMessage(messages[index]);
-    if (!context) continue;
-    result = mergeContexts(result, context);
-    if (isComplete(result)) return result;
-  }
-  if (!result.agent && !result.model && !result.variant) return null;
-  return result;
 }
-
-// src/plugin/commands.ts
-var HANDLED_COMMAND_SENTINEL = "ANTIGRAVITY_COMMAND_HANDLED";
-async function sendIgnoredMessage(client, sessionID, text2) {
-  const session = client.session;
-  const promptContext = await resolvePromptContext(client, sessionID);
-  const request = {
-    path: { id: sessionID },
-    body: {
-      noReply: true,
-      parts: [{ type: "text", text: text2, ignored: true }],
-      ...promptContext?.agent ? { agent: promptContext.agent } : {},
-      ...promptContext?.model ? { model: promptContext.model } : {},
-      ...promptContext?.variant ? { variant: promptContext.variant } : {}
-    }
+function mergeWithDefaults(partial) {
+  const defaults = emptyOperatorSettings();
+  return {
+    routing: { ...defaults.routing, ...partial.routing ?? {} },
+    killswitch: {
+      ...defaults.killswitch,
+      ...partial.killswitch ?? {},
+      accounts: {
+        ...defaults.killswitch.accounts ?? {},
+        ...partial.killswitch?.accounts ?? {}
+      }
+    },
+    log_level: partial.log_level ?? defaults.log_level
   };
-  if (typeof session?.promptAsync === "function") {
-    await session.promptAsync(request);
-    return;
-  }
-  if (typeof session?.prompt === "function") {
-    await Promise.resolve(session.prompt(request));
-    return;
-  }
-  throw new Error(
-    "OpenCode session prompt API is unavailable for ignored replies."
-  );
 }
-function throwHandledCommandSentinel() {
-  throw new Error(HANDLED_COMMAND_SENTINEL);
+function accountKeyForRefreshToken(refreshToken) {
+  return createHash18("sha256").update(refreshToken).digest("hex").slice(0, 12);
 }
-function menuInvocation(push, sessionId) {
+
+// src/plugin/command-apply.ts
+function operatorMenuSettings(settings) {
   return {
-    ...sessionId !== void 0 ? { sessionId } : {},
-    notify(message, kind) {
-      push(
-        {
-          command: ANTIGRAVITY_MENU_COMMAND,
-          notify: { message, kind: kind ?? "info" }
+    read() {
+      const current = settings.get();
+      return {
+        routing: {
+          cliFirst: current.routing.cli_first,
+          quotaStyleFallback: current.routing.quota_style_fallback
         },
-        sessionId
-      );
-    }
+        killswitch: {
+          enabled: current.killswitch.enabled,
+          minimumRemainingPercent: current.killswitch.minimum_remaining_percent
+        }
+      };
+    },
+    updateRouting: (next) => settings.update((draft) => {
+      draft.routing.cli_first = next.cliFirst;
+      draft.routing.quota_style_fallback = next.quotaStyleFallback;
+    }),
+    updateKillswitch: (next) => settings.update((draft) => {
+      draft.killswitch.enabled = next.enabled;
+      draft.killswitch.minimum_remaining_percent = next.minimumRemainingPercent;
+    })
   };
 }
-function createAntigravityCommandExecuteBefore(options) {
-  const connection = options.connection ?? {
-    isTuiConnected
-  };
-  return async (input2) => {
-    if (input2.command !== ANTIGRAVITY_MENU_COMMAND) return;
-    const opening = await options.open(input2.sessionID);
-    if (opening.kind === "menu") {
-      options.push(opening.payload, input2.sessionID);
-    } else {
-      options.push(
-        {
-          command: ANTIGRAVITY_MENU_COMMAND,
-          notify: { message: opening.message, kind: "warning" }
-        },
-        input2.sessionID
-      );
-    }
-    if (!connection.isTuiConnected(input2.sessionID)) {
-      await sendIgnoredMessage(
-        options.client,
-        input2.sessionID,
-        opening.kind === "menu" ? "The Antigravity menu opens in the OpenCode terminal interface." : opening.message
+var LOG_LEVEL_CHOICES = ["error", "warn", "info", "debug", "trace"];
+function diagnosticsMenuSection(options) {
+  return {
+    title: "Diagnostics",
+    build() {
+      const level = options.settings.get().log_level;
+      const dumping = options.dump.isEnabled();
+      return {
+        lines: [
+          `Gemini request dump: ${dumping ? "on" : "off"}`,
+          `Log level: ${level}`
+        ],
+        actions: [
+          {
+            id: "dump",
+            label: dumping ? "Stop dumping requests" : "Dump requests",
+            run: async () => {
+              options.dump.setEnabled(!dumping);
+              return `Gemini request dump ${dumping ? "off" : "on"}`;
+            }
+          },
+          {
+            id: "logging",
+            label: "Change log level",
+            knobs: [
+              {
+                kind: "choice",
+                id: "level",
+                label: "Level",
+                choices: LOG_LEVEL_CHOICES.map((value) => ({
+                  value,
+                  label: value
+                })),
+                value: level
+              }
+            ],
+            run: async ({ values }) => {
+              const next = LOG_LEVEL_CHOICES.find(
+                (candidate) => candidate === values.level
+              );
+              if (next === void 0)
+                return {
+                  ok: false,
+                  text: "Choose a log level",
+                  code: "invalid-input"
+                };
+              await options.settings.update((draft) => {
+                draft.log_level = next;
+              });
+              options.applyLogLevel(next);
+              return `Log level set to ${next}`;
+            }
+          }
+        ]
+      };
+    }
+  };
+}
+var STALE_FAILURES = /* @__PURE__ */ new Set(["attribution", "unknown-row", "id-removed"]);
+function createStoreAccountLimits(input2) {
+  return {
+    async read(ref) {
+      const read = await input2.repository.read();
+      if (read.status !== "ready") return null;
+      const row = read.rows.find((candidate) => sameRowRef(candidate.ref, ref));
+      const token2 = row?.credential?.refreshToken;
+      if (token2 === void 0) return null;
+      return input2.settings.get().killswitch.accounts?.[accountKeyForRefreshToken(token2)] ?? null;
+    },
+    async write(ref, minimumRemainingPercent) {
+      try {
+        await input2.repository.updateMetadata(ref, async (_current, row) => {
+          const token2 = row.credential?.refreshToken;
+          if (token2 === void 0)
+            throw new Error("The account holds no stored credential");
+          const key = accountKeyForRefreshToken(token2);
+          await input2.settings.update((draft) => {
+            const accounts = { ...draft.killswitch.accounts ?? {} };
+            if (minimumRemainingPercent === null) delete accounts[key];
+            else accounts[key] = minimumRemainingPercent;
+            draft.killswitch.accounts = accounts;
+          });
+          return { kind: "keep" };
+        });
+      } catch (error) {
+        if (error instanceof AccountRepositoryError && STALE_FAILURES.has(error.failure.kind))
+          return "stale";
+        throw error;
+      }
+      return "applied";
+    }
+  };
+}
+
+// src/plugin/prompt-context.ts
+function isRecord15(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractMessages(response) {
+  if (Array.isArray(response)) return response;
+  if (isRecord15(response) && Array.isArray(response.data)) return response.data;
+  return [];
+}
+function getRole(message) {
+  if (!isRecord15(message) || !isRecord15(message.info)) return void 0;
+  return typeof message.info.role === "string" ? message.info.role : void 0;
+}
+function extractFromMessage(message) {
+  if (!isRecord15(message) || !isRecord15(message.info)) return null;
+  const info = message.info;
+  const modelInfo = isRecord15(info.model) ? info.model : void 0;
+  const agent = typeof info.agent === "string" ? info.agent : void 0;
+  const providerID = typeof modelInfo?.providerID === "string" ? modelInfo.providerID : typeof info.providerID === "string" ? info.providerID : void 0;
+  const modelID = typeof modelInfo?.modelID === "string" ? modelInfo.modelID : typeof info.modelID === "string" ? info.modelID : void 0;
+  const variant = typeof modelInfo?.variant === "string" ? modelInfo.variant : typeof info.variant === "string" ? info.variant : void 0;
+  if (!agent && (!providerID || !modelID) && !variant) return null;
+  const context = {};
+  if (agent) context.agent = agent;
+  if (providerID && modelID) context.model = { providerID, modelID };
+  if (variant) context.variant = variant;
+  return context;
+}
+function mergeContexts(base, patch) {
+  return {
+    agent: base.agent ?? patch.agent,
+    model: base.model ?? patch.model,
+    variant: base.variant ?? patch.variant
+  };
+}
+function isComplete(context) {
+  return Boolean(context.agent && context.model && context.variant);
+}
+async function resolvePromptContext(client, sessionId) {
+  if (!client || !sessionId) return null;
+  const typedClient = client;
+  if (typeof typedClient.session?.messages !== "function") return null;
+  let messages = [];
+  try {
+    messages = extractMessages(
+      await Promise.resolve(
+        typedClient.session.messages({
+          path: { id: sessionId },
+          query: { limit: 100 }
+        })
+      )
+    );
+  } catch {
+    return null;
+  }
+  if (messages.length === 0) return null;
+  let result = {};
+  for (let index = messages.length - 1; index >= 0; index--) {
+    if (getRole(messages[index]) !== "assistant") continue;
+    const context = extractFromMessage(messages[index]);
+    if (!context) continue;
+    result = mergeContexts(result, context);
+    if (isComplete(result)) return result;
+  }
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const context = extractFromMessage(messages[index]);
+    if (!context) continue;
+    result = mergeContexts(result, context);
+    if (isComplete(result)) return result;
+  }
+  if (!result.agent && !result.model && !result.variant) return null;
+  return result;
+}
+
+// src/plugin/commands.ts
+var HANDLED_COMMAND_SENTINEL = "ANTIGRAVITY_COMMAND_HANDLED";
+async function sendIgnoredMessage(client, sessionID, text2) {
+  const session = client.session;
+  const promptContext = await resolvePromptContext(client, sessionID);
+  const request = {
+    path: { id: sessionID },
+    body: {
+      noReply: true,
+      parts: [{ type: "text", text: text2, ignored: true }],
+      ...promptContext?.agent ? { agent: promptContext.agent } : {},
+      ...promptContext?.model ? { model: promptContext.model } : {},
+      ...promptContext?.variant ? { variant: promptContext.variant } : {}
+    }
+  };
+  if (typeof session?.promptAsync === "function") {
+    await session.promptAsync(request);
+    return;
+  }
+  if (typeof session?.prompt === "function") {
+    await Promise.resolve(session.prompt(request));
+    return;
+  }
+  throw new Error(
+    "OpenCode session prompt API is unavailable for ignored replies."
+  );
+}
+function throwHandledCommandSentinel() {
+  throw new Error(HANDLED_COMMAND_SENTINEL);
+}
+function menuInvocation(push, sessionId) {
+  return {
+    ...sessionId !== void 0 ? { sessionId } : {},
+    notify(message, kind) {
+      push(
+        {
+          command: ANTIGRAVITY_MENU_COMMAND,
+          notify: { message, kind: kind ?? "info" }
+        },
+        sessionId
+      );
+    }
+  };
+}
+function createAntigravityCommandExecuteBefore(options) {
+  const connection = options.connection ?? {
+    isTuiConnected
+  };
+  return async (input2) => {
+    if (input2.command !== ANTIGRAVITY_MENU_COMMAND) return;
+    const opening = await options.open(input2.sessionID);
+    if (opening.kind === "menu") {
+      options.push(opening.payload, input2.sessionID);
+    } else {
+      options.push(
+        {
+          command: ANTIGRAVITY_MENU_COMMAND,
+          notify: { message: opening.message, kind: "warning" }
+        },
+        input2.sessionID
+      );
+    }
+    if (!connection.isTuiConnected(input2.sessionID)) {
+      await sendIgnoredMessage(
+        options.client,
+        input2.sessionID,
+        opening.kind === "menu" ? "The Antigravity menu opens in the OpenCode terminal interface." : opening.message
       );
     }
     throwHandledCommandSentinel();
@@ -44935,483 +45469,139 @@ function createRequestExecutor(deps) {
             response,
             cancellation
           );
-          inFlight.add(retained.settled);
-          void retained.settled.then(() => inFlight.delete(retained.settled));
-          return redactCredentialResponse(
-            preserveResponseMetadata2(retained.response, response),
-            [...selectedCredentials]
-          );
-        },
-        (error) => {
-          cancellation.release();
-          throw redactCredentialError(error, [...selectedCredentials]);
-        }
-      ).catch((error) => {
-        cancellation.release();
-        throw redactCredentialError(error, [...selectedCredentials]);
-      });
-      inFlight.add(pending);
-      void pending.then(
-        () => inFlight.delete(pending),
-        () => inFlight.delete(pending)
-      );
-      return pending;
-    },
-    retire: retire2,
-    dispose
-  };
-}
-function extractRateLimitBodyInfo(body) {
-  if (!body || typeof body !== "object") return { retryDelayMs: null };
-  const error = body.error;
-  const message = error && typeof error === "object" ? error.message : void 0;
-  const details = error && typeof error === "object" ? error.details : void 0;
-  let reason;
-  if (Array.isArray(details)) {
-    for (const detail of details) {
-      if (!detail || typeof detail !== "object") continue;
-      const type = detail["@type"];
-      if (typeof type === "string" && type.includes("google.rpc.ErrorInfo")) {
-        const detailReason = detail.reason;
-        if (typeof detailReason === "string") {
-          reason = detailReason;
-          break;
-        }
-      }
-    }
-    for (const detail of details) {
-      if (!detail || typeof detail !== "object") continue;
-      const type = detail["@type"];
-      if (typeof type === "string" && type.includes("google.rpc.RetryInfo")) {
-        const retryDelay = detail.retryDelay;
-        if (typeof retryDelay === "string") {
-          const retryDelayMs = parseDurationToMs(retryDelay);
-          if (retryDelayMs !== null) {
-            return { retryDelayMs, message, reason };
-          }
-        }
-      }
-    }
-    for (const detail of details) {
-      if (!detail || typeof detail !== "object") continue;
-      const metadata = detail.metadata;
-      if (metadata && typeof metadata === "object") {
-        const quotaResetDelay = metadata.quotaResetDelay;
-        const quotaResetTime = metadata.quotaResetTimeStamp;
-        if (typeof quotaResetDelay === "string") {
-          const quotaResetDelayMs = parseDurationToMs(quotaResetDelay);
-          if (quotaResetDelayMs !== null) {
-            return {
-              retryDelayMs: quotaResetDelayMs,
-              message,
-              quotaResetTime,
-              reason
-            };
-          }
-        }
-      }
-    }
-  }
-  if (message) {
-    const afterMatch = message.match(/reset after\s+([0-9hms.]+)/i);
-    const rawDuration = afterMatch?.[1];
-    if (rawDuration) {
-      const parsed = parseDurationToMs(rawDuration);
-      if (parsed !== null) {
-        return { retryDelayMs: parsed, message, reason };
-      }
-    }
-  }
-  return { retryDelayMs: null, message, reason };
-}
-function parseDurationToMs(duration) {
-  const simpleMatch = duration.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/i);
-  if (simpleMatch) {
-    const value = parseFloat(simpleMatch[1]);
-    const unit = (simpleMatch[2] || "s").toLowerCase();
-    switch (unit) {
-      case "h":
-        return value * 3600 * 1e3;
-      case "m":
-        return value * 60 * 1e3;
-      case "s":
-        return value * 1e3;
-      case "ms":
-        return value;
-      default:
-        return value * 1e3;
-    }
-  }
-  const compoundRegex = /(\d+(?:\.\d+)?)(h|m(?!s)|s|ms)/gi;
-  let totalMs = 0;
-  let matchFound = false;
-  let match = null;
-  while (true) {
-    match = compoundRegex.exec(duration);
-    if (match === null) break;
-    matchFound = true;
-    const value = parseFloat(match[1]);
-    const unit = match[2]?.toLowerCase();
-    switch (unit) {
-      case "h":
-        totalMs += value * 3600 * 1e3;
-        break;
-      case "m":
-        totalMs += value * 60 * 1e3;
-        break;
-      case "s":
-        totalMs += value * 1e3;
-        break;
-      case "ms":
-        totalMs += value;
-        break;
-    }
-  }
-  return matchFound ? totalMs : null;
-}
-
-// src/plugin/shared/vault-request-credentials.ts
-function vaultAccountRows(routes) {
-  return routes.map((route, index) => ({
-    index,
-    enabled: true,
-    lastUsed: 0,
-    rateLimitResetTimes: {},
-    touchedForQuota: {},
-    route,
-    ...route.email !== void 0 ? { email: route.email } : {}
-  }));
-}
-function vaultAccountRowKey(row) {
-  return JSON.stringify([
-    row.route.routeId,
-    row.route.credentialId,
-    row.route.accountIdentity
-  ]);
-}
-function refreshVaultAccountRow(prior, fresh) {
-  prior.route = fresh.route;
-  if (fresh.email === void 0) delete prior.email;
-  else prior.email = fresh.email;
-}
-var VaultSendGrant = class {
-  credentialId;
-  accountIdentity;
-  recordVersion;
-  projectId;
-  report401;
-  constructor(admission, report) {
-    Object.defineProperty(this, "accessToken", {
-      value: admission.accessToken,
-      enumerable: false
-    });
-    this.credentialId = admission.credentialId;
-    this.accountIdentity = admission.accountIdentity;
-    this.recordVersion = admission.recordVersion;
-    this.projectId = admission.projectId;
-    this.report401 = report;
-  }
-};
-function createVaultRequestCredentials(source, onAdmitted) {
-  return {
-    domain: "vault",
-    async admit({ account, signal }) {
-      const admission = await source.admit(account.route, signal);
-      if (onAdmitted)
-        onAdmitted.admitted(account, onAdmitted.source.attribution(admission));
-      return new VaultSendGrant(
-        admission,
-        (status) => source.reportServedStatus(admission, status)
-      );
-    }
-  };
-}
-function present4(value) {
-  return value === null ? void 0 : value;
-}
-function storedResets(resets) {
-  const stored = {};
-  for (const [key, at] of Object.entries(resets))
-    if (typeof at === "number") stored[key] = at;
-  return stored;
-}
-function cachedQuotaOf(quota) {
-  const groups = quota.cachedQuota;
-  if (groups == null) return void 0;
-  const out = {};
-  for (const name of ["gemini", "non-gemini"]) {
-    const group = groups[name];
-    if (group === void 0) continue;
-    out[name] = {
-      modelCount: group.modelCount,
-      ...group.remainingFraction != null ? { remainingFraction: group.remainingFraction } : {},
-      ...group.resetTime != null ? { resetTime: group.resetTime } : {},
-      ...group.windows != null ? {
-        windows: group.windows.map((window) => ({
-          window: window.window,
-          remainingFraction: window.remainingFraction,
-          resetTime: window.resetTime
-        }))
-      } : {}
-    };
-  }
-  return out;
-}
-function durableSelectionOf(row) {
-  return {
-    lastUsed: row.lastUsed,
-    ...row.lastSwitchReason !== void 0 ? { lastSwitchReason: row.lastSwitchReason } : {},
-    rateLimitResetTimes: storedResets(row.rateLimitResetTimes),
-    ...row.coolingDownUntil !== void 0 ? { coolingDownUntil: row.coolingDownUntil } : {},
-    ...row.cooldownReason !== void 0 ? { cooldownReason: row.cooldownReason } : {},
-    ...row.fingerprint !== void 0 ? { fingerprint: structuredClone(row.fingerprint) } : {},
-    ...row.fingerprintHistory !== void 0 ? { fingerprintHistory: structuredClone(row.fingerprintHistory) } : {},
-    ...row.verificationRequired !== void 0 ? { verificationRequired: row.verificationRequired } : {},
-    ...row.verificationRequiredAt !== void 0 ? { verificationRequiredAt: row.verificationRequiredAt } : {},
-    ...row.verificationRequiredReason !== void 0 ? { verificationRequiredReason: row.verificationRequiredReason } : {},
-    ...row.verificationUrl !== void 0 ? { verificationUrl: row.verificationUrl } : {},
-    ...row.accountIneligible !== void 0 ? { accountIneligible: row.accountIneligible } : {},
-    ...row.accountIneligibleAt !== void 0 ? { accountIneligibleAt: row.accountIneligibleAt } : {},
-    ...row.accountIneligibleReason !== void 0 ? { accountIneligibleReason: row.accountIneligibleReason } : {},
-    ...row.eligibilityStateUpdatedAt !== void 0 ? { eligibilityStateUpdatedAt: row.eligibilityStateUpdatedAt } : {},
-    ...row.dailyRequestCounts !== void 0 ? { dailyRequestCounts: { ...row.dailyRequestCounts } } : {}
-  };
-}
-function applyDurableSelection(row, metadata) {
-  row.lastUsed = metadata.lastUsed;
-  const reason = present4(metadata.lastSwitchReason);
-  if (reason !== void 0) row.lastSwitchReason = reason;
-  const resets = present4(metadata.rateLimitResetTimes);
-  if (resets !== void 0) {
-    const copy = {};
-    for (const [key, at] of Object.entries(resets))
-      if (typeof at === "number") copy[key] = at;
-    row.rateLimitResetTimes = copy;
-  }
-  const until = present4(metadata.coolingDownUntil);
-  const cooldownReason = present4(metadata.cooldownReason);
-  if (until !== void 0 && cooldownReason !== void 0) {
-    row.coolingDownUntil = until;
-    row.cooldownReason = cooldownReason;
-  }
-  const fingerprint = present4(metadata.fingerprint);
-  if (fingerprint !== void 0) row.fingerprint = structuredClone(fingerprint);
-  const history = present4(metadata.fingerprintHistory);
-  if (history !== void 0) row.fingerprintHistory = structuredClone(history);
-  const verification = present4(metadata.verificationRequired);
-  if (verification !== void 0) row.verificationRequired = verification;
-  const verificationAt = present4(metadata.verificationRequiredAt);
-  if (verificationAt !== void 0) row.verificationRequiredAt = verificationAt;
-  const verificationReason = present4(metadata.verificationRequiredReason);
-  if (verificationReason !== void 0)
-    row.verificationRequiredReason = verificationReason;
-  const verificationUrl = present4(metadata.verificationUrl);
-  if (verificationUrl !== void 0) row.verificationUrl = verificationUrl;
-  const ineligible = present4(metadata.accountIneligible);
-  if (ineligible !== void 0) row.accountIneligible = ineligible;
-  const ineligibleAt = present4(metadata.accountIneligibleAt);
-  if (ineligibleAt !== void 0) row.accountIneligibleAt = ineligibleAt;
-  const ineligibleReason = present4(metadata.accountIneligibleReason);
-  if (ineligibleReason !== void 0)
-    row.accountIneligibleReason = ineligibleReason;
-  const eligibilityAt = present4(metadata.eligibilityStateUpdatedAt);
-  if (eligibilityAt !== void 0) row.eligibilityStateUpdatedAt = eligibilityAt;
-  const counts = present4(metadata.dailyRequestCounts);
-  if (counts !== void 0) row.dailyRequestCounts = { ...counts };
-}
-function stateBelongsTo(state, row) {
-  return state.observed.routeId === row.route.routeId && state.observed.credentialId === row.route.credentialId;
-}
-function createVaultSelectionState(options) {
-  const now = options.now ?? (() => Date.now());
-  const attributions = /* @__PURE__ */ new WeakMap();
-  const changed = /* @__PURE__ */ new Set();
-  let writing = Promise.resolve();
-  const mark = (row) => {
-    changed.add(row);
-  };
-  const report = (error) => {
-    try {
-      options.onError?.(error);
-    } catch {
-    }
-  };
-  const writeRow = async (row) => {
-    const attribution = attributions.get(row);
-    if (attribution === void 0) return;
-    changed.delete(row);
-    const selection = durableSelectionOf(row);
-    try {
-      await options.source.commitState(attribution, (current) => ({
-        metadata: {
-          ...current?.metadata ?? { addedAt: now() },
-          ...selection
-        },
-        ...current?.quota !== void 0 ? { quota: current.quota } : {},
-        ...current?.extensions !== void 0 ? { extensions: current.extensions } : {}
-      }));
-    } catch (error) {
-      report(error);
-    }
-  };
-  const flush = () => {
-    writing = writing.then(async () => {
-      for (const row of [...changed]) await writeRow(row);
-    });
-    return writing;
-  };
-  return {
-    sink: {
-      rateLimit: mark,
-      cooldown: mark,
-      switched: mark,
-      lastUsed: mark,
-      usage: mark,
-      accessVerdict: mark,
-      fingerprint: mark,
-      requestSave: () => {
-        void flush();
-      }
-    },
-    admitted(row, attribution) {
-      attributions.set(row, attribution);
-    },
-    async hydrate(rows) {
-      const file = await options.readState();
-      for (const row of rows) {
-        const identity = row.route.accountIdentity;
-        if (!Object.hasOwn(file.accounts, identity)) continue;
-        const state = file.accounts[identity];
-        if (state === void 0 || !stateBelongsTo(state, row)) continue;
-        if (state.metadata !== void 0)
-          applyDurableSelection(row, state.metadata);
-        if (state.quota !== void 0) {
-          const cached = cachedQuotaOf(state.quota);
-          if (cached !== void 0) row.cachedQuota = cached;
-          const updatedAt = present4(state.quota.cachedQuotaUpdatedAt);
-          if (updatedAt !== void 0) row.cachedQuotaUpdatedAt = updatedAt;
+          inFlight.add(retained.settled);
+          void retained.settled.then(() => inFlight.delete(retained.settled));
+          return redactCredentialResponse(
+            preserveResponseMetadata2(retained.response, response),
+            [...selectedCredentials]
+          );
+        },
+        (error) => {
+          cancellation.release();
+          throw redactCredentialError(error, [...selectedCredentials]);
         }
-      }
+      ).catch((error) => {
+        cancellation.release();
+        throw redactCredentialError(error, [...selectedCredentials]);
+      });
+      inFlight.add(pending);
+      void pending.then(
+        () => inFlight.delete(pending),
+        () => inFlight.delete(pending)
+      );
+      return pending;
     },
-    flush,
-    recordQuota(attribution, quota) {
-      return options.source.commitState(attribution, (current) => ({
-        ...current?.metadata !== void 0 ? { metadata: current.metadata } : {},
-        quota,
-        ...current?.extensions !== void 0 ? { extensions: current.extensions } : {}
-      }));
-    }
+    retire: retire2,
+    dispose
   };
 }
-function createVaultAccountPool(options) {
-  const { source, durable } = options;
-  const state = durable ? createVaultSelectionState({
-    source: durable.source,
-    readState: durable.readState,
-    ...options.now ? { now: options.now } : {},
-    ...durable.onError ? { onError: durable.onError } : {}
-  }) : void 0;
-  const selector = new AccountSelector({
-    ...options.now ? { now: options.now } : {},
-    ...state ? { sink: state.sink } : {}
-  });
-  const credentials = createVaultRequestCredentials(
-    source,
-    state && durable ? {
-      source: durable.source,
-      admitted: (row, attribution) => state.admitted(row, attribution)
-    } : void 0
-  );
-  const rowsFromSource = async () => {
-    const rows = vaultAccountRows(source.routes());
-    if (state) {
-      const kept = new Set(selector.rows.map(vaultAccountRowKey));
-      const added = rows.filter((row) => !kept.has(vaultAccountRowKey(row)));
-      if (added.length > 0) await state.hydrate(added);
+function extractRateLimitBodyInfo(body) {
+  if (!body || typeof body !== "object") return { retryDelayMs: null };
+  const error = body.error;
+  const message = error && typeof error === "object" ? error.message : void 0;
+  const details = error && typeof error === "object" ? error.details : void 0;
+  let reason;
+  if (Array.isArray(details)) {
+    for (const detail of details) {
+      if (!detail || typeof detail !== "object") continue;
+      const type = detail["@type"];
+      if (typeof type === "string" && type.includes("google.rpc.ErrorInfo")) {
+        const detailReason = detail.reason;
+        if (typeof detailReason === "string") {
+          reason = detailReason;
+          break;
+        }
+      }
     }
-    return rows;
-  };
-  const replace = async () => {
-    selector.replaceAccounts(await rowsFromSource(), {
-      keyOf: vaultAccountRowKey,
-      refresh: refreshVaultAccountRow
-    });
-  };
-  let firstRead = null;
-  const readOnce = () => {
-    firstRead ??= (async () => {
-      await source.refresh();
-      selector.resetAccounts(await rowsFromSource());
-    })().catch((error) => {
-      firstRead = null;
-      throw error;
-    });
-    return firstRead;
-  };
-  return {
-    selector,
-    credentials,
-    state,
-    async sync() {
-      const pending = firstRead;
-      await readOnce();
-      if (pending !== null) await replace();
-    },
-    async refresh() {
-      await readOnce();
-      await source.refresh();
-      await replace();
-    },
-    flush: async () => {
-      await state?.flush();
+    for (const detail of details) {
+      if (!detail || typeof detail !== "object") continue;
+      const type = detail["@type"];
+      if (typeof type === "string" && type.includes("google.rpc.RetryInfo")) {
+        const retryDelay = detail.retryDelay;
+        if (typeof retryDelay === "string") {
+          const retryDelayMs = parseDurationToMs(retryDelay);
+          if (retryDelayMs !== null) {
+            return { retryDelayMs, message, reason };
+          }
+        }
+      }
     }
-  };
-}
-function vaultQuotaState(quota, at) {
-  const cachedQuota = {};
-  for (const [name, group] of Object.entries(quota.groups)) {
-    if (group === void 0) continue;
-    cachedQuota[name] = {
-      modelCount: group.modelCount,
-      ...group.remainingFraction !== void 0 ? { remainingFraction: group.remainingFraction } : {},
-      ...group.resetTime !== void 0 ? { resetTime: group.resetTime } : {},
-      ...group.windows !== void 0 ? { windows: group.windows.map((window) => ({ ...window })) } : {}
-    };
-  }
-  return { schemaVersion: 1, cachedQuota, cachedQuotaUpdatedAt: at };
-}
-async function checkVaultQuota(input2) {
-  const state = input2.pool.state;
-  const rows = [...input2.pool.selector.rows];
-  const now = input2.now ?? (() => Date.now());
-  let checked = 0;
-  for (const row of rows) {
-    if (input2.signal.aborted || state === void 0) break;
-    try {
-      const answer = await input2.fetchReading(row.route, input2.signal);
-      const attribution = answer.quotaAttribution;
-      if (attribution === void 0 || answer.quota.error !== void 0)
-        continue;
-      const reading = vaultQuotaState(answer.quota, now());
-      const result = await state.recordQuota(attribution, reading);
-      if (result.status !== "written") continue;
-      checked += 1;
-      const live = input2.pool.selector.rows.find(
-        (candidate) => candidate.route.routeId === attribution.routeId && candidate.route.credentialId === attribution.credentialId && candidate.route.accountIdentity === attribution.accountIdentity
-      );
-      if (live !== void 0) {
-        const cached = cachedQuotaOf(reading);
-        if (cached !== void 0) live.cachedQuota = cached;
-        live.cachedQuotaUpdatedAt = reading.cachedQuotaUpdatedAt ?? void 0;
+    for (const detail of details) {
+      if (!detail || typeof detail !== "object") continue;
+      const metadata = detail.metadata;
+      if (metadata && typeof metadata === "object") {
+        const quotaResetDelay = metadata.quotaResetDelay;
+        const quotaResetTime = metadata.quotaResetTimeStamp;
+        if (typeof quotaResetDelay === "string") {
+          const quotaResetDelayMs = parseDurationToMs(quotaResetDelay);
+          if (quotaResetDelayMs !== null) {
+            return {
+              retryDelayMs: quotaResetDelayMs,
+              message,
+              quotaResetTime,
+              reason
+            };
+          }
+        }
       }
-    } catch (error) {
-      try {
-        input2.onError?.(error);
-      } catch {
+    }
+  }
+  if (message) {
+    const afterMatch = message.match(/reset after\s+([0-9hms.]+)/i);
+    const rawDuration = afterMatch?.[1];
+    if (rawDuration) {
+      const parsed = parseDurationToMs(rawDuration);
+      if (parsed !== null) {
+        return { retryDelayMs: parsed, message, reason };
       }
     }
   }
-  return { checked, notChecked: rows.length - checked };
+  return { retryDelayMs: null, message, reason };
+}
+function parseDurationToMs(duration) {
+  const simpleMatch = duration.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/i);
+  if (simpleMatch) {
+    const value = parseFloat(simpleMatch[1]);
+    const unit = (simpleMatch[2] || "s").toLowerCase();
+    switch (unit) {
+      case "h":
+        return value * 3600 * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "s":
+        return value * 1e3;
+      case "ms":
+        return value;
+      default:
+        return value * 1e3;
+    }
+  }
+  const compoundRegex = /(\d+(?:\.\d+)?)(h|m(?!s)|s|ms)/gi;
+  let totalMs = 0;
+  let matchFound = false;
+  let match = null;
+  while (true) {
+    match = compoundRegex.exec(duration);
+    if (match === null) break;
+    matchFound = true;
+    const value = parseFloat(match[1]);
+    const unit = match[2]?.toLowerCase();
+    switch (unit) {
+      case "h":
+        totalMs += value * 3600 * 1e3;
+        break;
+      case "m":
+        totalMs += value * 60 * 1e3;
+        break;
+      case "s":
+        totalMs += value * 1e3;
+        break;
+      case "ms":
+        totalMs += value;
+        break;
+    }
+  }
+  return matchFound ? totalMs : null;
 }
 
 // src/plugin/fetch-interceptor.ts
@@ -46514,6 +46704,7 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
       await drainSidebarWrites();
     }
   });
+  let vaultQuotaPoller;
   const vaultCustody = createOpenCodeVaultCustody({
     accountFile: resolve11(getStoragePath()),
     readHostSlot: async () => {
@@ -46524,7 +46715,10 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     // The request executor reports failed bearer authorization to Claustrum,
     // which decides whether its served credential needs replacement.
     reporterSource: "direct",
-    onAuthorityChanged: () => scheduleSidebarPublication(),
+    onAuthorityChanged: (authority) => {
+      if (authority !== "vault") vaultQuotaPoller?.abortTick();
+      scheduleSidebarPublication();
+    },
     onRosterChanged: () => scheduleSidebarPublication()
   });
   let vaultPool;
@@ -46571,6 +46765,7 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
       return manager.getAccounts().map((entry) => ({
         index: entry.index,
         label: entry.label,
+        email: entry.email,
         enabled: entry.enabled,
         current: isAccountCurrent(entry.index, activeByFamily),
         coolingDownUntil: entry.coolingDownUntil,
@@ -46598,6 +46793,7 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
       return buildSidebarMachineStateFromAccounts(
         manager?.getAccounts().map((entry) => ({
           index: entry.index,
+          email: entry.email,
           enabled: entry.enabled,
           current: active2 ? isAccountCurrent(entry.index, active2) : false,
           coolingDownUntil: entry.coolingDownUntil,
@@ -46615,23 +46811,13 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     vault: async () => {
       const { pool } = await currentVaultPool();
       await pool.sync();
-      const projection = buildSidebarMachineStateFromAccounts(
-        pool.selector.rows.map((entry) => ({
-          index: entry.index,
-          enabled: entry.enabled,
-          current: false,
-          coolingDownUntil: entry.coolingDownUntil,
-          healthScore: pool.selector.healthTracker.getScore(entry.index),
-          cachedQuota: entry.cachedQuota,
-          cachedQuotaUpdatedAt: entry.cachedQuotaUpdatedAt
-        }))
+      const projection = buildVaultSidebarProjection(
+        pool,
+        await vaultCustody.readState(),
+        dependencies.clock.now()
       );
       return {
         ...projection,
-        accounts: projection.accounts.map((account) => ({
-          ...account,
-          id: `vault-${account.id}`
-        })),
         ...projection.accounts.length === 0 ? { lastError: VAULT_ACCOUNT_REMEDY } : {}
       };
     },
@@ -46710,6 +46896,21 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     options._onPollerCreated?.(poller);
     poller.start();
     lifecycle.register({ dispose: () => poller.dispose() }, "producer");
+    vaultQuotaPoller = new BackgroundVaultQuotaRefresh({
+      intervalMs: config.background_quota_refresh_interval_minutes * 6e4,
+      sidebarStateFile: getSidebarStateFile(),
+      readAuthority,
+      currentVaultPool,
+      readProviderState: () => vaultCustody.readState(),
+      publishSidebar: () => sidebarPublisher.publish(),
+      transport: dependencies.fetchImpl,
+      logger,
+      now: dependencies.clock.now,
+      random: dependencies.clock.random
+    });
+    options._onVaultPollerCreated?.(vaultQuotaPoller);
+    vaultQuotaPoller.start();
+    lifecycle.register(vaultQuotaPoller, "producer");
   }
   const operatorSettings = createOperatorSettingsController({
     projectConfigPath: join29(directory, ".opencode", "antigravity.json"),
@@ -46833,17 +47034,21 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
                 vaultSelectors.set(key, selector);
                 return selector;
               },
-              (signal) => checkVaultQuota({
-                pool,
-                signal,
-                fetchReading: (ref, check) => fetchVaultAccountQuota({
-                  source,
-                  ref,
-                  signal: check,
-                  logger,
-                  transport: dependencies.fetchImpl
-                })
-              })
+              (signal) => checkAndPublishVaultQuota(
+                {
+                  pool,
+                  signal,
+                  now: dependencies.clock.now,
+                  fetchReading: (ref, check) => fetchVaultAccountQuota({
+                    source,
+                    ref,
+                    signal: check,
+                    logger,
+                    transport: dependencies.fetchImpl
+                  })
+                },
+                () => sidebarPublisher.publish()
+              )
             )
           })
         };
@@ -47091,10 +47296,8 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
     apply: async (request) => {
       const current = await currentMenu();
       if (current.kind === "unavailable") throw new Error(current.message);
-      const result = await current.menu.apply(
-        request,
-        menuInvocation(pushNotification, request.sessionId)
-      );
+      const invocation = menuInvocation(pushNotification, request.sessionId);
+      const result = await current.menu.apply(request, invocation);
       try {
         if (await readAuthority() === "local")
           await lifecycle.getAccountManager()?.refreshFromRepository();
@@ -47111,6 +47314,11 @@ var createAntigravityPlugin = (providerId, options = {}) => async (input2) => {
           request.sessionId
         );
       }
+      const refreshed = await currentMenu();
+      if (refreshed.kind === "menu" && refreshed.menu !== current.menu) {
+        const payload = await refreshed.menu.open(invocation);
+        return { ...result, menu: payload.menu };
+      }
       return result;
     },
     drain: drainNotifications