dsh-agy 0.2.2 → 0.2.4

package/lib/{session-KoIh3xdB.mjs → accounts-DbTTxX_z.mjs}

@@ -1,23 +1,36 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { i as proxiedFetch, n as isProxyUnreachableError } from "./proxy-DQPIwUov.mjs";
 import { createCipheriv, createDecipheriv, createHash, randomBytes, randomUUID } from "node:crypto";
-import { EnvHttpProxyAgent } from "undici";
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import lockfile from "proper-lockfile";
-//#region src/proxy.ts
+//#region src/types.ts
 /**
-* Proxy-aware fetch: respects the standard HTTP_PROXY / HTTPS_PROXY / NO_PROXY
-* environment variables (lowercase variants included) via undici's
-* EnvHttpProxyAgent. Applied per-request through the `dispatcher` option so the
-* plugin never mutates the host process's global dispatcher — DSH's own fetch
-* calls stay untouched.
+* Host-independent authentication error. The adapter maps `kind` to the DSH
+* error protocol without coupling the session or CLI layers to dsh-llm.
 */
-const agent = new EnvHttpProxyAgent();
-/** fetch() that routes through the env-configured proxy when one is set. */
-const proxiedFetch = (input, init) => fetch(input, {
-	...init,
-	dispatcher: agent
-});
+var AgyAuthError = class extends Error {
+	kind;
+	constructor(kind, message, options) {
+		super(message, options);
+		this.name = "AgyAuthError";
+		this.kind = kind;
+	}
+};
+/**
+* Enabled accounts exist, but every candidate is temporarily blocked. Kept
+* independent of dsh-llm so CLI and web entry points do not gain a host import.
+*/
+var AgyPoolBlockedError = class extends Error {
+	kind;
+	blockedUntil;
+	constructor(kind, blockedUntil) {
+		super(kind === "quota-exhausted" ? "All agy accounts have exhausted quota for the requested model family." : "All agy accounts are temporarily blocked for the requested model family.");
+		this.name = "AgyPoolBlockedError";
+		this.kind = kind;
+		this.blockedUntil = blockedUntil;
+	}
+};
 //#endregion
 //#region src/oauth/constants.ts
 /**
@@ -45,10 +58,32 @@ var constants_exports = /* @__PURE__ */ __exportAll({
 	OAUTH_USERINFO_URL: () => OAUTH_USERINFO_URL,
 	fetchAgyFirstOk: () => fetchAgyFirstOk,
 	getAgyBootstrapClientMetadata: () => getAgyBootstrapClientMetadata,
-	getAgyBootstrapUserAgent: () => getAgyBootstrapUserAgent
+	getAgyBootstrapUserAgent: () => getAgyBootstrapUserAgent,
+	resolveAgyClientCredentials: () => resolveAgyClientCredentials
 });
 const AGY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
 const AGY_CLIENT_SECRET = "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";
+/**
+* Effective OAuth client credentials: AGY_CLIENT_ID / AGY_CLIENT_SECRET env
+* overrides win when set (BYO OAuth app escape hatch, mirrors pi-antigravity);
+* otherwise the embedded public Antigravity credentials are used.
+*/
+function resolveAgyClientCredentials(overrideClientId) {
+	if (overrideClientId) {
+		if (overrideClientId === "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com") return {
+			clientId: AGY_CLIENT_ID,
+			clientSecret: AGY_CLIENT_SECRET
+		};
+		return {
+			clientId: overrideClientId,
+			clientSecret: process.env.AGY_CLIENT_SECRET || "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"
+		};
+	}
+	return {
+		clientId: process.env.AGY_CLIENT_ID || "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com",
+		clientSecret: process.env.AGY_CLIENT_SECRET || "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"
+	};
+}
 /** Required scopes. `openid` must NOT be added: it routes Google into the hanging
 * `firstparty/nativeapp` consent for this client (verified by OmniRoute). */
 const AGY_SCOPES = [
@@ -94,7 +129,10 @@ async function fetchAgyFirstOk(urlPath, init, fetchImpl = proxiedFetch) {
 		const response = await fetchImpl(`${baseEndpoint}${urlPath}`, init);
 		if (!AGY_ENDPOINT_SKIP_STATUSES.has(response.status)) return response;
 		lastSkipped = response;
-	} catch {}
+	} catch (error) {
+		const { isProxyUnreachableError } = await import("./proxy-DQPIwUov.mjs").then((n) => n.o);
+		if (isProxyUnreachableError(error)) throw error;
+	}
 	if (lastSkipped) return lastSkipped;
 	throw new Error("all agy endpoints failed");
 }
