dsh-agy-link 0.4.66 → 0.4.70

package/dist/index.js

@@ -7,7 +7,7 @@ import * as dshLlm from "@deepseek-ai/dsh-llm";
 import { LlmAdapter, LlmError } from "@deepseek-ai/dsh-llm";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { defineTool } from "@deepseek-ai/dsh-tools";
-import { chmod, copyFile, mkdir, mkdtemp, readFile, readdir, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, readdir, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { EventEmitter } from "node:events";
 import { createServer } from "node:http";
 import { promisify } from "node:util";
@@ -135,7 +135,8 @@ function defaultConfig() {
 		autoFallbackModel: false,
 		logRetentionDays: 7,
 		disableTelemetry: true,
-		quotaPollIntervalMs: 9e5,
+		quotaPollIntervalMs: 36e5,
+		quotaViaCli: true,
 		proxyUrl: "",
 		suppressAgyAutoUpdate: process.platform === "win32"
 	};
@@ -165,6 +166,60 @@ function looksLikeNetworkError(message) {
 	return /dial tcp|fetch failed|econn(?:refused|reset|aborted)|enotfound|ehostunreach|enetunreach|socket hang up|getaddrinfo|bad gateway|service unavailable|unexpected eof|\beof\b|tls handshake timeout|i\/o timeout|network (?:error|is unreachable)|no route to host|connection reset|context deadline exceeded|temporary failure in name resolution|proxyconnect|token validation failed|validate (?:the )?token|silent auth failed/i.test(message);
 }
 /**
+* Backoff schedule for CONSECUTIVE transport (NETWORK) failures.
+*
+* DSH's generic backoff starts at 2s and doubles, which spends the whole retry
+* budget inside a few seconds. A real egress outage does not look like that:
+* on 2026-10-21 the machine's proxy answered CONNECT 200 and then killed TLS
+* for ~14 minutes, so every agy run failed its startup eligibility probe with
+* `Post "…/loadCodeAssist": EOF` and the turn died after two retries in 4s
+* while agy itself kept working whenever a gap appeared.
+*
+* These delays are stated per failure as `providerRetryAfterMs`, which the
+* retry plugin honours verbatim — but only up to the policy's maxDelayMs (a
+* longer request makes it drop the retry entirely), so the cap must stay above
+* the last entry. The schedule is capped, never unbounded: a dead egress still
+* ends the turn, just after minutes instead of seconds.
+*/
+const NETWORK_RETRY_DELAYS_MS = [
+	5e3,
+	15e3,
+	3e4
+];
+/** Delay to request after `consecutiveFailures` transport failures in a row. */
+function networkRetryDelayMs(consecutiveFailures) {
+	const index = Math.min(Math.max(Math.trunc(consecutiveFailures) - 1, 0), NETWORK_RETRY_DELAYS_MS.length - 1);
+	return NETWORK_RETRY_DELAYS_MS[index];
+}
+/**
+* Whether every ENABLED account leaves through the same proxy.
+*
+* When it does, a transport failure is a property of the machine's egress, not
+* of the account: rotating the pool repoints the session for nothing and burns
+* the rotation budget that a real quota/eligibility hop needs. Accounts with
+* their own `proxyUrl` (or one with an override next to the default) can fail
+* independently, so rotation stays meaningful there.
+*
+* `globalProxy` is the proxy an account without an override uses (config
+* `proxyUrl`, else the detected system proxy). It matters because a newly
+* created pool account is seeded with a COPY of the system proxy while the
+* primary/system account keeps an empty override — comparing raw overrides
+* would call that "two different egresses" and rotate on every blip.
+*
+* Disabled accounts are ignored: they are never selected, so their proxy cannot
+* make the reachable egress distinct.
+*/
+function accountsShareSingleEgress(accounts, globalProxy) {
+	const fallback = (globalProxy ?? "").trim();
+	const urls = /* @__PURE__ */ new Set();
+	for (const account of accounts) {
+		if (account.enabled === false) continue;
+		urls.add((account.proxyUrl ?? "").trim() || fallback);
+		if (urls.size > 1) return false;
+	}
+	return true;
+}
+/**
 * Evidence from agy's OWN per-run log that a stored credential was present but
 * could not be VALIDATED over the network — i.e. jitter wearing an auth costume.
 *
@@ -457,6 +512,7 @@ function resolveConfig(entry, env = process.env, overrides = readOverrides()) {
 		logRetentionDays: asNum(get("logRetentionDays")) ?? base.logRetentionDays,
 		disableTelemetry: asBool(get("disableTelemetry")) ?? base.disableTelemetry,
 		quotaPollIntervalMs: asNum(get("quotaPollIntervalMs")) ?? base.quotaPollIntervalMs,
+		quotaViaCli: asBool(get("quotaViaCli")) ?? base.quotaViaCli,
 		proxyUrl: asString(get("proxyUrl")) ?? base.proxyUrl,
 		suppressAgyAutoUpdate: asBool(get("suppressAgyAutoUpdate")) ?? base.suppressAgyAutoUpdate
 	};
@@ -516,6 +572,10 @@ function resolveConfig(entry, env = process.env, overrides = readOverrides()) {
 		const q = asNum(env.DSH_AGY_QUOTA_POLL_INTERVAL_MS);
 		if (q && q >= 6e4) cfg.quotaPollIntervalMs = q;
 	}
+	if (env.DSH_AGY_QUOTA_VIA_CLI !== void 0) {
+		const qvc = asBool(env.DSH_AGY_QUOTA_VIA_CLI);
+		if (qvc !== void 0) cfg.quotaViaCli = qvc;
+	}
 	if (env.DSH_AGY_PROXY_URL) cfg.proxyUrl = env.DSH_AGY_PROXY_URL;
 	if (env.DSH_AGY_SUPPRESS_AUTOUPDATE !== void 0) {
 		const sa = asBool(env.DSH_AGY_SUPPRESS_AUTOUPDATE);
@@ -1989,7 +2049,7 @@ var EventMapper = class {
 	* context occupancy, so a failed turn used to reset the meter and could fire
 	* a bogus compaction a step later.
 	*/
-	*emitFailure(kind, code, message) {
+	*emitFailure(kind, code, message, retryAfterMs) {
 		if (this.finished) return;
 		const close = this.closeOpen();
 		if (close) yield close;
@@ -2001,20 +2061,19 @@ var EventMapper = class {
 				outputTokens: 0
 			}
 		};
+		const failure = {
+			message,
+			code,
+			...retryAfterMs !== void 0 && Number.isFinite(retryAfterMs) && retryAfterMs > 0 ? { providerRetryAfterMs: Math.trunc(retryAfterMs) } : {}
+		};
 		yield {
 			type: "finish",
 			reason: kind === "error" ? {
 				kind: "error",
-				failure: {
-					message,
-					code
-				}
+				failure
 			} : {
 				kind: "aborted",
-				failure: {
-					message,
-					code
-				}
+				failure
 			}
 		};
 		this.finished = true;
@@ -2022,6 +2081,24 @@ var EventMapper = class {
 };
 //#endregion
 //#region src/host/models.ts
+/** Check if a model identifier belongs to the Gemini 4 Argon family. */
+function isArgonModel(id) {
+	return id.trim().toLowerCase().includes("argon");
+}
+/**
+* Determine whether a managed account has confirmed access to the Gemini 4 Argon family.
+* Argon is exclusive to paid Pro/Ultra plans and returns a separate quota bucket
+* and/or dedicated model list from agy cli. Free/standard accounts do not have Argon.
+*/
+function accountHasArgon(acc, pool, catalog) {
+	if (!acc) return false;
+	if (acc.quotas?.argon !== void 0) return true;
+	if (pool && typeof pool.hasDedicatedGroup === "function" && pool.hasDedicatedGroup(acc.id, "argon")) return true;
+	if (acc.quotas?.google?.models?.some((m) => isArgonModel(m.modelId))) return true;
+	if (acc.quotas?.google !== void 0) return false;
+	if (catalog && catalog.source === "discovered") return catalog.models.some((m) => isArgonModel(m.id));
+	return false;
+}
 /** Parse `agy models` stdout: JSON shapes first, then two-column text. */
 function parseModelsOutput(stdout) {
 	const text = stdout.trim();
@@ -2207,6 +2284,7 @@ var ModelCatalog = class ModelCatalog {
 	ttlMs;
 	onUpdate;
 	current;
+	accountCatalogs = /* @__PURE__ */ new Map();
 	refreshing = null;
 	/**
 	* While the catalog is still on the fallback source, re-probe at most once
@@ -2226,46 +2304,60 @@ var ModelCatalog = class ModelCatalog {
 			discoveredAt: 0
 		};
 	}
-	get() {
+	get(accountId) {
+		if (accountId && this.accountCatalogs.has(accountId)) return this.accountCatalogs.get(accountId);
 		return this.current;
 	}
+	hasAccountCatalog(accountId) {
+		return this.accountCatalogs.has(accountId);
+	}
 	/** Refresh if stale; never throws — failures keep the previous catalog. */
-	async refreshIfNeeded() {
+	async refreshIfNeeded(accountId) {
 		if (this.refreshing) return this.refreshing;
 		const now = Date.now();
-		const age = now - this.current.discoveredAt;
-		if (this.current.source === "discovered" && age < this.ttlMs) return;
-		if (this.current.source === "fallback" && now - this.lastAttemptAt < ModelCatalog.FALLBACK_RETRY_MS) return;
+		const accountCat = accountId ? this.accountCatalogs.get(accountId) : void 0;
+		if (!accountId || accountCat) {
+			const targetCat = accountCat ?? this.current;
+			const age = now - targetCat.discoveredAt;
+			if (targetCat.source === "discovered" && age < this.ttlMs) return;
+			if (targetCat.source === "fallback" && now - this.lastAttemptAt < ModelCatalog.FALLBACK_RETRY_MS) return;
+		}
 		this.lastAttemptAt = now;
-		this.refreshing = this.refresh().finally(() => {
+		this.refreshing = this.refresh(accountId).finally(() => {
 			this.refreshing = null;
 		});
 		return this.refreshing;
 	}
-	async forceRefresh() {
-		await this.refresh();
+	async forceRefresh(accountId) {
+		await this.refresh(accountId);
 		this.onUpdate?.();
-		return this.current;
+		return this.get(accountId);
 	}
-	async refresh() {
+	async refresh(accountId) {
 		try {
 			const ac = new AbortController();
 			const timer = setTimeout(() => ac.abort(), 3e4);
 			try {
-				const { stdout } = await this.discover(ac.signal);
+				const { stdout } = await this.discover(ac.signal, accountId);
 				const raw = parseModelsOutput(stdout);
 				if (raw.length > 0) {
 					const newModels = foldEfforts(raw);
-					const changed = this.current.source !== "discovered" || this.current.models.length !== newModels.length || this.current.models.some((m, i) => m.id !== newModels[i]?.id);
-					this.current = {
+					const newCatalog = {
 						source: "discovered",
 						models: newModels,
 						discoveredAt: Date.now()
 					};
+					const prev = this.get(accountId);
+					const changed = prev.source !== "discovered" || prev.models.length !== newModels.length || prev.models.some((m, i) => m.id !== newModels[i]?.id);
+					if (accountId) this.accountCatalogs.set(accountId, newCatalog);
+					else this.current = newCatalog;
 					if (changed) this.onUpdate?.();
 					return;
 				}
-				this.current = {
+				if (accountId) {
+					const cat = this.accountCatalogs.get(accountId);
+					if (cat) cat.lastError = "agy models returned no entries";
+				} else this.current = {
 					...this.current,
 					lastError: "agy models returned no entries"
 				};
@@ -2273,9 +2365,13 @@ var ModelCatalog = class ModelCatalog {
 				clearTimeout(timer);
 			}
 		} catch (err) {
-			this.current = {
+			const errMsg = err instanceof Error ? err.message : String(err);
+			if (accountId) {
+				const cat = this.accountCatalogs.get(accountId);
+				if (cat) cat.lastError = errMsg;
+			} else this.current = {
 				...this.current,
-				lastError: err instanceof Error ? err.message : String(err)
+				lastError: errMsg
 			};
 		}
 	}
@@ -3698,7 +3794,7 @@ function runWinCredPs(target, user, action, payload = "") {
 		payload
 	], {
 		encoding: "utf8",
-		timeout: 8e3,
+		timeout: action === "write" ? 3e4 : 8e3,
 		windowsHide: true,
 		stdio: [
 			"ignore",
@@ -4555,6 +4651,28 @@ var AccountPoolManager = class {
 		this.authStrikes.delete(id);
 		this.persist();
 	}
+	/** True when this account has reported a dedicated quota group for `family`. */
+	hasDedicatedGroup(id, family) {
+		return this.getAccount(id)?.dedicatedGroups?.includes(family) === true;
+	}
+	/**
+	* Remember that `family` has its own quota group on this account.
+	* Persists only on an actual change so a steady-state poll stays write-free.
+	*/
+	noteDedicatedGroup(id, family) {
+		const acc = this.getAccount(id);
+		if (!acc) return;
+		if (acc.dedicatedGroups?.includes(family)) return;
+		acc.dedicatedGroups = [...acc.dedicatedGroups ?? [], family];
+		this.persist();
+	}
+	/** Forget a family's dedicated group after it stopped being reported. */
+	forgetDedicatedGroup(id, family) {
+		const acc = this.getAccount(id);
+		if (!acc?.dedicatedGroups?.includes(family)) return;
+		acc.dedicatedGroups = acc.dedicatedGroups.filter((f) => f !== family);
+		this.persist();
+	}
 	clearCooldown(id, family) {
 		if (id) {
 			const acc = this.getAccount(id);
@@ -28143,12 +28261,7 @@ const OAUTH_USERINFO_URL$1 = "https://www.googleapis.com/oauth2/v1/userinfo";
 const OAUTH_CALLBACK_PORT = 51121;
 const OAUTH_REDIRECT_URI = `http://localhost:${OAUTH_CALLBACK_PORT}/oauth-callback`;
 /** Runtime endpoint fallback order (Antigravity endpoint first, then Cloud Code PA fallbacks). */
-const AGY_ENDPOINTS = [
-	"https://daily-cloudcode-pa.googleapis.com",
-	"https://cloudcode-pa.googleapis.com",
-	"https://daily-cloudcode-pa.sandbox.googleapis.com",
-	"https://autopush-cloudcode-pa.sandbox.googleapis.com"
-];
+const AGY_ENDPOINTS = ["https://daily-cloudcode-pa.googleapis.com", "https://cloudcode-pa.googleapis.com"];
 function generatePkce() {
 	const verifier = randomBytes(32).toString("base64url");
 	return {
@@ -28841,6 +28954,32 @@ var SlotUnavailableError = class extends Error {
 		this.name = "SlotUnavailableError";
 	}
 };
+/**
+* Install an identity into the machine-wide slot and PROVE the write landed.
+*
+* The four install sites here used to ignore `io.writeSlot()`'s boolean. On
+* Windows that write is a PowerShell cold start that compiles a C# P/Invoke
+* shim, so on a loaded machine it can exceed its own timeout and return false
+* WITHOUT touching the slot (reproduced 2026-10-23 while probing: a delete
+* followed by a write reported false and left the slot empty). The run then
+* spawned anyway and authenticated as whichever account was already installed —
+* silently spending the wrong account's quota, which is the exact corruption
+* class this module exists to prevent. One retry, then refuse.
+*/
+function installSlotOrThrow(io, raw, log, label) {
+	if (io.writeSlot(raw)) return;
+	log("[agy-link] credential slot write failed for " + label + " — retrying once");
+	if (io.writeSlot(raw)) return;
+	throw new SlotUnavailableError("could not install the " + label + " credential into the Windows credential slot (the write was rejected) — refusing to run, because agy would authenticate as whichever account is already in the slot");
+}
+/** Restore path: never fail a teardown, but say so loudly. */
+function installSlotBestEffort(io, raw, log, label) {
+	try {
+		installSlotOrThrow(io, raw, log, label);
+	} catch (err) {
+		log("[agy-link] WARNING: could not restore the " + label + " credential into the slot (" + (err instanceof Error ? err.message : String(err)) + ") — the next run re-installs it");
+	}
+}
 let primaryFastRuns = 0;
 /** The secondary identity currently installed in the slot, if any. */
 let installedIdentity = null;
@@ -28866,6 +29005,54 @@ function releaseSwitchTarget(key) {
 function fastPathRunCount() {
 	return primaryFastRuns + (installedIdentity?.holders ?? 0);
 }
+/** Default ceiling for holding the slot while waiting for the first event. */
+const SLOT_HANDOFF_TIMEOUT_MS = 45e3;
+/**
+* Arrange for a credential-slot lease to be released after the startup read.
+*
+* Correctness rests on the caller's spawn ordering, which does not change: the
+* identity is installed UNDER the mutex immediately before the spawn, so
+* whatever a later switcher does cannot affect a run that is already past its
+* read. The residual exposure is a mid-run 401 forcing a re-auth (agy would
+* then read whatever identity is installed at that moment); the hand-off logs
+* when it fires so that case is diagnosable instead of silent.
+*/
+function armSlotHandoff(opts) {
+	const timeoutMs = opts.timeoutMs !== void 0 && opts.timeoutMs > 0 ? opts.timeoutMs : SLOT_HANDOFF_TIMEOUT_MS;
+	const log = opts.log ?? (() => {});
+	let done = false;
+	let byTimeout = false;
+	let timer = null;
+	const clear = () => {
+		if (timer !== null) {
+			clearTimeout(timer);
+			timer = null;
+		}
+	};
+	const fire = (reason) => {
+		if (done) return;
+		done = true;
+		clear();
+		try {
+			opts.release();
+		} catch {}
+		if (reason !== "first-event") log("[agy-link] credential slot handed back at " + reason + " (no first event yet)");
+	};
+	timer = setTimeout(() => {
+		timer = null;
+		if (done) return;
+		byTimeout = true;
+		log("[agy-link] credential slot held for " + Math.round(timeoutMs / 1e3) + "s without a first event — handing it back so other sessions are not blocked");
+		fire("timeout");
+	}, timeoutMs);
+	timer.unref?.();
+	return {
+		onFirstEvent: () => fire("first-event"),
+		dispose: () => fire("run-end"),
+		released: () => done,
+		timedOut: () => byTimeout
+	};
+}
 /** True while a run is waiting for (or performing) a slot identity switch. */
 function isSlotSwitchPending() {
 	return pendingSwitchTargets.size > 0;
@@ -29072,7 +29259,7 @@ async function acquireCredentialSlot(account, pool, options = {}) {
 		if (isPrimarySlot) {
 			if (!sameCredentialGrant(io.readSlot(), primary.raw)) {
 				log("[agy-link] re-asserting the primary credential into the Windows credential slot");
-				io.writeSlot(primary.raw);
+				installSlotOrThrow(io, primary.raw, log, "primary");
 			}
 			releaseLockFileNow();
 			releaseClaim();
@@ -29090,7 +29277,7 @@ async function acquireCredentialSlot(account, pool, options = {}) {
 							}, baseDir);
 						} else if (afterRaw) {
 							log("[agy-link] credential slot changed during a primary run — restoring the primary credential");
-							io.writeSlot(primary.raw);
+							installSlotBestEffort(io, primary.raw, log, "primary");
 							writePrimaryCredential(primary, baseDir);
 						}
 					} finally {
@@ -29121,7 +29308,7 @@ async function acquireCredentialSlot(account, pool, options = {}) {
 			done();
 			throw new SlotUnavailableError(`Account ${account.alias || account.id} holds the SAME credential as the primary account — its login was overwritten. Sign this account in again to restore its own token.`);
 		}
-		io.writeSlot(accountRaw);
+		installSlotOrThrow(io, accountRaw, log, account.alias || account.id);
 		releaseLockFileNow();
 		const state = {
 			fingerprint: accountFingerprint,
@@ -29135,7 +29322,7 @@ async function acquireCredentialSlot(account, pool, options = {}) {
 					} else if (afterFingerprint !== null) log(`[agy-link] credential slot was replaced during ${account.alias || account.id}'s run — refusing to write a foreign credential into the account file`);
 				} finally {
 					try {
-						io.writeSlot(primary.raw);
+						installSlotBestEffort(io, primary.raw, log, "primary");
 					} finally {
 						done();
 					}
@@ -29543,8 +29730,19 @@ async function queryViaNodeSqlite(dbPath, sql) {
 		if (typeof mod.DatabaseSync !== "function") throw new Error("DatabaseSync missing");
 		const Database = mod.DatabaseSync;
 		nodeSqliteQuery = async (p, q) => {
-			const db = new Database(p);
+			let db;
 			try {
+				db = new Database(p, { readOnly: true });
+			} catch {
+				db = new Database(p);
+			}
+			try {
+				try {
+					db.exec("PRAGMA busy_timeout = 2000;");
+				} catch {}
+				try {
+					db.exec("PRAGMA query_only = ON;");
+				} catch {}
 				return db.prepare(q).all().map((r) => `${String(r.idx)}|${String(r.step_type)}|${typeof r.payload_hex === "string" ? r.payload_hex : ""}`);
 			} finally {
 				db.close();
@@ -29557,9 +29755,13 @@ async function queryViaNodeSqlite(dbPath, sql) {
 	return nodeSqliteQuery(dbPath, sql);
 }
 /**
-* Copy the agy SQLite DB to a temp path (avoiding WAL lock issues), then
-* query tool and thought step payloads — node:sqlite first, sqlite3 CLI as
-* the fallback reader.
+* Query tool and thought step payloads directly from the agy SQLite DB —
+* node:sqlite first, sqlite3 CLI as the fallback reader.
+*
+* Direct read avoids the file-copy busy loop on macOS (issue #52) where
+* libuv uv_fs_copyfile spins at 100% CPU if an active WAL file is truncated
+* during copy. SQLite WAL mode provides concurrent read MVCC snapshots
+* natively without copying to temp.
 */
 async function loadAgyDbData(conversationId, accountHome) {
 	const steps = /* @__PURE__ */ new Map();
@@ -29576,26 +29778,34 @@ async function loadAgyDbData(conversationId, accountHome) {
 		thoughts,
 		seenSteps
 	};
-	let tmpDir = null;
-	const tmpDb = join(tmpdir(), `agy-db-${conversationId.slice(0, 8)}-${Date.now()}.db`);
 	try {
-		tmpDir = await mkdtemp(join(tmpdir(), "agy-db-"));
-		const target = join(tmpDir, "conversation.db");
-		await copyFile(dbPath, target);
-		await chmod(target, 384).catch(() => void 0);
-		try {
-			await copyFile(dbPath + "-wal", target + "-wal");
-		} catch {}
-		try {
-			await copyFile(dbPath + "-shm", target + "-shm");
-		} catch {}
+		if ((await stat(dbPath)).size === 0) return {
+			steps,
+			thoughts,
+			seenSteps
+		};
+	} catch {
+		return {
+			steps,
+			thoughts,
+			seenSteps
+		};
+	}
+	try {
 		const sql = `SELECT idx, step_type, hex(step_payload) AS payload_hex FROM steps WHERE (step_type IN (5,7,8,9,14,15,17,21,33,101,132,138,139)) AND length(step_payload) > 20`;
 		let lines = null;
 		try {
-			lines = await queryViaNodeSqlite(target, sql);
+			lines = await queryViaNodeSqlite(dbPath, sql);
 		} catch {
 			try {
-				const { stdout } = await execFileAsync("sqlite3", [target, sql], {
+				const { stdout } = await execFileAsync("sqlite3", [
+					"-cmd",
+					".timeout 2000",
+					"-cmd",
+					"PRAGMA query_only = ON;",
+					dbPath,
+					sql
+				], {
 					timeout: 5e3,
 					encoding: "utf-8",
 					maxBuffer: 26214400
@@ -29640,24 +29850,6 @@ async function loadAgyDbData(conversationId, accountHome) {
 				console.error("[dsh-agy-link] agy conversation DB unavailable (" + String(err) + ") — falling back to stream-carried metadata only" + (code === "ENOENT" ? "; install the sqlite3 CLI for full tool args and thoughts" : ""));
 			} catch {}
 		}
-	} finally {
-		if (tmpDir !== null) try {
-			await rm(tmpDir, {
-				recursive: true,
-				force: true
-			});
-		} catch {}
-		else {
-			try {
-				await unlink(tmpDb);
-			} catch {}
-			try {
-				await unlink(tmpDb + "-wal");
-			} catch {}
-			try {
-				await unlink(tmpDb + "-shm");
-			} catch {}
-		}
 	}
 	return {
 		steps,
@@ -30111,6 +30303,92 @@ function brief(s) {
 	const flat = s.trim().replace(/\s+/g, " ");
 	return flat.length > 300 ? flat.slice(0, 300) + "..." : flat;
 }
+/**
+* Await `work` while periodically yielding a SESSION-VISIBLE notice.
+*
+* Why this exists: Windows has ONE machine-global credential slot, so every
+* session's agy run is serialized behind whichever session got there first.
+* A healthy long run (a 15-minute build, a 240-minute long tool) made the
+* OTHER sessions sit with a completely empty transcript for up to
+* `dispatchTimeoutMinutes` — indistinguishable from a freeze. The console
+* heartbeat was invisible to the user, so the only honest signal was "nothing
+* is happening" (2026-10-22: two sessions looked hung for 15 minutes while
+* another project's agy run held the slot).
+*
+* Resolves with `work`'s value; rejects with `work`'s rejection untouched, so
+* the caller's existing error classification is unchanged.
+*/
+async function* awaitWithNotices(work, opts) {
+	const baseInterval = opts.intervalMs > 0 ? opts.intervalMs : 3e4;
+	const escalate = opts.escalate !== void 0 && opts.escalate > 1 ? opts.escalate : 1;
+	const maxInterval = opts.maxIntervalMs !== void 0 && opts.maxIntervalMs > baseInterval ? opts.maxIntervalMs : baseInterval * 100;
+	let intervalMs = baseInterval;
+	const startedAt = Date.now();
+	let settled = null;
+	let wake = null;
+	const ping = () => {
+		const resume = wake;
+		wake = null;
+		resume?.();
+	};
+	work.then((value) => {
+		if (settled === null) {
+			settled = {
+				ok: true,
+				value
+			};
+			ping();
+		}
+	}, (error) => {
+		if (settled === null) {
+			settled = {
+				ok: false,
+				error
+			};
+			ping();
+		}
+	});
+	let pendingNotices = 0;
+	let timer = null;
+	const arm = () => {
+		if (timer !== null || settled !== null) return;
+		timer = setTimeout(() => {
+			timer = null;
+			pendingNotices++;
+			intervalMs = Math.min(Math.round(intervalMs * escalate), maxInterval);
+			ping();
+		}, intervalMs);
+		timer.unref?.();
+	};
+	try {
+		arm();
+		for (;;) {
+			if (settled !== null) break;
+			if (pendingNotices > 0) {
+				pendingNotices--;
+				yield {
+					type: "reasoning-delta",
+					index: -1,
+					text: opts.notice(Date.now() - startedAt) + "\n"
+				};
+				arm();
+				continue;
+			}
+			await new Promise((resolve) => {
+				wake = resolve;
+			});
+		}
+	} finally {
+		if (timer !== null) {
+			clearTimeout(timer);
+			timer = null;
+		}
+	}
+	const done = settled;
+	if (done === null) throw new Error("awaitWithNotices lost its completion signal");
+	if (done.ok) return done.value;
+	throw done.error;
+}
 function sawAuthFailure(parser, outcome) {
 	if (parser.stats.sawAuthFailure) return true;
 	if (looksLikeAuthFailure(outcome.stderrTail)) return true;
@@ -30172,6 +30450,16 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 	*/
 	rateLimitFailover = /* @__PURE__ */ new Map();
 	static RATE_LIMIT_FAILOVER_WINDOW_MS = 6e5;
+	/**
+	* sessionKey -> consecutive transport failures and when the streak started.
+	*
+	* The streak drives the 5s/15s/30s retry delay handed to DSH. A success (or
+	* any non-transport failure) clears it, and a gap longer than the window
+	* treats the next failure as a fresh streak: a user who retries a turn ten
+	* minutes after an outage must not start by waiting 30 seconds.
+	*/
+	networkStreak = /* @__PURE__ */ new Map();
+	static NETWORK_STREAK_WINDOW_MS = 6e5;
 	constructor(deps) {
 		super();
 		this.deps = deps;
@@ -30181,6 +30469,39 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 		this.warnedKeys.add(key);
 		this.deps.log?.("WARNING: " + msg);
 	}
+	/**
+	* Record one transport failure and return the streak position (1-based).
+	* Position drives the delay requested from DSH.
+	*/
+	noteNetworkFailure(sessionKey) {
+		if (sessionKey === "") return 1;
+		const now = Date.now();
+		const prev = this.networkStreak.get(sessionKey);
+		const count = (prev === void 0 || now - prev.at > AgyAdapter.NETWORK_STREAK_WINDOW_MS ? 0 : prev.count) + 1;
+		this.networkStreak.set(sessionKey, {
+			count,
+			at: now
+		});
+		return count;
+	}
+	/** Drop the transport streak: the session reached Google (or failed another way). */
+	clearNetworkStreak(sessionKey) {
+		if (sessionKey === "") return;
+		this.networkStreak.delete(sessionKey);
+	}
+	/**
+	* Whether every enabled account leaves through the same proxy.
+	*
+	* A shared egress makes a transport failure a property of the machine's
+	* network, not of the account: rotating the sticky pointer repoints the
+	* session for nothing and spends the rotation budget a real quota or
+	* eligibility hop needs (live 2026-10-21: one flapping proxy produced EOFs
+	* on every account and the turn still rotated the pool).
+	*/
+	sharesSingleEgress() {
+		const fallback = (this.deps.getConfig().proxyUrl ?? "").trim() || (detectSystemProxy() ?? "");
+		return accountsShareSingleEgress(this.deps.pool?.getAccounts() ?? [], fallback);
+	}
 	/** Mark a session prompt as no longer in flight so retries are not debounced. */
 	clearInFlightPrompt(sessionKey, prompt) {
 		if (sessionKey === "") return;
@@ -30199,6 +30520,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 	*/
 	claimFailover(sessionKey, code) {
 		if (!isAccountScopedFailure(code)) return false;
+		if (code === Err.NETWORK && this.sharesSingleEgress()) return true;
 		const enabled = (this.deps.pool?.getAccounts() ?? []).filter((a) => a.enabled).length;
 		const max = Math.max(1, enabled - 1);
 		const now = Date.now();
@@ -30253,10 +30575,10 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 		if (enabledAccounts >= 2) retryableCodes.push(Err.AUTH);
 		return {
 			mode: "normal",
-			maxRetries: enabledAccounts >= 3 ? 2 : 1,
+			maxRetries: Math.max(enabledAccounts >= 3 ? 2 : 1, NETWORK_RETRY_DELAYS_MS.length),
 			retryableCodes,
 			initialDelayMs: 2e3,
-			maxDelayMs: 1e4,
+			maxDelayMs: 45e3,
 			jitterRatio: .1
 		};
 	}
@@ -30266,10 +30588,20 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 			name: "Antigravity (agy CLI)"
 		};
 	}
+	getActiveAccount() {
+		if (!this.deps.pool) return void 0;
+		const pool = this.deps.pool;
+		const activeId = pool.getActiveAccountId("google") ?? pool.getPoolData().lastActiveAccountId ?? pool.getPoolData().primaryAccountId;
+		return activeId ? pool.getAccount(activeId) : void 0;
+	}
 	async listModels(_provider) {
-		this.deps.catalog.refreshIfNeeded();
+		const activeAcc = this.getActiveAccount();
+		this.deps.catalog.refreshIfNeeded(activeAcc?.id);
 		const cfg = this.deps.getConfig();
-		const { entries, dropped } = sanitizeCatalogEntries(this.deps.catalog.get().models);
+		const cat = this.deps.catalog.get(activeAcc?.id);
+		let models = cat.models;
+		if (!activeAcc || !accountHasArgon(activeAcc, this.deps.pool, cat)) models = models.filter((m) => !isArgonModel(m.id));
+		const { entries, dropped } = sanitizeCatalogEntries(models);
 		if (dropped.length > 0) this.warnOnce("catalog-dupes", "model catalog contained duplicate ids [" + dropped.join(", ") + "] — kept first occurrence so DSH does not drop the whole provider group (INVALID_CATALOG)");
 		const hidden = new Set(cfg.hiddenModels.map((s) => s.trim()));
 		return entries.filter((m) => !hidden.has(m.id)).map((m) => ({
@@ -30280,8 +30612,9 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 		}));
 	}
 	async resolveModel(_provider, model, _signal) {
+		const activeAcc = this.getActiveAccount();
 		const cfg = this.deps.getConfig();
-		const cat = this.deps.catalog.get();
+		const cat = this.deps.catalog.get(activeAcc?.id);
 		const rawModel = typeof model === "string" ? model.trim() : "";
 		const cleanId = rawModel !== "" ? rawModel : cfg.defaultModel;
 		const entry = findEntry(cat, cleanId);
@@ -30411,7 +30744,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 			}
 			if (rec !== void 0) {
 				this.deps.runs.forget(continuation.runId);
-				this.warnOnce("dead-continuation:" + continuation.runId, "agy run " + continuation.runId + " settled in " + (deadFailure?.code ?? "") + " — retrying this step on another account instead of replaying it");
+				this.warnOnce("dead-continuation:" + continuation.runId, "agy run " + continuation.runId + " settled in " + (deadFailure?.code ?? "") + " — retrying this step instead of replaying it" + (deadFailure?.code === Err.NETWORK && this.sharesSingleEgress() ? " on the same account (shared egress)" : " on another account"));
 			} else this.warnOnce("stale-continuation:" + continuation.runId, "agy run " + continuation.runId + " is no longer available in memory (server restarted?) — falling back to fresh turn prompt assembly");
 		}
 		const catalog = this.deps.catalog.get();
@@ -30467,18 +30800,24 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 		if (model === "" && activeModel !== "" && !isAux && sessionKey !== "") this.deps.syncSessionModel?.(sessionKey, activeModel, options.reasoningEffort ? String(options.reasoningEffort) : void 0);
 		let account;
 		if (this.deps.pool && !isAux && sessionKey !== "") {
-			const prefix = `${sessionKey}:`;
-			let mostRecentAccount;
-			let latestUpdated = -1;
-			for (const [k, b] of Object.entries(this.deps.store.all())) if (k.startsWith(prefix) && b.updatedAt > latestUpdated) {
-				const boundId = k.slice(prefix.length);
-				const boundAcc = this.deps.pool.getAccount(boundId);
-				if (boundAcc) {
-					mostRecentAccount = boundAcc;
-					latestUpdated = b.updatedAt;
-				} else this.deps.store.delete(k);
-			}
-			if (mostRecentAccount && this.deps.pool.isAccountEligible(mostRecentAccount, family)) account = mostRecentAccount;
+			if (process.platform === "win32" && cfg.parallelSameAccount) {
+				const poolActive = this.deps.pool.selectAccount(family);
+				if (poolActive) account = poolActive;
+			}
+			if (!account) {
+				const prefix = `${sessionKey}:`;
+				let mostRecentAccount;
+				let latestUpdated = -1;
+				for (const [k, b] of Object.entries(this.deps.store.all())) if (k.startsWith(prefix) && b.updatedAt > latestUpdated) {
+					const boundId = k.slice(prefix.length);
+					const boundAcc = this.deps.pool.getAccount(boundId);
+					if (boundAcc) {
+						mostRecentAccount = boundAcc;
+						latestUpdated = b.updatedAt;
+					} else this.deps.store.delete(k);
+				}
+				if (mostRecentAccount && this.deps.pool.isAccountEligible(mostRecentAccount, family)) account = mostRecentAccount;
+			}
 		}
 		if (!account && this.deps.pool) account = this.deps.pool.selectAccount(family) ?? void 0;
 		if (this.deps.pool && this.deps.pool.getAccounts().length > 0 && !account) {
@@ -30603,7 +30942,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				if (binding.interrupted === true) prompt = "[the previous turn was interrupted before it finished — do not continue or answer that unfinished work; respond only to the newest request below]\n\n" + prompt;
 			}
 		}
-		if (cfg.forwardSystemPrompt) {
+		if (cfg.forwardSystemPrompt || isReview) {
 			const sysInstruction = options.system || (() => {
 				const sm = messages.find((m) => m.role === "system");
 				return sm ? textOf(sm).trim() : "";
@@ -30773,6 +31112,8 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 		const dispatchHardCapMs = cfg.dispatchTimeoutMinutes > 0 ? cfg.dispatchTimeoutMinutes * 6e4 : 0;
 		const dispatchStartedAt = Date.now();
 		const DISPATCH_HEARTBEAT_MS = 12e4;
+		/** First session-visible "waiting for the slot" notice (then ×3 each time). */
+		const DISPATCH_NOTICE_MS = 2e4;
 		let dispatchHeartbeat = null;
 		const stopDispatchHeartbeat = () => {
 			if (dispatchHeartbeat !== null) {
@@ -30809,9 +31150,22 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 		let granted = false;
 		let dispatchBackoffMs = 2e3;
 		const maxDispatchAttempts = 1 + Math.max(0, cfg.dispatchRetries);
+		let abandonedDuringDispatch = false;
+		let dispatchSettled = false;
 		try {
 			for (let attempt = 1; attempt <= maxDispatchAttempts && !granted; attempt++) try {
-				release = await this.deps.acquire(options.signal);
+				const pendingConcurrencySlot = this.deps.acquire(options.signal);
+				pendingConcurrencySlot.then((late) => {
+					if (abandonedDuringDispatch) try {
+						late();
+					} catch {}
+				}, () => {});
+				release = yield* awaitWithNotices(pendingConcurrencySlot, {
+					intervalMs: DISPATCH_NOTICE_MS,
+					escalate: 3,
+					maxIntervalMs: 54e4,
+					notice: (waitedMs) => "[agy] 正在等待 agy 凭据槽：另一个会话正在运行（已等待 " + Math.max(1, Math.round(waitedMs / 6e4)) + " 分钟）。同一台机器同一时刻只能有一个 agy 身份占用系统凭据槽；稍候会自动开始，按 Stop 可取消。\n[agy] waiting for the agy credential slot: another session is running (" + Math.max(1, Math.round(waitedMs / 6e4)) + "m elapsed)."
+				});
 				startDispatchHeartbeat();
 				slotLease = process.env.NODE_TEST_CONTEXT === void 0 ? await acquireCredentialSlot(account ?? void 0, this.deps.pool, {
 					baseDir: this.deps.pool?.dir,
@@ -30829,6 +31183,11 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				if (e instanceof WaitTimeoutError) {
 					if (attempt < maxDispatchAttempts) {
 						this.deps.log?.("agy dispatch attempt " + attempt + "/" + maxDispatchAttempts + " timed out after " + cfg.dispatchTimeoutMinutes + "m waiting for the credential slot — releasing and retrying in " + Math.round(dispatchBackoffMs / 1e3) + "s");
+						yield {
+							type: "reasoning-delta",
+							index: -1,
+							text: "[agy] 等待 agy 凭据槽已超过 " + cfg.dispatchTimeoutMinutes + " 分钟，正在重新排队（" + Math.round(dispatchBackoffMs / 1e3) + " 秒后重试 " + (attempt + 1) + "/" + maxDispatchAttempts + "）。\n[agy] credential-slot wait exceeded " + cfg.dispatchTimeoutMinutes + "m — re-queueing (attempt " + (attempt + 1) + "/" + maxDispatchAttempts + ").\n"
+						};
 						stopDispatchHeartbeat();
 						await dispatchSleep(dispatchBackoffMs);
 						dispatchBackoffMs = Math.min(dispatchBackoffMs * 2, 15e3);
@@ -30839,18 +31198,30 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				const detail = e instanceof SlotUnavailableError ? e.message : brief(String(e));
 				throw new LlmError(detail, Err.AGY_ERROR);
 			}
+			dispatchSettled = true;
 		} catch (e) {
+			dispatchSettled = true;
 			stopDispatchHeartbeat();
 			this.clearInFlightPrompt(sessionKey, prompt);
 			throw e;
+		} finally {
+			if (!dispatchSettled) abandonedDuringDispatch = true;
 		}
 		stopDispatchHeartbeat();
-		const releaseOnce = () => {
-			if (released) return;
-			released = true;
+		let slotHandoff = null;
+		const releaseSlotLease = () => {
+			if (slotHandoff !== null) {
+				slotHandoff.dispose();
+				return;
+			}
 			try {
 				slotLease?.release();
 			} catch {}
+		};
+		const releaseOnce = () => {
+			if (released) return;
+			released = true;
+			releaseSlotLease();
 			release?.();
 			release = null;
 		};
@@ -30897,6 +31268,14 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				}
 				this.lastAccountSpawnTime.set(account.id, Date.now());
 			}
+			if (slotLease !== void 0) slotHandoff = armSlotHandoff({
+				release: () => {
+					try {
+						slotLease?.release();
+					} catch {}
+				},
+				log: (msg) => this.deps.log?.(msg)
+			});
 			proc = startAgyProcess({
 				bin,
 				args,
@@ -30909,6 +31288,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				stderrKeepalive: true,
 				onLine: (line) => {
 					sawAnyEvent = true;
+					slotHandoff?.onFirstEvent();
 					lastOutputAt = Date.now();
 					startToolHeartbeat();
 					applyToolIdleBudget();
@@ -31048,12 +31428,17 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 					message: "agy produced no result event (" + parser.stats.garbage + " unparseable lines)"
 				};
 			}
+			if (failure !== null) {
+				if (failure.code === Err.NETWORK) failure.retryAfterMs = networkRetryDelayMs(this.noteNetworkFailure(sessionKey));
+				else this.clearNetworkStreak(sessionKey);
+			}
 			rec.settle(failure);
 			const superseded = this.activeRuns.get(sessionKey) !== void 0 && this.activeRuns.get(sessionKey) !== rec;
 			if (failure === null) {
 				if (account) this.deps.pool?.recordSuccess(account.id, family);
 				this.failoverBudget.delete(sessionKey);
 				this.rateLimitFailover.delete(sessionKey);
+				this.clearNetworkStreak(sessionKey);
 				if (!isAux && sessionAccountKey !== "" && !superseded) {
 					const finalId = binding !== void 0 ? binding.conversationId : conversationId;
 					if (finalId) this.deps.store.set(sessionAccountKey, {
@@ -31068,7 +31453,8 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				if (account && !outcome.aborted && looksLikeHardRateLimit(rawErrText)) this.deps.pool?.recordFailure(account.id, family, failure.message);
 				if (account && silentTimeout) this.deps.pool?.advanceAccount(account.id, family);
 				if (account && failure.code === Err.ELIGIBILITY) this.deps.pool?.advanceAccount(account.id, family);
-				if (!outcome.aborted && failure.code !== Err.RATE_LIMIT && failure.code !== Err.OVERLOADED && (failure.code === Err.NETWORK || failure.code === Err.AUTH) && account) this.deps.pool?.advanceAccount(account.id, family);
+				const sharedEgressNetwork = failure.code === Err.NETWORK && this.sharesSingleEgress();
+				if (!outcome.aborted && failure.code !== Err.RATE_LIMIT && failure.code !== Err.OVERLOADED && !sharedEgressNetwork && (failure.code === Err.NETWORK || failure.code === Err.AUTH) && account) this.deps.pool?.advanceAccount(account.id, family);
 				if (account && shouldMarkAuthRequired(failure.code, failure.message)) {
 					const authoritative = isAuthoritativeAuthError(rawErrText + " " + runLogText);
 					if (failure.code === Err.AUTH && !authoritative) this.deps.pool?.noteAuthFailure(account.id, failure.message);
@@ -31244,7 +31630,7 @@ var AgyAdapter = class AgyAdapter extends LlmAdapter {
 				}
 				if (!mapper.isFinished && !abortedLocally && !signal?.aborted) {
 					const f = rec.failureInfo;
-					if (f !== null) for (const ch of mapper.emitFailure(f.kind, f.code, f.message)) queue.push(ch);
+					if (f !== null) for (const ch of mapper.emitFailure(f.kind, f.code, f.message, f.retryAfterMs)) queue.push(ch);
 					else for (const ch of mapper.emitFailure("error", Err.INVALID_OUTPUT, "agy stream ended without a result event")) queue.push(ch);
 				}
 			} catch (err) {
@@ -32584,6 +32970,174 @@ var PoolAuthFlow = class {
 	}
 };
 //#endregion
+//#region src/host/agy-usage.ts
+function num(v) {
+	return typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : void 0;
+}
+function str(v) {
+	return typeof v === "string" && v.trim() !== "" ? v.trim() : void 0;
+}
+function normalizeBucket(raw) {
+	const id = str(raw.id);
+	if (id === void 0) return null;
+	return {
+		id,
+		name: str(raw.name),
+		window: (str(raw.window) ?? "").toLowerCase(),
+		remainingFraction: num(raw.remaining_fraction ?? raw.remainingFraction),
+		resetTime: str(raw.reset_time ?? raw.resetTime)
+	};
+}
+/** Pull groups out of one `command_result` envelope. */
+function groupsFromCommandResult(parsed) {
+	const command = parsed.command;
+	if (command === void 0 || command.name !== "usage") return null;
+	const rawGroups = command.data?.groups;
+	if (!Array.isArray(rawGroups) || rawGroups.length === 0) return null;
+	const groups = [];
+	for (const g of rawGroups) {
+		if (g === null || typeof g !== "object") continue;
+		const group = g;
+		const name = str(group.name);
+		if (name === void 0) continue;
+		const buckets = [];
+		if (Array.isArray(group.buckets)) for (const b of group.buckets) {
+			if (b === null || typeof b !== "object") continue;
+			const bucket = normalizeBucket(b);
+			if (bucket !== null) buckets.push(bucket);
+		}
+		groups.push({
+			name,
+			description: str(group.description),
+			buckets
+		});
+	}
+	return groups.length > 0 ? groups : null;
+}
+/**
+* Parse `agy -p /usage --output-format stream-json` stdout.
+*
+* Primary shape: one NDJSON line carrying a `command_result` event with
+* `command.name === "usage"`. Fallback: the plain-text table mode
+* (`<group>\t<window label>\t<pct>%\t<reset ISO>`), which the CLI prints when
+* run without `--output-format stream-json`.
+*
+* Returns null when nothing usable was found — callers keep their fallback data.
+*/
+function parseAgyUsageOutput(stdout) {
+	const lines = stdout.split(/\r?\n/);
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("{")) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			continue;
+		}
+		if (parsed === null || typeof parsed !== "object") continue;
+		const obj = parsed;
+		if (obj.event !== "command_result") continue;
+		const groups = groupsFromCommandResult(obj);
+		if (groups !== null) return groups;
+	}
+	return parseUsageTextTable(stdout);
+}
+/** `<group>\t<label>\t<pct>%\t<reset>` rows; weekly labels carry "week". */
+function parseUsageTextTable(text) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const raw of text.split(/\r?\n/)) {
+		const line = raw.trim();
+		if (line === "") continue;
+		const cells = line.split("	");
+		if (cells.length < 3) continue;
+		const [groupName, label, pctCell] = cells;
+		const pct = Number.parseFloat(pctCell.replace("%", "").trim());
+		if (!Number.isFinite(pct)) continue;
+		const window = /week/i.test(label) ? "weekly" : "5h";
+		let group = byName.get(groupName);
+		if (group === void 0) {
+			group = {
+				name: groupName,
+				buckets: []
+			};
+			byName.set(groupName, group);
+		}
+		group.buckets.push({
+			id: `${groupName.toLowerCase().replace(/\s+/g, "-")}-${window}`,
+			name: label,
+			window,
+			remainingFraction: Math.min(1, Math.max(0, pct / 100)),
+			resetTime: cells[3]?.trim() || void 0
+		});
+	}
+	return byName.size > 0 ? [...byName.values()] : null;
+}
+/**
+* Map CLI groups onto pool families.
+*
+* Order matters: the Argon group's description mentions "Gemini quota bucket",
+* so the Argon gate must run before the generic Gemini one or the two groups
+* collapse into `google` and overwrite each other.
+*/
+function usageGroupsToFamilies(groups, now = Date.now()) {
+	const out = {};
+	if (groups === null) return out;
+	for (const group of groups) {
+		const name = group.name.toLowerCase();
+		const desc = (group.description ?? "").toLowerCase();
+		const hasArgonBucket = group.buckets.some((b) => b.id.toLowerCase().includes("argon"));
+		const isArgon = name.includes("argon") || desc.includes("argon") || hasArgonBucket;
+		const isGoogle = !isArgon && (name.includes("gemini") || desc.includes("gemini"));
+		const is3P = name.includes("claude") || name.includes("gpt") || desc.includes("claude") || desc.includes("gpt");
+		const families = isArgon ? ["argon"] : isGoogle ? ["google"] : is3P ? ["anthropic", "openai"] : [];
+		if (families.length === 0) continue;
+		let fiveHourFrac;
+		let fiveHourReset;
+		let weeklyFrac;
+		let weeklyReset;
+		for (const bucket of group.buckets) {
+			const w = (bucket.window || bucket.id).toLowerCase();
+			if (w.includes("week")) {
+				weeklyFrac = bucket.remainingFraction;
+				weeklyReset = bucket.resetTime;
+			} else if (w.includes("5h") || w.includes("five")) {
+				fiveHourFrac = bucket.remainingFraction;
+				fiveHourReset = bucket.resetTime;
+			}
+		}
+		for (const family of families) out[family] = {
+			remainingFraction: fiveHourFrac,
+			resetTime: fiveHourReset,
+			weeklyFraction: weeklyFrac,
+			weeklyResetTime: weeklyReset,
+			description: group.description,
+			updatedAt: now
+		};
+	}
+	return out;
+}
+/** Spawn one `agy -p /usage` and parse its groups. Never throws, never rejects. */
+async function readAgyUsage(opts) {
+	try {
+		return parseAgyUsageOutput((await startAgyProcess({
+			bin: opts.bin,
+			args: [
+				"-p",
+				"/usage",
+				"--output-format",
+				"stream-json"
+			],
+			timeoutMs: opts.timeoutMs ?? 2e4,
+			signal: opts.signal,
+			env: opts.env,
+			preemptAutoUpdate: opts.preemptAutoUpdate
+		}).outcome).stdout);
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/host/quota.ts
 /**
 * When the quota-summary endpoint transiently fails, per-model fallback
@@ -32597,6 +33151,56 @@ function mergeFallbackFamilyQuota(prev, fallback) {
 	if (prev && typeof prev.remainingFraction === "number") return prev;
 	return fallback;
 }
+/**
+* True when any returned group is the dedicated Argon bucket.
+*
+* The backend stops emitting that group once the plan folds Argon into the
+* larger Gemini bucket (Ultra). From then on the family is governed by the
+* shared bucket, so a cooldown recorded against the retired pool — e.g. a 429
+* taken minutes before an upgrade — must not keep blocking the family for days.
+*/
+function summaryHasArgonGroup(groups) {
+	return groups.some((group) => {
+		const fields = [group.displayName, group.description];
+		for (const bucket of group.buckets ?? []) fields.push(bucket.bucketId, bucket.displayName);
+		return fields.some((value) => typeof value === "string" && value.toLowerCase().includes("argon"));
+	});
+}
+/**
+* Decide whether a family's cooldown belongs to a quota bucket that no longer exists.
+*
+* A cooldown is recorded against the pool that produced the 429. A plan change can
+* retire that pool — a Pro → Ultra upgrade folds Argon into the larger Gemini bucket
+* and the backend stops emitting the `Gemini 4 Argon` group — leaving a cooldown that
+* blocks the family until a reset that no longer applies:
+*
+*   All Antigravity accounts are unavailable: no account can serve argon right now
+*   (1 in cooldown) (earliest reset in 345338s)
+*
+* `groupSeenBefore` is what keeps this from firing on accounts that never had the
+* group at all (free tier, or any plan without an Argon bucket): their argon
+* cooldowns come from genuine 429s and must survive.
+*/
+function shouldReleaseOrphanedCooldown(state) {
+	return state.summaryAuthoritative && !state.groupPresent && state.groupSeenBefore && state.hasCooldown;
+}
+/**
+* Pick the family fraction when this poll's summary carried no group for it.
+*
+* An *authoritative* summary (at least one group returned) means the absence is
+* real: the family lost its own bucket — a Pro → Ultra upgrade folds the
+* separate Argon pool into the larger Gemini bucket, and the backend then stops
+* reporting a `Gemini 4 Argon` group entirely while `fetchAvailableModels`
+* keeps listing the argon models with fresh per-model fractions. Keeping the
+* last-known-good row there would freeze a dead window on screen (0%, a reset
+* time from the previous tier).
+*
+* A failed or empty summary is the case `mergeFallbackFamilyQuota` protects:
+* nothing authoritative arrived, so the previous complete value stays.
+*/
+function pickFamilyQuota(prev, fresh, summaryAuthoritative) {
+	return summaryAuthoritative ? fresh : mergeFallbackFamilyQuota(prev, fresh);
+}
 function detectEmailFromAgyLogs(homeDir) {
 	const logDir = join(homeDir, ".gemini", "antigravity-cli", "log");
 	if (!existsSync(logDir)) return void 0;
@@ -32615,9 +33219,25 @@ function detectEmailFromAgyLogs(homeDir) {
 	} catch {}
 }
 const OAUTH_USERINFO_URL = "https://www.googleapis.com/oauth2/v1/userinfo";
+/** Used when the installed agy version is unknown or older than AGY_UA_MIN_VERSION. */
+const AGY_UA_FALLBACK_VERSION = "1.4.5";
+function semverAtLeast(candidate, floor) {
+	if (!candidate) return false;
+	const a = candidate.match(/^(\d+)\.(\d+)\.(\d+)$/);
+	const b = floor.match(/^(\d+)\.(\d+)\.(\d+)$/);
+	if (!a || !b) return false;
+	for (let i = 1; i <= 3; i += 1) {
+		const x = Number(a[i]);
+		const y = Number(b[i]);
+		if (x !== y) return x > y;
+	}
+	return true;
+}
 /** Platform-faithful agy User-Agent (hardcoding darwin/arm64 on Windows is a bad fingerprint). */
-function agyUserAgent(version = "2.24.0") {
-	return `antigravity/${version} ${process.platform === "win32" ? "windows" : process.platform}/${process.arch === "x64" ? "amd64" : process.arch}`;
+function agyUserAgent(version) {
+	const os = process.platform === "win32" ? "windows" : process.platform;
+	const arch = process.arch === "x64" ? "amd64" : process.arch;
+	return `antigravity/cli/${semverAtLeast(version, "1.3.0") ? version : AGY_UA_FALLBACK_VERSION} (aidev_client; os_type=${os}; arch=${arch}; auth_method=consumer)`;
 }
 /** Coerce an expiry value (ISO string, epoch millis, or epoch seconds) to ms. */
 function parseExpiryMs(value) {
@@ -32662,6 +33282,24 @@ function isStale5hBucket(remainingFraction, resetTime, now = Date.now()) {
 	const resetMs = Date.parse(resetTime) - now;
 	return resetMs > 162e5 && resetMs < 1872e4;
 }
+/** How close two ISO reset stamps must be to name the SAME quota window. */
+const QUOTA_WINDOW_MATCH_TOLERANCE_MS = 3e5;
+/**
+* True when two reset stamps point at the same quota window.
+*
+* `fetchAvailableModels` returns a per-model `quotaInfo` with NO window label:
+* for some accounts it carries the 5-hour bucket, for others the WEEKLY bucket
+* (live: daoxzeex@gmail.com reports the weekly fraction + weekly reset on every
+* Gemini model). The only reliable discriminator is the reset instant — it
+* matches exactly one of the `retrieveUserQuotaSummary` buckets.
+*/
+function sameQuotaWindow(a, b, toleranceMs = QUOTA_WINDOW_MATCH_TOLERANCE_MS) {
+	if (!a || !b) return false;
+	const ta = Date.parse(a);
+	const tb = Date.parse(b);
+	if (!Number.isFinite(ta) || !Number.isFinite(tb)) return false;
+	return Math.abs(ta - tb) <= toleranceMs;
+}
 /**
 * Parse a go-keyring payload (optionally "go-keyring-base64:" prefixed) into
 * a normalized StoredToken. Shared by the macOS and Linux keyring readers.
@@ -32828,6 +33466,8 @@ async function readWindowsCredentialToken() {
 var QuotaService = class {
 	pool;
 	globalProxy;
+	agyVersion;
+	cliDeps;
 	preferredEndpointIndex = 0;
 	/** accountId -> in-flight getValidAccessToken attempt (dedup). */
 	tokenRefreshInFlight = /* @__PURE__ */ new Map();
@@ -32835,9 +33475,31 @@ var QuotaService = class {
 	* @param globalProxy resolves the plugin-wide proxy URL; used when the
 	* account has no dedicated proxyUrl. Injected so tests stay network-free.
 	*/
-	constructor(pool, globalProxy = () => "") {
+	constructor(pool, globalProxy = () => "", agyVersion = () => null, cliDeps = {}) {
 		this.pool = pool;
 		this.globalProxy = globalProxy;
+		this.agyVersion = agyVersion;
+		this.cliDeps = cliDeps;
+	}
+	/**
+	* One `agy -p /usage` spawn under this account's own home/proxy, mapped onto
+	* pool families. Returns null when the CLI is missing, fails or reports
+	* nothing — the caller then falls back to REST-derived quotas.
+	*/
+	async readCliUsageFamilies(account) {
+		const bin = this.cliDeps.bin?.();
+		if (!bin) return null;
+		const groups = await readAgyUsage({
+			bin,
+			env: {
+				...process.env,
+				...account.dir ? isolatedHomeEnv(account.dir) : {},
+				...proxyEnvFor(this.proxyFor(account))
+			},
+			timeoutMs: 2e4,
+			preemptAutoUpdate: this.cliDeps.preemptAutoUpdate?.()
+		});
+		return groups === null ? null : usageGroupsToFamilies(groups);
 	}
 	/** Dedicated account proxy wins, then the global config proxy, then detected system proxy. */
 	proxyFor(account) {
@@ -33002,7 +33664,7 @@ var QuotaService = class {
 			headers: {
 				Authorization: `Bearer ${accessToken}`,
 				"Content-Type": "application/json",
-				"User-Agent": agyUserAgent()
+				"User-Agent": agyUserAgent(this.agyVersion())
 			},
 			body: JSON.stringify({})
 		}, proxyUrl);
@@ -33052,7 +33714,7 @@ var QuotaService = class {
 			headers: {
 				Authorization: `Bearer ${accessToken}`,
 				"Content-Type": "application/json",
-				"User-Agent": agyUserAgent()
+				"User-Agent": agyUserAgent(this.agyVersion())
 			},
 			body: JSON.stringify({})
 		}, proxyUrl);
@@ -33085,7 +33747,7 @@ var QuotaService = class {
 					headers: {
 						Authorization: `Bearer ${accessToken}`,
 						"Content-Type": "application/json",
-						"User-Agent": agyUserAgent()
+						"User-Agent": agyUserAgent(this.agyVersion())
 					},
 					body: JSON.stringify({})
 				}, proxyUrl);
@@ -33130,6 +33792,15 @@ var QuotaService = class {
 			const siblingEmails = new Set(this.pool.getAccounts().filter((a) => a.id !== account.id && a.email).map((a) => a.email));
 			if (detected && !siblingEmails.has(detected)) email = detected;
 		}
+		if (this.cliDeps.viaCli?.() !== false) {
+			const cliFamilies = await this.readCliUsageFamilies(account);
+			if (cliFamilies !== null && Object.keys(cliFamilies).length > 0) {
+				if (account.authRequired) this.pool.clearAuthRequired(account.id);
+				if (cliFamilies.argon) this.pool.noteDedicatedGroup(account.id, "argon");
+				this.pool.updateAccountQuotas(account.id, cliFamilies, email);
+				return cliFamilies;
+			}
+		}
 		const accessToken = await this.getValidAccessToken(account);
 		if (!accessToken) return null;
 		if (force) {
@@ -33241,24 +33912,32 @@ var QuotaService = class {
 			});
 			const isStale = stale5hFamilies.has(fam);
 			if (!familyQuotas[fam]) {
-				familyQuotas[fam] = mergeFallbackFamilyQuota(account.quotas[fam], {
+				familyQuotas[fam] = pickFamilyQuota(account.quotas[fam], {
 					remainingFraction: remaining,
 					resetTime,
 					updatedAt: now
-				});
+				}, summaryGroups.length > 0);
 				if (fam === "argon" && familyQuotas[fam].weeklyFraction === void 0) {
 					familyQuotas[fam].weeklyFraction = remaining;
 					familyQuotas[fam].weeklyResetTime = resetTime;
 				}
 			} else {
-				if (remaining < (familyQuotas[fam].remainingFraction ?? 1) || isStale) {
-					familyQuotas[fam].remainingFraction = remaining;
-					familyQuotas[fam].resetTime = resetTime;
+				const familyQuota = familyQuotas[fam];
+				if (sameQuotaWindow(resetTime, familyQuota.weeklyResetTime) && !sameQuotaWindow(resetTime, familyQuota.resetTime)) {
+					if (remaining < (familyQuota.weeklyFraction ?? 1)) {
+						familyQuota.weeklyFraction = remaining;
+						familyQuota.weeklyResetTime = resetTime;
+					}
+					continue;
+				}
+				if (remaining < (familyQuota.remainingFraction ?? 1) || isStale) {
+					familyQuota.remainingFraction = remaining;
+					familyQuota.resetTime = resetTime;
 					stale5hFamilies.delete(fam);
 				}
-				if (fam === "argon" && familyQuotas[fam].weeklyFraction === void 0) {
-					familyQuotas[fam].weeklyFraction = remaining;
-					familyQuotas[fam].weeklyResetTime = resetTime;
+				if (fam === "argon" && familyQuota.weeklyFraction === void 0) {
+					familyQuota.weeklyFraction = remaining;
+					familyQuota.weeklyResetTime = resetTime;
 				}
 			}
 		}
@@ -33266,6 +33945,18 @@ var QuotaService = class {
 			const fam = famKey;
 			if (familyQuotas[fam]) familyQuotas[fam].models = list;
 		}
+		if (summaryGroups.length > 0) {
+			if (summaryHasArgonGroup(summaryGroups)) this.pool.noteDedicatedGroup(account.id, "argon");
+			else if (shouldReleaseOrphanedCooldown({
+				summaryAuthoritative: true,
+				groupPresent: false,
+				groupSeenBefore: this.pool.hasDedicatedGroup(account.id, "argon"),
+				hasCooldown: account.cooldowns?.argon !== void 0
+			})) {
+				this.pool.forgetDedicatedGroup(account.id, "argon");
+				this.pool.clearCooldown(account.id, "argon");
+			}
+		}
 		this.pool.updateAccountQuotas(account.id, familyQuotas, email);
 		return familyQuotas;
 	}
@@ -33303,6 +33994,12 @@ var QuotaService = class {
 				if (detected && detected !== acc.email) this.pool.resetAccountIdentity(acc.id, detected);
 			}
 			accounts = accounts.filter((acc) => shouldPollAccount(acc) || needsAuthReverify(acc));
+			for (let i = 0; i < accounts.length; i++) {
+				const acc = accounts[i];
+				await this.refreshAccountQuota(acc, false).catch(() => null);
+				if (i < accounts.length - 1) await new Promise((resolve) => setTimeout(resolve, 2e3));
+			}
+			return;
 		}
 		await Promise.allSettled(accounts.map((acc) => this.refreshAccountQuota(acc, force)));
 	}
@@ -33747,7 +34444,11 @@ function apply(ctx, entryConfig = {}) {
 	const version = () => versionCache;
 	const store = new SessionStore(join(stateDir(), "sessions.json"));
 	const pool = new AccountPoolManager();
-	const quota = new QuotaService(pool, () => getConfig().proxyUrl || detectSystemProxy() || "");
+	const quota = new QuotaService(pool, () => getConfig().proxyUrl || detectSystemProxy() || "", version, {
+		bin: () => bin(),
+		viaCli: () => getConfig().quotaViaCli,
+		preemptAutoUpdate: () => getConfig().suppressAgyAutoUpdate
+	});
 	const semaphore = new Semaphore(() => getConfig().maxConcurrent);
 	const getDiscoveryEnv = (account) => {
 		const cfg = getConfig();
@@ -33763,12 +34464,13 @@ function apply(ctx, entryConfig = {}) {
 			...proxyEnvFor(account?.proxyUrl || cfg.proxyUrl || detectSystemProxy() || void 0)
 		};
 	};
-	const catalog = new ModelCatalog(async (signal) => {
+	const catalog = new ModelCatalog(async (signal, accountId) => {
 		const b = bin();
 		if (!b) throw new Error("agy binary not found");
 		const poolData = pool.getPoolData();
-		const primaryAcc = poolData.primaryAccountId ? pool.getAccount(poolData.primaryAccountId) : void 0;
-		const candidateAccount = primaryAcc && primaryAcc.enabled && !primaryAcc.authRequired ? primaryAcc : pool.getAccounts().find((a) => a.enabled && !a.authRequired);
+		const targetAcc = accountId ? pool.getAccount(accountId) : void 0;
+		const activeId = pool.getActiveAccountId("google") ?? poolData.lastActiveAccountId ?? poolData.primaryAccountId;
+		const candidateAccount = targetAcc && targetAcc.enabled && !targetAcc.authRequired ? targetAcc : (activeId ? pool.getAccount(activeId) : void 0) ?? (poolData.primaryAccountId ? pool.getAccount(poolData.primaryAccountId) : void 0) ?? pool.getAccounts().find((a) => a.enabled && !a.authRequired);
 		let out = await probeProcess(b, ["models"], 3e4, signal, getDiscoveryEnv(candidateAccount), getConfig().suppressAgyAutoUpdate);
 		if ((out.code !== 0 || out.stdout.includes("Please sign in") || /sign in|auth|not logged in/i.test(out.stderrTail)) && (!candidateAccount || !candidateAccount.dir)) {
 			const secondary = pool.getAccounts().find((a) => a.enabled && !a.authRequired && a.dir);
@@ -34441,6 +35143,7 @@ function apply(ctx, entryConfig = {}) {
 					const body = await readBody(req);
 					const id = typeof body.id === "string" ? body.id : "";
 					const ok = id !== "" && pool.setActiveAccount(id);
+					if (ok) catalog.forceRefresh(id).then(() => notifyPicker()).catch(() => notifyPicker());
 					sendJson(res, ok ? 200 : 400, {
 						ok,
 						pool: pool.getPoolData()
@@ -34577,7 +35280,7 @@ function apply(ctx, entryConfig = {}) {
 	ctx.effect(() => {
 		if (!getConfig().enabled) return () => void 0;
 		const refresh = () => {
-			quota.refreshAllQuotas().catch(() => void 0);
+			quota.refreshAllQuotas().then(() => notifyPicker()).catch(() => void 0);
 		};
 		const boot = setTimeout(refresh, 5e3);
 		boot.unref?.();