@@ -332,8 +370,10 @@ function parseOAuthErrorPayload(text) {
 /**
 * Refresh the access token for an account. `revoked` means Google rejected the
 * refresh token (`invalid_grant`) — the account must be re-authenticated.
+* For legacy accounts without a stored clientId, embedded credentials are tried
+* first with an env-override fallback before treating invalid_grant as fatal.
 */
-async function refreshAccessToken(auth) {
+async function refreshAccessToken(auth, options) {
 	const parts = parseRefreshParts(auth.refresh);
 	if (!parts.refreshToken) return {
 		type: "failed",
@@ -343,26 +383,33 @@ async function refreshAccessToken(auth) {
 			statusText: "Bad Request"
 		})
 	};
-	try {
+	const candidateIds = options?.clientId ? [options.clientId] : Array.from(new Set([AGY_CLIENT_ID, process.env.AGY_CLIENT_ID].filter((id) => Boolean(id && id.length > 0))));
+	let revokedCount = 0;
+	let transientFailure;
+	for (const currentClientId of candidateIds) try {
 		const startTime = Date.now();
+		const { clientId, clientSecret } = resolveAgyClientCredentials(currentClientId);
 		const response = await proxiedFetch(OAUTH_TOKEN_URL, {
 			method: "POST",
 			headers: { "Content-Type": "application/x-www-form-urlencoded" },
 			body: new URLSearchParams({
 				grant_type: "refresh_token",
 				refresh_token: parts.refreshToken,
-				client_id: AGY_CLIENT_ID,
-				client_secret: AGY_CLIENT_SECRET
+				client_id: clientId,
+				client_secret: clientSecret
 			})
-		});
+		}, options?.proxyUrl ? { proxyUrl: options.proxyUrl } : void 0);
 		if (!response.ok) {
 			const errorText = await response.text().catch(() => void 0);
 			const { code, description } = parseOAuthErrorPayload(errorText);
 			const details = [code, description ?? errorText].filter(Boolean).join(": ");
 			const baseMessage = `Agy token refresh failed (${response.status} ${response.statusText})`;
 			const message = details ? `${baseMessage} - ${details}` : baseMessage;
-			if (code === "invalid_grant") return { type: "revoked" };
-			return {
+			if (code === "invalid_grant") {
+				revokedCount++;
+				continue;
+			}
+			transientFailure = {
 				type: "failed",
 				error: new AgyTokenRefreshError({
 					message,
@@ -372,6 +419,7 @@ async function refreshAccessToken(auth) {
 					statusText: response.statusText
 				})
 			};
+			continue;
 		}
 		const payload = await response.json();
 		const refreshedParts = {
@@ -385,421 +433,337 @@ async function refreshAccessToken(auth) {
 				access: payload.access_token,
 				expires: calculateTokenExpiry(startTime, payload.expires_in),
 				refresh: formatRefreshParts(refreshedParts)
-			}
+			},
+			clientId
 		};
 	} catch (error) {
-		if (error instanceof AgyTokenRefreshError) throw error;
-		return {
+		const raw = error instanceof Error ? error : new Error(String(error));
+		const code = error?.code;
+		const errorCode = error?.errorCode;
+		const wrapped = new AgyTokenRefreshError({
+			message: raw.message,
+			status: 0,
+			statusText: "Network Error",
+			code: code ?? errorCode,
+			description: raw.message
+		});
+		wrapped.cause = error;
+		if (code) wrapped.code = code;
+		if (errorCode) wrapped.errorCode = errorCode;
+		transientFailure = {
 			type: "failed",
-			error: new AgyTokenRefreshError({
-				message: error instanceof Error ? error.message : "Unknown refresh error",
-				status: 0,
-				statusText: ""
-			})
+			error: wrapped
 		};
 	}
-}
-//#endregion
-//#region src/store/keyring.ts
-/**
-* Master-key management and AES-256-GCM secret codec for the account store.
-*
-* The master key lives in the DSH credentials document (`~/.dsh/.credentials.yaml`,
-* 0600) under `AGY_MASTER_KEY` so both the in-harness plugin (via
-* `ctx.credentials`) and the standalone `dsh-agy` CLI (direct file read) can
-* encrypt and decrypt the same account store.
-*/
-const MASTER_KEY_REF = "AGY_MASTER_KEY";
-const ENC_PREFIX$1 = "enc:v1:";
-/** AES-256-GCM codec; ciphertext format `enc:v1:<iv-b64>:<tag-b64>:<data-b64>`. */
-function createAesGcmCodec(key) {
-	if (key.length !== 32) throw new Error(`createAesGcmCodec: master key must be 32 bytes, got ${key.length}`);
+	if (transientFailure) return transientFailure;
+	if (revokedCount === candidateIds.length) return { type: "revoked" };
 	return {
-		encrypt(plaintext) {
-			const iv = randomBytes(12);
-			const cipher = createCipheriv("aes-256-gcm", key, iv);
-			const data = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
-			const tag = cipher.getAuthTag();
-			return `${ENC_PREFIX$1}${iv.toString("base64url")}:${tag.toString("base64url")}:${data.toString("base64url")}`;
-		},
-		decrypt(payload) {
-			if (!payload.startsWith(ENC_PREFIX$1)) throw new Error("decrypt: payload is not in encrypted format");
-			const [, , ivB64 = "", tagB64 = "", dataB64 = ""] = payload.split(":");
-			const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(ivB64, "base64url"));
-			decipher.setAuthTag(Buffer.from(tagB64, "base64url"));
-			return Buffer.concat([decipher.update(Buffer.from(dataB64, "base64url")), decipher.final()]).toString("utf8");
-		}
+		type: "failed",
+		error: new AgyTokenRefreshError({
+			message: "Token refresh failed on all candidate client IDs",
+			status: 400,
+			statusText: "Bad Request"
+		})
 	};
 }
-/** Derive a 32-byte key from an arbitrary master-key string (SHA-256). */
-function deriveKey(masterKey) {
-	return createHash("sha256").update(masterKey, "utf8").digest();
+//#endregion
+//#region src/runtime/rotation.ts
+const BACKOFF_TIERS_MS = [
+	5e3,
+	1e4,
+	2e4,
+	3e4,
+	6e4
+];
+/** Below this remaining fraction the account is treated as soft-quota-exhausted. */
+const SOFT_QUOTA_THRESHOLD = .15;
+function backoffFor(consecutiveFailures, maxJitterMs = 1e3) {
+	const index = Math.min(Math.max(consecutiveFailures, 0), BACKOFF_TIERS_MS.length - 1);
+	return (BACKOFF_TIERS_MS[index] ?? BACKOFF_TIERS_MS[BACKOFF_TIERS_MS.length - 1]) + Math.floor(Math.random() * maxJitterMs);
 }
-/** Default DSH home (`~/.dsh`), honoring `$DSH_HOME`. */
-function resolveDshHome() {
-	return process.env.DSH_HOME ? resolve(process.env.DSH_HOME) : join(homedir(), ".dsh");
+/** Whether the account is currently in a cooldown window. */
+function isCoolingDown(account, now = Date.now()) {
+	return (account.coolingDownUntil ?? 0) > now;
 }
-function homedir() {
-	return process.env.HOME ?? process.env.USERPROFILE ?? ".";
+/** Whether the requested model family on this account is rate-limited. */
+function isFamilyRateLimited(account, family, now = Date.now()) {
+	if (!family) return false;
+	const resetAt = account.rateLimitResetTimes?.[family];
+	return typeof resetAt === "number" && resetAt > now;
+}
+/** Record a rate-limit reset for one model key, retaining the latest reset time. */
+function recordRateLimit(account, modelKey, resetAtMs) {
+	const current = account.rateLimitResetTimes?.[modelKey] ?? 0;
+	account.rateLimitResetTimes = {
+		...account.rateLimitResetTimes ?? {},
+		[modelKey]: Math.max(current, resetAtMs)
+	};
+}
+/** Clear expired rate limits and cooldowns in place. */
+function clearExpiredState(account, now = Date.now()) {
+	if (account.rateLimitResetTimes) {
+		const fresh = Object.fromEntries(Object.entries(account.rateLimitResetTimes).filter(([, reset]) => reset > now));
+		account.rateLimitResetTimes = Object.keys(fresh).length > 0 ? fresh : void 0;
+	}
+	if (account.coolingDownUntil && account.coolingDownUntil <= now) {
+		account.coolingDownUntil = void 0;
+		account.cooldownReason = void 0;
+	}
+}
+/** 24h cooldown for a fully exhausted daily quota (single-account: stop hitting the wall). */
+const FULL_QUOTA_COOLDOWN_MS = 864e5;
+/** Cap for a server-reported reset time on per-minute limits (guards against bogus far-future values). */
+const MAX_RATE_LIMIT_COOLDOWN_MS = 18e5;
+/** Absolute server-reported reset in ms when it lies in the future, else undefined. */
+function parseFutureResetMs$1(resetTime, now = Date.now()) {
+	if (!resetTime) return void 0;
+	const reset = Date.parse(resetTime);
+	if (Number.isNaN(reset) || reset <= now) return void 0;
+	return reset;
 }
 /**
-* Minimal reader for the DSH credentials document: a flat YAML mapping of
-* `KEY: "value"` / `KEY: value` lines. Values are unquoted with JSON-style
-* escaping for double-quoted scalars; anything more complex fails loudly.
+* Decide what to do after one failed attempt.
+* @param kind - classified failure kind.
+* @param category - 429 sub-category when kind is rate-limit.
+* @param account - the account that failed (mutated with cooldown/rate-limit state).
+* @param consecutiveFailures - consecutive failures on this account.
+* @param retryAfterMs - server-provided retry delay when present.
+* @param resetTime - server-provided absolute reset time; cooldowns use it (capped) instead of fixed windows.
 */
-function readCredentialsDocument(file) {
-	if (!existsSync(file)) return /* @__PURE__ */ new Map();
-	const entries = /* @__PURE__ */ new Map();
-	const text = readFileSync(file, "utf8");
-	for (const line of text.split(/\r?\n/)) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("---")) continue;
-		const match = /^([A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/.exec(trimmed);
-		if (!match) continue;
-		const [, key = "", rawValue = ""] = match;
-		let value;
-		if (rawValue.startsWith("\"")) try {
-			value = JSON.parse(rawValue);
-		} catch {
-			throw new Error(`readCredentialsDocument: invalid quoted value for "${key}" in ${file}`);
+function decideRotation(kind, account, consecutiveFailures, retryAfterMs, category = "unknown", resetTime) {
+	const now = Date.now();
+	const backoffMs = backoffFor(consecutiveFailures);
+	switch (kind) {
+		case "rate-limit": {
+			if (category === "soft_rate_limit") return {
+				action: "retry",
+				backoffMs: Math.min(retryAfterMs ?? backoffMs, 3e3)
+			};
+			if (category === "quota_exhausted") {
+				const resetMs = parseFutureResetMs$1(resetTime, now);
+				const cooldownMs = resetMs !== void 0 ? Math.min(resetMs - now, FULL_QUOTA_COOLDOWN_MS) : FULL_QUOTA_COOLDOWN_MS;
+				account.coolingDownUntil = now + Math.max(cooldownMs, 6e4);
+				account.cooldownReason = "quota-exhausted";
+				return {
+					action: "cool",
+					backoffMs: Math.max(cooldownMs, 6e4)
+				};
+			}
+			const resetMs = parseFutureResetMs$1(resetTime, now);
+			const cooldownMs = resetMs !== void 0 ? Math.min(resetMs - now, MAX_RATE_LIMIT_COOLDOWN_MS) : retryAfterMs ?? 3e5;
+			return {
+				action: "rotate",
+				backoffMs: Math.max(cooldownMs, 1e3)
+			};
 		}
-		else if (rawValue.startsWith("'")) {
-			if (!rawValue.endsWith("'") || rawValue.length < 2) throw new Error(`readCredentialsDocument: unterminated single-quoted value for "${key}" in ${file}`);
-			value = rawValue.slice(1, -1).replace(/''/g, "'");
-		} else value = rawValue;
-		if (value.length === 0) continue;
-		entries.set(key, value);
+		case "auth-failure":
+			account.verificationRequired = true;
+			account.verificationRequiredAt = now;
+			account.verificationRequiredReason = "auth-failure";
+			account.enabled = false;
+			return { action: "revoke" };
+		case "network-error":
+			account.coolingDownUntil = now + backoffMs;
+			account.cooldownReason = "network-error";
+			return {
+				action: "rotate",
+				backoffMs
+			};
+		case "project-error":
+			account.coolingDownUntil = now + backoffMs;
+			account.cooldownReason = "project-error";
+			return {
+				action: "cool",
+				backoffMs
+			};
+		case "request-error": return { action: "noop" };
+		case "transient": return {
+			action: "retry",
+			backoffMs
+		};
+		case "proxy-unreachable": return {
+			action: "rotate",
+			backoffMs: Math.min(backoffMs, 1e3)
+		};
 	}
-	return entries;
 }
 /**
-* POSIX owner-only enforcement. Windows mode bits never report 0600 (and
-* chmod is a no-op there), so the check is skipped on win32; the encrypted
-* account file and credentials document remain the only defense-in-depth
-* layer on that platform.
+* Pick the next account index for rotation (round-robin across enabled,
+* non-cooling accounts; falls back to the active one when all are cooling).
 */
-function assertOwnerOnly(file) {
-	if (process.platform === "win32") return;
-	const mode = statSync(file).mode & 511;
-	if (mode !== 384) throw new Error(`dsh-agy: ${file} is readable beyond its owner (mode ${mode.toString(8)}); run "chmod 600" before starting again`);
+function pickNextAccountIndex(accounts, currentIndex, now = Date.now(), modelOrFamily) {
+	if (accounts.length <= 1) return currentIndex;
+	const enabled = accounts.map((a, i) => ({
+		account: a,
+		index: i
+	})).filter(({ account, index }) => {
+		if (index === currentIndex || account.enabled === false) return false;
+		if (isCoolingDown(account, now)) return false;
+		if (modelOrFamily && isFamilyRateLimited(account, modelOrFamily, now)) return false;
+		return true;
+	});
+	if (enabled.length === 0) return currentIndex;
+	return (enabled.find((e) => e.index > currentIndex) ?? enabled[0]).index;
 }
-/**
-* Load the master key from the DSH credentials document. Returns undefined when
-* the document or the reference is absent.
-*/
-function loadMasterKey(dshHome) {
-	const file = join(dshHome, ".credentials.yaml");
-	if (!existsSync(file)) return void 0;
-	assertOwnerOnly(file);
-	return readCredentialsDocument(file).get(MASTER_KEY_REF);
+/** Build the soft-quota cache TTL: short when low, long when healthy. */
+function computeSoftQuotaCacheTtlMs(remainingFraction, now = Date.now()) {
+	if (typeof remainingFraction !== "number") return 6e5;
+	if (remainingFraction < .15) return 6e4;
+	if (remainingFraction < .5) return 3e5;
+	return 9e5;
+}
+const DAY_MS = 864e5;
+/** Floor for remaining-time in drain-urgency scores (mirrors AuthStorage; a stale reset must not explode the score). */
+const DRAIN_FLOOR_MS = 6e4;
+/** Map a model id to its backend quota counter family (OMP getAntigravityCounterKeyForModel). */
+function modelFamilyOf(modelId) {
+	if (!modelId) return void 0;
+	const id = modelId.toLowerCase();
+	if (id.startsWith("claude-")) return "anthropic";
+	if (id.startsWith("gemini-") || id.startsWith("gemma-")) return "google";
+	if (id.startsWith("gpt-") || id.startsWith("openai/")) return "openai";
+}
+/** Quota-cache key for a request: the model's family, or the unknown bucket. */
+function familyKeyOf(modelId) {
+	return modelFamilyOf(modelId) ?? "unknown";
+}
+function earliestResetTime(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	const ta = Date.parse(a);
+	const tb = Date.parse(b);
+	if (Number.isNaN(ta)) return b;
+	if (Number.isNaN(tb)) return a;
+	return ta <= tb ? a : b;
 }
 /**
-* Generate and persist a fresh master key (0600) in the DSH credentials document.
-*
-* Append-only + atomic rename: the DSH credentials service owns this file and
-* preserves comments and the formatting of untouched entries (and may hold
-* YAML constructs this minimal reader cannot parse). Rewriting the whole file
-* from our parsed view would silently drop those; appending keeps them.
+* Aggregate a fetchAvailableModels response into per-family quota records:
+* the family's remaining fraction is its most-pressured model's, and the
+* reset time is the earliest across the family (the bottleneck resets first).
 */
-function persistMasterKey(dshHome, masterKey) {
-	const file = join(dshHome, ".credentials.yaml");
-	mkdirSync(dirname(file), { recursive: true });
-	const existingText = existsSync(file) ? readFileSync(file, "utf8") : "";
-	if (existingText.length > 0 && readCredentialsDocument(file).has("AGY_MASTER_KEY")) throw new Error(`persistMasterKey: ${MASTER_KEY_REF} already exists in ${file}`);
-	const entry = `${MASTER_KEY_REF}: ${JSON.stringify(masterKey)}`;
-	const next = existingText.length > 0 && !existingText.endsWith("\n") ? `${existingText}\n${entry}\n` : `${existingText}${entry}\n`;
-	const tmp = `${file}.tmp-masterkey`;
-	writeFileSync(tmp, next, { mode: 384 });
-	renameSync(tmp, file);
+function ingestFamilyQuotas(discovered) {
+	const families = /* @__PURE__ */ new Map();
+	for (const [modelId, entry] of Object.entries(discovered.models ?? {})) {
+		const remaining = entry.quotaInfo?.remainingFraction;
+		if (typeof remaining !== "number" || !Number.isFinite(remaining)) continue;
+		const key = familyKeyOf(modelId);
+		const current = families.get(key);
+		const resetTime = earliestResetTime(current?.resetTime, entry.quotaInfo?.resetTime);
+		families.set(key, {
+			remainingFraction: current ? Math.min(current.remainingFraction ?? 1, remaining) : remaining,
+			...resetTime ? { resetTime } : {},
+			modelCount: (current?.modelCount ?? 0) + 1
+		});
+	}
+	return Object.fromEntries(families);
+}
+/** The quota record for one family, or the most-pressured family when the model is unknown. */
+function familyQuotaFor(account, family) {
+	const cache = account.cachedQuota ?? {};
+	if (family) return cache[family];
+	let worst;
+	for (const entry of Object.values(cache)) {
+		if (typeof entry.remainingFraction !== "number") continue;
+		if (!worst || entry.remainingFraction < (worst.remainingFraction ?? 1)) worst = entry;
+	}
+	return worst;
+}
+/** Whether the account's quota cache needs a refresh (missing, or past its health-based TTL). */
+function isQuotaStale(account, now = Date.now()) {
+	if (!account.cachedQuota || !account.cachedQuotaUpdatedAt) return true;
+	const ttl = computeSoftQuotaCacheTtlMs(familyQuotaFor(account)?.remainingFraction);
+	return now - account.cachedQuotaUpdatedAt > ttl;
+}
+/** Whether the requested family on this account is soft-quota-exhausted (below the pre-check threshold). */
+function isFamilyDrained(account, family, now = Date.now()) {
+	const quota = familyQuotaFor(account, family);
+	if (!quota || typeof quota.remainingFraction !== "number") return false;
+	if (quota.resetTime) {
+		const reset = Date.parse(quota.resetTime);
+		if (!Number.isNaN(reset) && reset <= now) return false;
+	}
+	return quota.remainingFraction < SOFT_QUOTA_THRESHOLD;
 }
 /**
-* Resolve (load or create) the master key for a dsh home, then build the codec.
-* Creating a key writes the credentials document; read-only setups should call
-* {@link loadMasterKey} first and surface a friendly error instead.
+* Required drain rate: headroomFraction / remainingHours — how fast the
+* family's remaining quota must be consumed to avoid expiring unused at its
+* reset (mirrors AuthStorage.#computeWindowRequiredDrain with a daily window).
 */
-function resolveMasterKeyCodec(dshHome) {
-	let masterKey = loadMasterKey(dshHome);
-	let created = false;
-	if (!masterKey) {
-		masterKey = randomBytes(32).toString("hex");
-		persistMasterKey(dshHome, masterKey);
-		created = true;
+function requiredDrainFor(quota, now = Date.now()) {
+	const remaining = quota?.remainingFraction;
+	if (typeof remaining !== "number" || !Number.isFinite(remaining)) return 0;
+	const headroom = Math.min(Math.max(remaining, 0), 1);
+	if (headroom <= 0) return 0;
+	let remainingMs = DAY_MS;
+	const resetTime = quota?.resetTime;
+	if (resetTime) {
+		const resetAt = Date.parse(resetTime);
+		if (!Number.isNaN(resetAt)) remainingMs = Math.min(remainingMs, Math.max(resetAt - now, 0));
 	}
-	return {
-		codec: createAesGcmCodec(deriveKey(masterKey)),
-		created
-	};
+	return headroom / (Math.max(remainingMs, DRAIN_FLOOR_MS) / 36e5);
 }
-const ENC_PREFIX = "enc:v1:";
-const properFileLock = { async withLock(file, fn) {
-	const release = await lockfile.lock(file, {
-		stale: 3e4,
-		update: 1e4,
-		retries: {
-			retries: 10,
-			factor: 1.5,
-			minTimeout: 50,
-			maxTimeout: 2e3
+function parseFutureResetMs(resetTime, now) {
+	if (!resetTime) return void 0;
+	const reset = Date.parse(resetTime);
+	if (Number.isNaN(reset) || reset <= now) return void 0;
+	return reset;
+}
+/**
+* Rank pool candidates for one request, mirroring AuthStorage's antigravity
+* ordering: unblocked first (earliest unblock time among blocked), hot windows
+* last, measured usage before unmeasured, required-drain descending, then
+* used-fraction ascending. Ties preserve the rotation order seeded from
+* `startIndex` so an unmeasured pool keeps the active-account bias.
+*/
+function rankPoolCandidates(entries, modelId, now = Date.now(), startIndex = 0) {
+	const family = modelFamilyOf(modelId);
+	const activePos = entries.findIndex((e) => e.index === startIndex);
+	const clampedStart = activePos >= 0 ? activePos : 0;
+	const candidates = (entries.length === 0 ? [] : [...entries.slice(clampedStart), ...entries.slice(0, clampedStart)]).map(({ account, index }, orderPos) => {
+		const quota = familyQuotaFor(account, family);
+		const remaining = quota?.remainingFraction;
+		const used = typeof remaining === "number" ? Math.min(Math.max(1 - remaining, 0), 1) : void 0;
+		let blockedUntil = null;
+		if (account.coolingDownUntil && account.coolingDownUntil > now) blockedUntil = account.coolingDownUntil;
+		const familyLimit = account.rateLimitResetTimes?.[familyKeyOf(modelId)];
+		if (familyLimit !== void 0 && familyLimit > now) blockedUntil = blockedUntil === null ? familyLimit : Math.max(blockedUntil, familyLimit);
+		if (blockedUntil === null && quota && typeof remaining === "number" && remaining <= 0) {
+			const resetMs = parseFutureResetMs(quota.resetTime, now);
+			if (resetMs !== void 0) blockedUntil = resetMs;
 		}
+		return {
+			account,
+			index,
+			orderPos,
+			blockedUntil,
+			usedFraction: used,
+			requiredDrain: requiredDrainFor(quota, now),
+			hot: used !== void 0 && used >= .85,
+			measured: used !== void 0
+		};
 	});
-	try {
-		return await fn();
-	} finally {
-		await release();
-	}
-} };
-function isEncrypted(value) {
-	return value.startsWith(ENC_PREFIX);
-}
-/** Decrypt one account's refresh field when encrypted; plaintext passes through (legacy). */
-function decryptAccount(account, codec) {
-	if (isEncrypted(account.refresh)) return {
-		...account,
-		refresh: codec.decrypt(account.refresh)
-	};
-	return account;
-}
-/** Encrypt one account's refresh field (plaintext stays plaintext if no codec change). */
-function encryptAccount(account, codec) {
-	if (!isEncrypted(account.refresh)) return {
-		...account,
-		refresh: codec.encrypt(account.refresh)
-	};
-	return account;
-}
-function decryptStorage(storage, codec) {
-	return {
-		...storage,
-		accounts: storage.accounts.map((a) => decryptAccount(a, codec))
-	};
-}
-function encryptStorage(storage, codec) {
-	return {
-		...storage,
-		accounts: storage.accounts.map((a) => encryptAccount(a, codec))
-	};
-}
-function migrateV1ToV2(v1) {
-	return {
-		version: 2,
-		accounts: v1.accounts.map((acc) => ({
-			email: acc.email,
-			refreshToken: acc.refreshToken,
-			projectId: acc.projectId,
-			managedProjectId: acc.managedProjectId,
-			addedAt: acc.addedAt,
-			lastUsed: acc.lastUsed,
-			lastSwitchReason: acc.lastSwitchReason,
-			rateLimitResetTimes: acc.isRateLimited && acc.rateLimitResetTime ? { default: acc.rateLimitResetTime } : void 0
-		})),
-		activeIndex: v1.activeIndex
-	};
-}
-function migrateV2ToV3(v2) {
-	return {
-		version: 3,
-		accounts: v2.accounts.map((acc) => ({
-			email: acc.email,
-			refresh: `${acc.refreshToken}|${acc.projectId ?? ""}|${acc.managedProjectId ?? ""}`,
-			projectId: acc.projectId,
-			managedProjectId: acc.managedProjectId,
-			addedAt: acc.addedAt,
-			lastUsed: acc.lastUsed,
-			enabled: true,
-			lastSwitchReason: acc.lastSwitchReason,
-			rateLimitResetTimes: acc.rateLimitResetTimes
-		})),
-		activeIndex: v2.activeIndex
-	};
-}
-function migrateV3ToV4(v3) {
-	return {
-		version: 4,
-		accounts: v3.accounts,
-		activeIndex: v3.activeIndex
-	};
-}
-function migrateStorage(raw) {
-	switch (raw.version) {
-		case 1: return migrateStorage(migrateV1ToV2(raw));
-		case 2: return migrateStorage(migrateV2ToV3(raw));
-		case 3: return migrateStorage(migrateV3ToV4(raw));
-		case 4: return raw;
-		default: throw new Error(`migrateStorage: unsupported storage version ${raw.version}`);
-	}
-}
-var JsonAccountStore = class {
-	file;
-	codec;
-	lock;
-	constructor(options) {
-		this.file = options.file;
-		this.codec = options.codec;
-		this.lock = options.lock ?? properFileLock;
-	}
-	/**
-	* Ensure the store document exists before locking: proper-lockfile resolves
-	* the target's realpath and fails with ENOENT when it is absent.
-	*/
-	ensureFile() {
-		if (existsSync(this.file)) return;
-		mkdirSync(dirname(this.file), { recursive: true });
-		const tmp = `${this.file}.tmp-init`;
-		writeFileSync(tmp, JSON.stringify({
-			version: 4,
-			accounts: [],
-			activeIndex: 0
-		}) + "\n", { mode: 384 });
-		renameSync(tmp, this.file);
-	}
-	async load() {
-		let text;
-		try {
-			text = readFileSync(this.file, "utf8");
-		} catch (error) {
-			if (error.code === "ENOENT") return {
-				version: 4,
-				accounts: [],
-				activeIndex: 0
-			};
-			throw error;
-		}
-		assertOwnerOnly(this.file);
-		return decryptStorage(migrateStorage(JSON.parse(text)), this.codec);
-	}
-	async save(storage) {
-		const encrypted = encryptStorage(storage, this.codec);
-		mkdirSync(dirname(this.file), { recursive: true });
-		const tmp = `${this.file}.tmp`;
-		writeFileSync(tmp, JSON.stringify(encrypted, null, 2) + "\n", { mode: 384 });
-		renameSync(tmp, this.file);
-	}
-	async mutate(fn) {
-		this.ensureFile();
-		return this.lock.withLock(this.file, async () => {
-			const storage = await this.load();
-			const result = await fn(storage);
-			await this.save(storage);
-			return result;
-		});
-	}
-};
-/** Pick the active account, falling back to the first enabled one. */
-function resolveActiveAccount(storage) {
-	const accounts = storage.accounts;
-	if (accounts.length === 0) return void 0;
-	const active = accounts[storage.activeIndex];
-	if (active && active.enabled !== false) return {
-		account: active,
-		index: storage.activeIndex
-	};
-	const fallbackIndex = accounts.findIndex((a) => a.enabled !== false);
-	if (fallbackIndex === -1) return void 0;
-	return {
-		account: accounts[fallbackIndex],
-		index: fallbackIndex
-	};
-}
-//#endregion
-//#region src/runtime/rotation.ts
-const BACKOFF_TIERS_MS = [
-	5e3,
-	1e4,
-	2e4,
-	3e4,
-	6e4
-];
-function backoffFor(consecutiveFailures, maxJitterMs = 1e3) {
-	const index = Math.min(Math.max(consecutiveFailures, 0), BACKOFF_TIERS_MS.length - 1);
-	return (BACKOFF_TIERS_MS[index] ?? BACKOFF_TIERS_MS[BACKOFF_TIERS_MS.length - 1]) + Math.floor(Math.random() * maxJitterMs);
-}
-/** Whether the account is currently in a cooldown window. */
-function isCoolingDown(account, now = Date.now()) {
-	return (account.coolingDownUntil ?? 0) > now;
-}
-/** Clear expired rate limits and cooldowns in place. */
-function clearExpiredState(account, now = Date.now()) {
-	if (account.rateLimitResetTimes) {
-		const fresh = Object.fromEntries(Object.entries(account.rateLimitResetTimes).filter(([, reset]) => reset > now));
-		account.rateLimitResetTimes = Object.keys(fresh).length > 0 ? fresh : void 0;
-	}
-	if (account.coolingDownUntil && account.coolingDownUntil <= now) {
-		account.coolingDownUntil = void 0;
-		account.cooldownReason = void 0;
-	}
-}
-/** 24h cooldown for a fully exhausted daily quota (single-account: stop hitting the wall). */
-const FULL_QUOTA_COOLDOWN_MS = 864e5;
-/**
-* Decide what to do after one failed attempt.
-* @param kind - classified failure kind.
-* @param category - 429 sub-category when kind is rate-limit.
-* @param account - the account that failed (mutated with cooldown/rate-limit state).
-* @param consecutiveFailures - consecutive failures on this account.
-* @param retryAfterMs - server-provided retry delay when present.
-*/
-function decideRotation(kind, account, consecutiveFailures, retryAfterMs, category = "unknown") {
-	const now = Date.now();
-	const backoffMs = backoffFor(consecutiveFailures);
-	switch (kind) {
-		case "rate-limit":
-			if (category === "soft_rate_limit") return {
-				action: "retry",
-				backoffMs: Math.min(retryAfterMs ?? backoffMs, 3e3)
-			};
-			if (category === "quota_exhausted") {
-				account.coolingDownUntil = now + FULL_QUOTA_COOLDOWN_MS;
-				account.cooldownReason = void 0;
-				return {
-					action: "cool",
-					backoffMs: FULL_QUOTA_COOLDOWN_MS
-				};
-			}
-			account.coolingDownUntil = now + (retryAfterMs ?? 3e5);
-			account.cooldownReason = void 0;
-			return {
-				action: "rotate",
-				backoffMs
-			};
-		case "auth-failure":
-			account.verificationRequired = true;
-			account.verificationRequiredAt = now;
-			account.verificationRequiredReason = "auth-failure";
-			account.enabled = false;
-			return { action: "revoke" };
-		case "network-error":
-			account.coolingDownUntil = now + backoffMs;
-			account.cooldownReason = "network-error";
-			return {
-				action: "rotate",
-				backoffMs
-			};
-		case "project-error":
-			account.coolingDownUntil = now + backoffMs;
-			account.cooldownReason = "project-error";
-			return {
-				action: "cool",
-				backoffMs
-			};
-		case "request-error": return { action: "noop" };
-		case "transient": return {
-			action: "retry",
-			backoffMs
-		};
-	}
-}
-/**
-* Pick the next account index for rotation (round-robin across enabled,
-* non-cooling accounts; falls back to the active one when all are cooling).
-*/
-function pickNextAccountIndex(accounts, currentIndex, now = Date.now()) {
-	if (accounts.length <= 1) return currentIndex;
-	const enabled = accounts.map((a, i) => ({
-		account: a,
-		index: i
-	})).filter(({ account, index }) => index !== currentIndex && account.enabled !== false && !isCoolingDown(account, now));
-	if (enabled.length === 0) return currentIndex;
-	return (enabled.find((e) => e.index > currentIndex) ?? enabled[0]).index;
+	candidates.sort((left, right) => {
+		const leftBlocked = left.blockedUntil !== null;
+		const rightBlocked = right.blockedUntil !== null;
+		if (leftBlocked !== rightBlocked) return leftBlocked ? 1 : -1;
+		if (leftBlocked && rightBlocked) return (left.blockedUntil ?? 0) - (right.blockedUntil ?? 0);
+		if (left.hot !== right.hot) return left.hot ? 1 : -1;
+		if (left.measured !== right.measured) return left.measured ? -1 : 1;
+		const drain = right.requiredDrain - left.requiredDrain;
+		if (drain !== 0) return drain;
+		const usedDiff = (left.usedFraction ?? .5) - (right.usedFraction ?? .5);
+		if (usedDiff !== 0) return usedDiff;
+		return left.orderPos - right.orderPos;
+	});
+	return candidates.map(({ account, index, blockedUntil, usedFraction, requiredDrain, hot, measured }) => ({
+		account,
+		index,
+		blockedUntil,
+		usedFraction,
+		requiredDrain,
+		hot,
+		measured
+	}));
 }
 //#endregion
 //#region src/runtime/fingerprint.ts
@@ -909,6 +873,19 @@ function getRandomizedHeaders(data = getFingerprintData(), version = randomFrom(
 		"Client-Metadata": JSON.stringify({ ideType: randomFrom(data.ideTypes) })
 	};
 }
+/**
+* Deterministic fallback headers for the `stable` fingerprint mode: the first
+* entry of each pool, every call — one fixed client identity instead of
+* per-request randomization (OMP-style fixed-client posture).
+*/
+function getStableHeaders(data = getFingerprintData(), version = data.versionPool[0] ?? "") {
+	const platform = data.platforms[0] ?? "windows/amd64";
+	return {
+		"User-Agent": `antigravity/${version || "1.18.3"} ${platform}`,
+		"X-Goog-Api-Client": data.sdkClients[0] ?? "",
+		"Client-Metadata": JSON.stringify({ ideType: data.ideTypes[0] ?? "ANTIGRAVITY" })
+	};
+}
 /** Rewrite the version inside a fingerprint UA; reports whether it changed. */
 function updateFingerprintVersion(fingerprint, version) {
 	const pattern = /^(antigravity\/)([\d.]+)/;
@@ -925,10 +902,35 @@ function recordFingerprintVersion(history, fingerprint, reason) {
 		reason
 	}].slice(-5);
 }
+//#endregion
+//#region src/runtime/risk.ts
+const TRUE_VALUES = /* @__PURE__ */ new Set([
+	"1",
+	"true",
+	"yes",
+	"on"
+]);
+function envFlag(name) {
+	const value = process.env[name];
+	return value !== void 0 && TRUE_VALUES.has(value.trim().toLowerCase());
+}
+/** Global kill switch: DSH_AGY_DISABLE=1 keeps the plugin from registering anything. */
+function isAgyDisabled() {
+	return envFlag("DSH_AGY_DISABLE");
+}
+/**
+* Fingerprint strategy: `dynamic` (default, upstream behavior: per-request
+* header randomization + regeneration on repeated rate-limits) or `stable`
+* (one identity per account, never regenerated, deterministic fallback
+* headers — mirrors OMP's fixed-client posture).
+*/
+function fingerprintMode() {
+	return process.env.DSH_AGY_FINGERPRINT_MODE === "stable" ? "stable" : "dynamic";
+}
 /**
 * Resolve the impersonation headers for one request from the account's
-* persistent fingerprint (stable identity), falling back to full per-request
-* randomization when the account has no fingerprint yet.
+* persistent fingerprint (stable identity). The fallback randomizes per
+* request in `dynamic` mode and pins one identity in `stable` mode.
 */
 function impersonationHeadersFor(account) {
 	const fingerprint = account.fingerprint;
@@ -937,22 +939,29 @@ function impersonationHeadersFor(account) {
 		"X-Goog-Api-Client": fingerprint.apiClient,
 		"Client-Metadata": JSON.stringify(fingerprint.clientMetadata)
 	};
-	const randomized = getRandomizedHeaders(DEFAULT_FINGERPRINT_DATA);
+	const headers = fingerprintMode() === "stable" ? getStableHeaders(DEFAULT_FINGERPRINT_DATA) : getRandomizedHeaders(DEFAULT_FINGERPRINT_DATA);
 	return {
-		"User-Agent": randomized["User-Agent"],
-		"X-Goog-Api-Client": randomized["X-Goog-Api-Client"],
-		"Client-Metadata": randomized["Client-Metadata"]
+		"User-Agent": headers["User-Agent"],
+		"X-Goog-Api-Client": headers["X-Goog-Api-Client"],
+		"Client-Metadata": headers["Client-Metadata"]
 	};
 }
-var AgySessionManager = class {
+var AgySessionManager = class AgySessionManager {
 	store;
 	onRotate;
+	onHealthReport;
 	tokenCache = /* @__PURE__ */ new Map();
 	/** In-flight refresh promises keyed by account: concurrent requests share one refresh. */
 	refreshInFlight = /* @__PURE__ */ new Map();
+	/** In-flight quota fetches keyed by account: concurrent selections share one fetchAvailableModels call. */
+	quotaRefreshInFlight = /* @__PURE__ */ new Map();
 	failureCounts = /* @__PURE__ */ new Map();
 	/** Accounts whose request-time project discovery already failed (no retry per request). */
 	projectRetryFailed = /* @__PURE__ */ new Set();
+	/** Bound for one quota poll so selection never stalls on a hung endpoint. */
+	static QUOTA_FETCH_TIMEOUT_MS = 3e3;
+	/** Refresh the token this far ahead of expiry so a request never blocks on the token endpoint. */
+	static REFRESH_SKEW_MS = 12e4;
 	/**
 	* Session affinity (time-window approximation): DSH exposes no conversation
 	* id, so instead of pinning per session we reuse the last-used account while
@@ -964,23 +973,18 @@ var AgySessionManager = class {
 	constructor(options) {
 		this.store = options.store;
 		this.onRotate = options.onRotate;
+		this.onHealthReport = options.onHealthReport;
 	}
 	accountKey(account) {
-		return account.email ?? `idx-${account.refresh}`;
+		return account.id ?? account.email ?? `idx-${account.refresh}`;
 	}
-	/** Resolve a usable access token for the account, refreshing when expired. */
-	async accessTokenFor(account) {
-		const key = this.accountKey(account);
-		const cached = this.tokenCache.get(key);
-		if (cached && !accessTokenExpired({
-			access: cached.access,
-			expires: cached.expires,
-			refresh: account.refresh
-		})) return {
-			access: cached.access,
-			expires: cached.expires,
-			refresh: account.refresh
-		};
+	/**
+	* Refresh the account's access token (single-flight per account). A transient
+	* refresh failure keeps the cached token in place (retain-last-good): the old
+	* token stays valid until its own expiry and a later request retries the
+	* refresh. Only `invalid_grant` drops the cache.
+	*/
+	refreshToken(key, account, cached) {
 		const inFlight = this.refreshInFlight.get(key);
 		if (inFlight) return inFlight;
 		const refreshing = (async () => {
@@ -988,130 +992,323 @@ var AgySessionManager = class {
 				access: cached?.access ?? "",
 				expires: cached?.expires ?? 0,
 				refresh: account.refresh
+			}, {
+				clientId: account.clientId,
+				proxyUrl: account.proxy
 			});
 			if (result.type === "success") {
+				if (!account.clientId && result.clientId) {
+					await this.store.mutate((s) => {
+						const target = s.accounts.find((candidate) => this.accountKey(candidate) === key);
+						if (!target) throw new Error(`Account ${key} not found during clientId migration`);
+						target.clientId = result.clientId;
+					});
+					account.clientId = result.clientId;
+				}
 				this.tokenCache.set(key, {
 					access: result.auth.access,
 					expires: result.auth.expires
 				});
 				return result.auth;
 			}
+			if (result.type === "failed") {
+				if (cached && !accessTokenExpired({
+					access: cached.access,
+					expires: cached.expires,
+					refresh: account.refresh
+				})) return {
+					access: cached.access,
+					expires: cached.expires,
+					refresh: account.refresh
+				};
+				if (isProxyUnreachableError(result.error)) throw new AgyAuthError("transport", "proxy_unreachable", { cause: result.error });
+				throw new AgyAuthError(result.error.status === 429 ? "rate-limit" : result.error.status === 0 || result.error.status === 408 || result.error.status >= 500 ? "transport" : "invalid-credential", result.error.message, { cause: result.error });
+			}
 			if (result.type === "revoked") {
 				this.tokenCache.delete(key);
+				await this.store.mutate((s) => {
+					const target = s.accounts.find((candidate) => this.accountKey(candidate) === key);
+					if (target) {
+						target.enabled = false;
+						target.verificationRequired = true;
+						target.verificationRequiredAt = Date.now();
+						target.verificationRequiredReason = "auth-failure";
+					}
+				});
+				account.enabled = false;
+				account.verificationRequired = true;
+				account.verificationRequiredAt = Date.now();
+				account.verificationRequiredReason = "auth-failure";
 				return;
 			}
 		})();
 		this.refreshInFlight.set(key, refreshing);
-		try {
-			return await refreshing;
-		} finally {
-			this.refreshInFlight.delete(key);
-		}
+		refreshing.then(() => this.refreshInFlight.delete(key), () => this.refreshInFlight.delete(key));
+		return refreshing;
 	}
-	async pickAccount(storage) {
+	/** Resolve a usable access token for the account, pre-emptively refreshing near expiry. */
+	async accessTokenFor(account) {
+		const key = this.accountKey(account);
+		const cached = this.tokenCache.get(key);
 		const now = Date.now();
-		for (const account of storage.accounts) clearExpiredState(account, now);
-		let resolved = resolveActiveAccount(storage);
-		if (!resolved) return void 0;
-		if (this.lastUsed && now - this.lastUsed.at < 6e5) {
-			const last = storage.accounts[this.lastUsed.index];
-			if (last && last.enabled !== false && !isCoolingDown(last, now)) resolved = {
-				account: last,
-				index: this.lastUsed.index
+		if (cached && !accessTokenExpired({
+			access: cached.access,
+			expires: cached.expires,
+			refresh: account.refresh
+		})) {
+			if (cached.expires <= now + AgySessionManager.REFRESH_SKEW_MS) this.refreshToken(key, account, cached);
+			return {
+				access: cached.access,
+				expires: cached.expires,
+				refresh: account.refresh
 			};
 		}
-		if (isCoolingDown(resolved.account, now)) {
-			const nextIndex = pickNextAccountIndex(storage.accounts, resolved.index, now);
-			if (nextIndex !== resolved.index) resolved = {
-				account: storage.accounts[nextIndex],
-				index: nextIndex
+		return this.refreshToken(key, account, cached);
+	}
+	/**
+	* Refresh stale per-account quota caches (family-scoped, health-based TTL).
+	* Failures leave the account unmeasured: ranking treats it as a fallback
+	* instead of blocking selection on a hung endpoint.
+	*/
+	async refreshQuotaCache(storage) {
+		const now = Date.now();
+		const stale = storage.accounts.filter((account) => account.enabled !== false && isQuotaStale(account, now));
+		if (stale.length === 0) return;
+		const updates = (await Promise.all(stale.map(async (account) => {
+			const key = this.accountKey(account);
+			if (this.quotaRefreshInFlight.has(key)) return this.quotaRefreshInFlight.get(key);
+			const refresh = (async () => {
+				try {
+					const auth = await this.accessTokenFor(account);
+					if (!auth) return null;
+					const { fetchAvailableModels } = await import("./models-DRWVi33p.mjs").then((n) => n.r);
+					const quotas = ingestFamilyQuotas(await fetchAvailableModels(auth.access, account.projectId, (input, init) => {
+						const timeout = AbortSignal.timeout(AgySessionManager.QUOTA_FETCH_TIMEOUT_MS);
+						const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+						if (account.proxy) return proxiedFetch(input, {
+							...init,
+							signal
+						}, { proxyUrl: account.proxy });
+						return fetch(input, {
+							...init,
+							signal
+						});
+					}));
+					return {
+						key,
+						quotas,
+						updatedAt: Date.now()
+					};
+				} catch {
+					return null;
+				}
+			})();
+			this.quotaRefreshInFlight.set(key, refresh);
+			try {
+				return await refresh;
+			} finally {
+				this.quotaRefreshInFlight.delete(key);
+			}
+		}))).filter((r) => Boolean(r && Object.keys(r.quotas).length > 0));
+		if (updates.length > 0) {
+			for (const update of updates) {
+				const target = storage.accounts.find((candidate) => this.accountKey(candidate) === update.key);
+				if (target) {
+					target.cachedQuota = update.quotas;
+					target.cachedQuotaUpdatedAt = update.updatedAt;
+				}
+			}
+			try {
+				await this.store.mutate((s) => {
+					for (const update of updates) {
+						const target = s.accounts.find((candidate) => this.accountKey(candidate) === update.key);
+						if (target) {
+							target.cachedQuota = update.quotas;
+							target.cachedQuotaUpdatedAt = update.updatedAt;
+						}
+					}
+				});
+			} catch {}
+		}
+	}
+	/**
+	* Pick the account for one request: the affinity pin wins while it is fresh,
+	* healthy, and not drained for the requested model; otherwise the pool is
+	* ranked by family-scoped usage (OMP-aligned) and the best candidate wins.
+	*/
+	async pickAccount(storage, model) {
+		const now = Date.now();
+		for (const account of storage.accounts) clearExpiredState(account, now);
+		const family = modelFamilyOf(model);
+		const familyKey = familyKeyOf(model);
+		if (this.lastUsed && now - this.lastUsed.at < 6e5) {
+			const lastIndex = storage.accounts.findIndex((a) => this.accountKey(a) === this.lastUsed.key);
+			if (lastIndex !== -1) {
+				const last = storage.accounts[lastIndex];
+				if (last.enabled !== false && !isCoolingDown(last, now) && !isFamilyRateLimited(last, familyKey, now) && !isFamilyDrained(last, family, now)) return {
+					account: last,
+					index: lastIndex
+				};
+			}
+		}
+		const eligible = storage.accounts.map((account, index) => ({
+			account,
+			index
+		})).filter(({ account }) => account.enabled !== false);
+		if (eligible.length === 0) return void 0;
+		const ranked = rankPoolCandidates(eligible, model, now, storage.activeIndex);
+		const picked = ranked.find((candidate) => candidate.blockedUntil === null);
+		if (!picked) {
+			const quotaExhausted = (account) => {
+				if (account.cooldownReason === "quota-exhausted" && (account.coolingDownUntil ?? 0) > now) return true;
+				const quota = familyQuotaFor(account, family);
+				if ((quota?.remainingFraction ?? 1) > 0 || !quota?.resetTime) return false;
+				const resetAt = Date.parse(quota.resetTime);
+				return !Number.isNaN(resetAt) && resetAt > now;
 			};
+			const retryable = ranked.filter((candidate) => !quotaExhausted(candidate.account));
+			const blocked = retryable.length > 0 ? retryable : ranked;
+			const blockedUntil = Math.min(...blocked.map((candidate) => candidate.blockedUntil ?? now));
+			throw new AgyPoolBlockedError(retryable.length > 0 ? "retryable" : "quota-exhausted", blockedUntil);
+		}
+		if (picked.index !== storage.activeIndex) {
+			storage.activeIndex = picked.index;
+			await this.store.mutate((s) => {
+				s.activeIndex = picked.index;
+			});
 		}
-		return resolved;
+		return {
+			account: picked.account,
+			index: picked.index
+		};
 	}
 	/**
 	* Adapter hook: resolve the active session (refresh if needed), healing a
 	* missing projectId at request time — the OAuth-time loadCodeAssist may have
 	* transiently failed even when the Google account owns a Cloud Code project
 	* (mirrors OmniRoute's ensureAntigravityProjectAssigned + persistence).
+	* @param model - requested model id; drives family-scoped quota ranking.
 	*/
-	async getSession() {
-		const storage = await this.store.load();
-		const picked = await this.pickAccount(storage);
-		if (!picked) return void 0;
-		const auth = await this.accessTokenFor(picked.account);
-		if (!auth) return void 0;
-		const key = this.accountKey(picked.account);
-		if (!picked.account.projectId && !this.projectRetryFailed.has(key)) try {
-			const { loadCodeAssist } = await import("./exchange-DBRzR2M-.mjs").then((n) => n.n);
-			const { projectId } = await loadCodeAssist(auth.access);
-			if (projectId) {
-				await this.store.mutate((s) => {
-					const account = s.accounts[picked.index];
-					if (account) {
-						account.projectId = projectId;
-						const parts = parseRefreshParts(account.refresh);
-						account.refresh = formatRefreshParts({
-							refreshToken: parts.refreshToken,
-							projectId,
-							managedProjectId: parts.managedProjectId
-						});
+	async getSession(model) {
+		let storage = await this.store.load();
+		const maxAttempts = storage.accounts.filter((account) => account.enabled !== false).length;
+		let proxyUnreachableCount = 0;
+		for (let attempt = 0; attempt < maxAttempts; attempt++) {
+			if (storage.accounts.filter((account) => account.enabled !== false).length > 1) await this.refreshQuotaCache(storage);
+			const picked = await this.pickAccount(storage, model);
+			if (!picked) return void 0;
+			let auth;
+			try {
+				auth = await this.accessTokenFor(picked.account);
+			} catch (error) {
+				if (error instanceof AgyAuthError && error.kind === "transport" && isProxyUnreachableError(error)) {
+					proxyUnreachableCount++;
+					this.lastUsed = null;
+					const deadIndex = storage.accounts.findIndex((a) => this.accountKey(a) === this.accountKey(picked.account));
+					if (deadIndex !== -1) {
+						const next = pickNextAccountIndex(storage.accounts, deadIndex, Date.now());
+						if (next !== storage.activeIndex) {
+							storage.activeIndex = next;
+							await this.store.mutate((s) => {
+								s.activeIndex = next;
+							}).catch(() => {});
+						}
 					}
-				});
-				picked.account.projectId = projectId;
-			} else this.projectRetryFailed.add(key);
-		} catch {
-			this.projectRetryFailed.add(key);
+					storage = await this.store.load();
+					continue;
+				}
+				if (isProxyUnreachableError(error)) {
+					proxyUnreachableCount++;
+					this.lastUsed = null;
+					storage = await this.store.load();
+					continue;
+				}
+				throw error;
+			}
+			if (!auth) {
+				this.lastUsed = null;
+				storage = await this.store.load();
+				continue;
+			}
+			const key = this.accountKey(picked.account);
+			if (!picked.account.projectId && !this.projectRetryFailed.has(key)) try {
+				const { loadCodeAssist } = await import("./exchange-BvrLu2E4.mjs").then((n) => n.n);
+				const { projectId } = await loadCodeAssist(auth.access);
+				if (projectId) {
+					await this.store.mutate((s) => {
+						const account = s.accounts.find((candidate) => this.accountKey(candidate) === key);
+						if (account) {
+							account.projectId = projectId;
+							const parts = parseRefreshParts(account.refresh);
+							account.refresh = formatRefreshParts({
+								refreshToken: parts.refreshToken,
+								projectId,
+								managedProjectId: parts.managedProjectId
+							});
+						}
+					});
+					picked.account.projectId = projectId;
+				} else this.projectRetryFailed.add(key);
+			} catch {
+				this.projectRetryFailed.add(key);
+			}
+			this.lastUsed = {
+				key,
+				at: Date.now()
+			};
+			return {
+				auth,
+				account: picked.account,
+				index: picked.index,
+				impersonation: impersonationHeadersFor(picked.account)
+			};
 		}
-		this.lastUsed = {
-			index: picked.index,
-			at: Date.now()
-		};
-		return {
-			auth,
-			account: picked.account,
-			index: picked.index,
-			impersonation: impersonationHeadersFor(picked.account)
-		};
+		if (proxyUnreachableCount === maxAttempts && maxAttempts > 0) throw new AgyAuthError("transport", "proxy_unreachable");
 	}
 	/** Adapter hook: apply rotation decisions and fingerprint regeneration. */
 	async reportFailure(kind, session, info) {
-		const storage = await this.store.load();
-		const account = storage.accounts[session.index];
-		if (!account) return;
-		const key = this.accountKey(account);
+		if (!session?.account) return;
+		const key = this.accountKey(session.account);
 		const consecutive = (this.failureCounts.get(key) ?? 0) + 1;
 		this.failureCounts.set(key, consecutive);
-		const decision = decideRotation(kind, account, consecutive, info?.retryAfterMs, info?.rateLimitCategory);
-		if (decision.action === "revoke") {
-			this.tokenCache.delete(key);
-			this.failureCounts.delete(key);
-			await this.store.save(storage);
-			return;
-		}
-		if (kind === "rate-limit") {
-			if (!account.fingerprint) {
-				account.fingerprint = generateFingerprint(void 0, await resolveAntigravityVersionBounded());
-				account.fingerprintHistory = recordFingerprintVersion(account.fingerprintHistory, account.fingerprint, "initial");
-			} else {
-				const cached = peekCachedAntigravityVersion();
-				if (cached) updateFingerprintVersion(account.fingerprint, cached);
-				if (consecutive >= 2) {
-					const fresh = generateFingerprint(void 0, await resolveAntigravityVersionBounded());
-					account.fingerprintHistory = recordFingerprintVersion(account.fingerprintHistory, fresh, "regenerated");
-					account.fingerprint = fresh;
+		let nextIndexToRotate = null;
+		const fpCachedVersion = kind === "rate-limit" ? peekCachedAntigravityVersion() : null;
+		const fpResolvedVersion = kind === "rate-limit" && !fpCachedVersion ? await resolveAntigravityVersionBounded() : fpCachedVersion ?? "1.18.3";
+		await this.store.mutate((storage) => {
+			const account = storage.accounts.find((a) => this.accountKey(a) === key);
+			if (!account) return;
+			const decision = decideRotation(kind, account, consecutive, info?.retryAfterMs, info?.rateLimitCategory, info?.resetTime);
+			if (kind === "rate-limit" && info?.rateLimitCategory !== "soft_rate_limit") recordRateLimit(account, familyKeyOf(info?.model), parseFutureResetMs$1(info?.resetTime, Date.now()) ?? Date.now() + Math.min(info?.retryAfterMs ?? 3e5, 18e5));
+			if (decision.action === "revoke") {
+				this.tokenCache.delete(key);
+				this.failureCounts.delete(key);
+				return;
+			}
+			if (kind === "rate-limit" && info?.rateLimitCategory !== "soft_rate_limit") {
+				if (!account.fingerprint) {
+					account.fingerprint = generateFingerprint(void 0, fpResolvedVersion);
+					account.fingerprintHistory = recordFingerprintVersion(account.fingerprintHistory, account.fingerprint, "initial");
+				} else {
+					if (fpCachedVersion) updateFingerprintVersion(account.fingerprint, fpCachedVersion);
+					if (fingerprintMode() !== "stable" && consecutive >= 2) {
+						const fresh = generateFingerprint(void 0, fpResolvedVersion);
+						account.fingerprintHistory = recordFingerprintVersion(account.fingerprintHistory, fresh, "regenerated");
+						account.fingerprint = fresh;
+					}
 				}
 			}
-		}
-		if (decision.action === "rotate") {
-			const nextIndex = pickNextAccountIndex(storage.accounts, session.index);
-			if (nextIndex !== session.index) {
-				storage.activeIndex = nextIndex;
-				this.onRotate?.(session.index, nextIndex, kind);
+			if (decision.action === "rotate") {
+				const currentIndex = storage.accounts.findIndex((a) => this.accountKey(a) === key);
+				const familyKey = familyKeyOf(info?.model);
+				const nextIndex = pickNextAccountIndex(storage.accounts, currentIndex >= 0 ? currentIndex : storage.activeIndex, Date.now(), familyKey);
+				if (nextIndex !== storage.activeIndex) {
+					storage.activeIndex = nextIndex;
+					nextIndexToRotate = nextIndex;
+				}
+				this.lastUsed = null;
 			}
-			this.lastUsed = null;
-		}
-		await this.store.save(storage);
+		});
+		if (nextIndexToRotate !== null) this.onRotate?.(session.index, nextIndexToRotate, kind);
 	}
 	/** Adapter hook: reset the failure counter after a clean completion. */
 	async markSuccess(session) {
@@ -1124,13 +1321,13 @@ var AgySessionManager = class {
 	* Returns the collected text or a structured error message.
 	*/
 	async testCall(model, prompt = "Reply with exactly: OK", maxTokens = 1024) {
-		const session = await this.getSession();
-		if (!session) return {
-			ok: false,
-			error: "No agy account configured — run `dsh-agy login` first."
-		};
 		try {
-			const { toAgyRequestBody } = await import("./translate-BQuSQW35.mjs").then((n) => n.n);
+			const session = await this.getSession(model);
+			if (!session) return {
+				ok: false,
+				error: "No agy account configured — run `dsh-agy login` first."
+			};
+			const { toAgyRequestBody } = await import("./translate-COjBTH4-.mjs").then((n) => n.n);
 			const { fetchAgyFirstOk } = await Promise.resolve().then(() => constants_exports);
 			const { parseAgySse } = await import("./parse-D8bV2yqa.mjs").then((n) => n.n);
 			const body = toAgyRequestBody({
@@ -1188,30 +1385,29 @@ var AgySessionManager = class {
 	async exportBlob(index) {
 		const account = (await this.store.load()).accounts[index];
 		if (!account) return { error: "account not found" };
-		const auth = await this.accessTokenFor(account);
-		if (!auth) return { error: "refresh failed (revoked?)" };
-		const { encodeCredentialBlob } = await import("./blob-D1e7_uT1.mjs").then((n) => n.t);
-		const parts = parseRefreshParts(account.refresh);
-		return { blob: encodeCredentialBlob("agy", {
-			access_token: auth.access,
-			refresh_token: parts.refreshToken,
-			expires_in: Math.max(0, Math.round((auth.expires - Date.now()) / 1e3))
-		}) };
+		try {
+			const auth = await this.accessTokenFor(account);
+			if (!auth) return { error: "refresh failed (revoked?)" };
+			const { encodeCredentialBlob } = await import("./blob-D1e7_uT1.mjs").then((n) => n.t);
+			const parts = parseRefreshParts(account.refresh);
+			return { blob: encodeCredentialBlob("agy", {
+				access_token: auth.access,
+				refresh_token: parts.refreshToken,
+				expires_in: Math.max(0, Math.round((auth.expires - Date.now()) / 1e3))
+			}) };
+		} catch (error) {
+			return { error: error instanceof Error ? error.message : String(error) };
+		}
 	}
-	/** CLI/web helper: verify an account's credentials (refresh + userinfo). */
-	async verifyAccount(index) {
-		const account = (await this.store.load()).accounts[index];
-		if (!account) return {
-			ok: false,
-			error: "account not found"
-		};
-		const auth = await this.accessTokenFor(account);
-		if (!auth) return {
-			ok: false,
-			error: "refresh failed (revoked?)"
-		};
+	/** Probe one account: refresh + userinfo; a live credential re-enables the account. */
+	async probeAccount(index, account) {
 		try {
-			const response = await proxiedFetch("https://www.googleapis.com/oauth2/v1/userinfo?alt=json", { headers: { Authorization: `Bearer ${auth.access}` } });
+			const auth = await this.accessTokenFor(account);
+			if (!auth) return {
+				ok: false,
+				error: "refresh failed (revoked?)"
+			};
+			const response = await proxiedFetch("https://www.googleapis.com/oauth2/v1/userinfo?alt=json", { headers: { Authorization: `Bearer ${auth.access}` } }, account.proxy ? { proxyUrl: account.proxy } : void 0);
 			if (!response.ok) return {
 				ok: false,
 				error: `userinfo ${response.status}`
@@ -1238,8 +1434,391 @@ var AgySessionManager = class {
 			};
 		}
 	}
+	/** CLI/web helper: verify an account's credentials (refresh + userinfo). */
+	async verifyAccount(index) {
+		const account = (await this.store.load()).accounts[index];
+		if (!account) return {
+			ok: false,
+			error: "account not found"
+		};
+		return this.probeAccount(index, account);
+	}
+	/**
+	* Batch health check over all enabled accounts (or the given indices):
+	* refresh + userinfo per account, live credentials re-enable the account.
+	* Reports results through onHealthReport when a listener is registered.
+	*/
+	async checkAccounts(indices) {
+		const storage = await this.store.load();
+		const targets = indices !== void 0 ? indices.filter((index) => storage.accounts[index]) : storage.accounts.map((_, index) => index).filter((index) => storage.accounts[index].enabled !== false);
+		const results = await Promise.all(targets.map(async (index) => {
+			return {
+				index,
+				...await this.probeAccount(index, storage.accounts[index])
+			};
+		}));
+		this.onHealthReport?.(results);
+		return results;
+	}
+	/**
+	* Start a background health probe on an interval (disposable stop handle).
+	* The timer is unref'd unless told otherwise so harness processes can still
+	* exit; the CLI loop mode passes `unref: false`.
+	*/
+	startHealthProbe(intervalMs, options = {}) {
+		if (!Number.isFinite(intervalMs) || intervalMs <= 0) return () => {};
+		const timer = setInterval(() => {
+			this.checkAccounts().catch(() => {});
+		}, intervalMs);
+		if (options.unref !== false) timer.unref?.();
+		return () => clearInterval(timer);
+	}
+};
+//#endregion
+//#region src/store/keyring.ts
+/**
+* Master-key management and AES-256-GCM secret codec for the account store.
+*
+* The master key lives in the DSH credentials document (`~/.dsh/.credentials.yaml`,
+* 0600) under `AGY_MASTER_KEY` so both the in-harness plugin (via
+* `ctx.credentials`) and the standalone `dsh-agy` CLI (direct file read) can
+* encrypt and decrypt the same account store.
+*/
+const MASTER_KEY_REF = "AGY_MASTER_KEY";
+const ENC_PREFIX$1 = "enc:v1:";
+/** AES-256-GCM codec; ciphertext format `enc:v1:<iv-b64>:<tag-b64>:<data-b64>`. */
+function createAesGcmCodec(key) {
+	if (key.length !== 32) throw new Error(`createAesGcmCodec: master key must be 32 bytes, got ${key.length}`);
+	return {
+		encrypt(plaintext) {
+			const iv = randomBytes(12);
+			const cipher = createCipheriv("aes-256-gcm", key, iv);
+			const data = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+			const tag = cipher.getAuthTag();
+			return `${ENC_PREFIX$1}${iv.toString("base64url")}:${tag.toString("base64url")}:${data.toString("base64url")}`;
+		},
+		decrypt(payload) {
+			if (!payload.startsWith(ENC_PREFIX$1)) throw new Error("decrypt: payload is not in encrypted format");
+			const [, , ivB64 = "", tagB64 = "", dataB64 = ""] = payload.split(":");
+			const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(ivB64, "base64url"));
+			decipher.setAuthTag(Buffer.from(tagB64, "base64url"));
+			return Buffer.concat([decipher.update(Buffer.from(dataB64, "base64url")), decipher.final()]).toString("utf8");
+		}
+	};
+}
+/** Derive a 32-byte key from an arbitrary master-key string (SHA-256). */
+function deriveKey(masterKey) {
+	return createHash("sha256").update(masterKey, "utf8").digest();
+}
+/** Default DSH home (`~/.dsh`), honoring `$DSH_HOME`. */
+function resolveDshHome() {
+	return process.env.DSH_HOME ? resolve(process.env.DSH_HOME) : join(homedir(), ".dsh");
+}
+function homedir() {
+	return process.env.HOME ?? process.env.USERPROFILE ?? ".";
+}
+/**
+* Minimal reader for the DSH credentials document: a flat YAML mapping of
+* `KEY: "value"` / `KEY: value` lines. Values are unquoted with JSON-style
+* escaping for double-quoted scalars; anything more complex fails loudly.
+*/
+function readCredentialsDocument(file) {
+	if (!existsSync(file)) return /* @__PURE__ */ new Map();
+	const entries = /* @__PURE__ */ new Map();
+	const text = readFileSync(file, "utf8");
+	for (const line of text.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("---")) continue;
+		const match = /^([A-Za-z_][A-Za-z0-9_]*):\s*(.*)$/.exec(trimmed);
+		if (!match) continue;
+		const [, key = "", rawValue = ""] = match;
+		let value;
+		if (rawValue.startsWith("\"")) try {
+			value = JSON.parse(rawValue);
+		} catch {
+			throw new Error(`readCredentialsDocument: invalid quoted value for "${key}" in ${file}`);
+		}
+		else if (rawValue.startsWith("'")) {
+			if (!rawValue.endsWith("'") || rawValue.length < 2) throw new Error(`readCredentialsDocument: unterminated single-quoted value for "${key}" in ${file}`);
+			value = rawValue.slice(1, -1).replace(/''/g, "'");
+		} else value = rawValue;
+		if (value.length === 0) continue;
+		entries.set(key, value);
+	}
+	return entries;
+}
+/**
+* POSIX owner-only enforcement. Windows mode bits never report 0600 (and
+* chmod is a no-op there), so the check is skipped on win32; the encrypted
+* account file and credentials document remain the only defense-in-depth
+* layer on that platform.
+*/
+function assertOwnerOnly(file) {
+	if (process.platform === "win32") return;
+	const mode = statSync(file).mode & 511;
+	if (mode !== 384) throw new Error(`dsh-agy: ${file} is readable beyond its owner (mode ${mode.toString(8)}); run "chmod 600" before starting again`);
+}
+/**
+* Load the master key from the DSH credentials document. Returns undefined when
+* the document or the reference is absent.
+*/
+function loadMasterKey(dshHome) {
+	const file = join(dshHome, ".credentials.yaml");
+	if (!existsSync(file)) return void 0;
+	assertOwnerOnly(file);
+	return readCredentialsDocument(file).get(MASTER_KEY_REF);
+}
+/**
+* Generate and persist a fresh master key (0600) in the DSH credentials document.
+*
+* Append-only + atomic rename: the DSH credentials service owns this file and
+* preserves comments and the formatting of untouched entries (and may hold
+* YAML constructs this minimal reader cannot parse). Rewriting the whole file
+* from our parsed view would silently drop those; appending keeps them.
+*/
+function persistMasterKey(dshHome, masterKey) {
+	const file = join(dshHome, ".credentials.yaml");
+	mkdirSync(dirname(file), { recursive: true });
+	const existingText = existsSync(file) ? readFileSync(file, "utf8") : "";
+	if (existingText.length > 0 && readCredentialsDocument(file).has("AGY_MASTER_KEY")) throw new Error(`persistMasterKey: ${MASTER_KEY_REF} already exists in ${file}`);
+	const entry = `${MASTER_KEY_REF}: ${JSON.stringify(masterKey)}`;
+	const next = existingText.length > 0 && !existingText.endsWith("\n") ? `${existingText}\n${entry}\n` : `${existingText}${entry}\n`;
+	const tmp = `${file}.tmp-masterkey`;
+	writeFileSync(tmp, next, { mode: 384 });
+	renameSync(tmp, file);
+}
+/**
+* Resolve (load or create) the master key for a dsh home, then build the codec.
+* Creating a key writes the credentials document; read-only setups should call
+* {@link loadMasterKey} first and surface a friendly error instead.
+*/
+function resolveMasterKeyCodec(dshHome) {
+	let masterKey = loadMasterKey(dshHome);
+	let created = false;
+	if (!masterKey) {
+		masterKey = randomBytes(32).toString("hex");
+		persistMasterKey(dshHome, masterKey);
+		created = true;
+	}
+	return {
+		codec: createAesGcmCodec(deriveKey(masterKey)),
+		created
+	};
+}
+const ENC_PREFIX = "enc:v1:";
+const properFileLock = { async withLock(file, fn) {
+	const release = await lockfile.lock(file, {
+		stale: 3e4,
+		update: 1e4,
+		retries: {
+			retries: 10,
+			factor: 1.5,
+			minTimeout: 50,
+			maxTimeout: 2e3
+		}
+	});
+	try {
+		return await fn();
+	} finally {
+		await release();
+	}
+} };
+function isEncrypted(value) {
+	return value.startsWith(ENC_PREFIX);
+}
+/** Decrypt one account's refresh/proxy fields when encrypted; plaintext passes through (legacy). */
+function decryptAccount(account, codec) {
+	let out = account;
+	if (isEncrypted(out.refresh)) out = {
+		...out,
+		refresh: codec.decrypt(out.refresh)
+	};
+	if (out.proxy && isEncrypted(out.proxy)) out = {
+		...out,
+		proxy: codec.decrypt(out.proxy)
+	};
+	return out;
+}
+/** Encrypt one account's refresh/proxy fields (plaintext stays plaintext if no codec change). */
+function encryptAccount(account, codec) {
+	let out = account;
+	if (!isEncrypted(out.refresh)) out = {
+		...out,
+		refresh: codec.encrypt(out.refresh)
+	};
+	if (out.proxy && !isEncrypted(out.proxy)) out = {
+		...out,
+		proxy: codec.encrypt(out.proxy)
+	};
+	return out;
+}
+/** Mask a proxy URL for display/logs: protocol//host:port (no credentials, no query). */
+function maskProxyUrl(proxyUrl) {
+	if (!proxyUrl) return null;
+	try {
+		const u = new URL(proxyUrl);
+		const port = u.port || (u.protocol === "https:" ? "443" : u.protocol === "socks5:" || u.protocol === "socks5h:" ? "1080" : "8080");
+		return `${u.protocol}//${u.hostname}:${port}`;
+	} catch {
+		return null;
+	}
+}
+function ensureAccountIds(storage) {
+	let mutated = false;
+	const seenIds = /* @__PURE__ */ new Set();
+	for (const account of storage.accounts) {
+		if (!account.id || seenIds.has(account.id)) {
+			account.id = randomUUID();
+			mutated = true;
+		}
+		seenIds.add(account.id);
+	}
+	return {
+		storage,
+		mutated
+	};
+}
+function decryptStorage(storage, codec) {
+	return {
+		...storage,
+		accounts: storage.accounts.map((a) => decryptAccount(a, codec))
+	};
+}
+function encryptStorage(storage, codec) {
+	return {
+		...storage,
+		accounts: storage.accounts.map((a) => encryptAccount(a, codec))
+	};
+}
+function migrateV1ToV2(v1) {
+	return {
+		version: 2,
+		accounts: v1.accounts.map((acc) => ({
+			email: acc.email,
+			refreshToken: acc.refreshToken,
+			projectId: acc.projectId,
+			managedProjectId: acc.managedProjectId,
+			addedAt: acc.addedAt,
+			lastUsed: acc.lastUsed,
+			lastSwitchReason: acc.lastSwitchReason,
+			rateLimitResetTimes: acc.isRateLimited && acc.rateLimitResetTime ? { default: acc.rateLimitResetTime } : void 0
+		})),
+		activeIndex: v1.activeIndex
+	};
+}
+function migrateV2ToV3(v2) {
+	return {
+		version: 3,
+		accounts: v2.accounts.map((acc) => ({
+			email: acc.email,
+			refresh: `${acc.refreshToken}|${acc.projectId ?? ""}|${acc.managedProjectId ?? ""}`,
+			projectId: acc.projectId,
+			managedProjectId: acc.managedProjectId,
+			addedAt: acc.addedAt,
+			lastUsed: acc.lastUsed,
+			enabled: true,
+			lastSwitchReason: acc.lastSwitchReason,
+			rateLimitResetTimes: acc.rateLimitResetTimes
+		})),
+		activeIndex: v2.activeIndex
+	};
+}
+function migrateV3ToV4(v3) {
+	return {
+		version: 4,
+		accounts: v3.accounts,
+		activeIndex: v3.activeIndex
+	};
+}
+function migrateStorage(raw) {
+	switch (raw.version) {
+		case 1: return migrateStorage(migrateV1ToV2(raw));
+		case 2: return migrateStorage(migrateV2ToV3(raw));
+		case 3: return migrateStorage(migrateV3ToV4(raw));
+		case 4: return raw;
+		default: throw new Error(`migrateStorage: unsupported storage version ${raw.version}`);
+	}
+}
+var JsonAccountStore = class {
+	file;
+	codec;
+	lock;
+	constructor(options) {
+		this.file = options.file;
+		this.codec = options.codec;
+		this.lock = options.lock ?? properFileLock;
+	}
+	ensureFile() {
+		if (existsSync(this.file)) return;
+		mkdirSync(dirname(this.file), { recursive: true });
+		const tmp = `${this.file}.tmp-init`;
+		writeFileSync(tmp, JSON.stringify({
+			version: 4,
+			accounts: [],
+			activeIndex: 0
+		}) + "\n", { mode: 384 });
+		renameSync(tmp, this.file);
+	}
+	readAndMigrateUnlocked() {
+		let text;
+		try {
+			text = readFileSync(this.file, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") return {
+				storage: {
+					version: 4,
+					accounts: [],
+					activeIndex: 0
+				},
+				mutated: false
+			};
+			throw error;
+		}
+		assertOwnerOnly(this.file);
+		return ensureAccountIds(decryptStorage(migrateStorage(JSON.parse(text)), this.codec));
+	}
+	writeUnlocked(storage) {
+		const encrypted = encryptStorage(ensureAccountIds(storage).storage, this.codec);
+		mkdirSync(dirname(this.file), { recursive: true });
+		const tmp = `${this.file}.tmp`;
+		writeFileSync(tmp, JSON.stringify(encrypted, null, 2) + "\n", { mode: 384 });
+		renameSync(tmp, this.file);
+	}
+	/**
+	* Materialize and persist generated/repaired UUIDs under the file lock:
+	* re-reads the fresh on-disk state under the lock so concurrent mutations
+	* are never clobbered by a stale pre-lock snapshot.
+	*/
+	async materializeIdsWithLock() {
+		this.ensureFile();
+		return this.lock.withLock(this.file, async () => {
+			const { storage, mutated } = this.readAndMigrateUnlocked();
+			if (mutated) this.writeUnlocked(storage);
+			return storage;
+		});
+	}
+	async load() {
+		const { storage, mutated } = this.readAndMigrateUnlocked();
+		if (mutated) return this.materializeIdsWithLock();
+		return storage;
+	}
+	async save(storage) {
+		this.ensureFile();
+		await this.lock.withLock(this.file, async () => {
+			this.writeUnlocked(storage);
+		});
+	}
+	async mutate(fn) {
+		this.ensureFile();
+		return this.lock.withLock(this.file, async () => {
+			const { storage } = this.readAndMigrateUnlocked();
+			const result = await fn(storage);
+			this.writeUnlocked(storage);
+			return result;
+		});
+	}
 };
 //#endregion
-export { OAUTH_TOKEN_URL as C, getAgyBootstrapUserAgent as D, getAgyBootstrapClientMetadata as E, proxiedFetch as O, OAUTH_AUTHORIZE_URL as S, fetchAgyFirstOk as T, AGY_CLIENT_ID as _, MASTER_KEY_REF as a, AGY_ENDPOINT_FALLBACKS as b, loadMasterKey as c, resolveMasterKeyCodec as d, calculateTokenExpiry as f, generateAntigravityRequestId as g, deriveAntigravitySessionId as h, JsonAccountStore as i, persistMasterKey as l, resolveAntigravityVersionBounded as m, generateFingerprint as n, createAesGcmCodec as o, resolveAntigravityVersion as p, recordFingerprintVersion as r, deriveKey as s, AgySessionManager as t, resolveDshHome as u, AGY_CLIENT_SECRET as v, OAUTH_USERINFO_URL as w, AGY_SCOPES as x, AGY_DEFAULT_REDIRECT_URI as y };
+export { AgyPoolBlockedError as A, OAUTH_TOKEN_URL as C, getAgyBootstrapUserAgent as D, getAgyBootstrapClientMetadata as E, resolveAgyClientCredentials as O, OAUTH_AUTHORIZE_URL as S, fetchAgyFirstOk as T, deriveAntigravitySessionId as _, deriveKey as a, AGY_ENDPOINT_FALLBACKS as b, resolveDshHome as c, isAgyDisabled as d, generateFingerprint as f, resolveAntigravityVersionBounded as g, resolveAntigravityVersion as h, createAesGcmCodec as i, AgyAuthError as k, resolveMasterKeyCodec as l, calculateTokenExpiry as m, maskProxyUrl as n, loadMasterKey as o, recordFingerprintVersion as p, MASTER_KEY_REF as r, persistMasterKey as s, JsonAccountStore as t, AgySessionManager as u, generateAntigravityRequestId as v, OAUTH_USERINFO_URL as w, AGY_SCOPES as x, AGY_DEFAULT_REDIRECT_URI as y };
 
-//# sourceMappingURL=session-KoIh3xdB.mjs.map
+//# sourceMappingURL=accounts-DbTTxX_z.mjs.map