dsh-agy 0.3.1 → 0.4.0

package/lib/{accounts-CkaHhb5H.mjs → accounts-BN4h0AU4.mjs}

@@ -1,4 +1,4 @@
-import { _ as setResolvedAgyVersion, a as AGY_PLATFORM_ENUM, b as isProxyRouted, d as antigravityUserAgent, g as resolveAgyClientCredentials, l as OAUTH_TOKEN_URL, p as currentAgyVersion, t as AGY_CLIENT_ID, v as AgyAuthError, y as AgyPoolBlockedError } from "./constants-Db4tmyfb.mjs";
+import { _ as setResolvedAgyVersion, a as AGY_PLATFORM_ENUM, b as QUOTA_WINDOWS, d as antigravityUserAgent, g as resolveAgyClientCredentials, l as OAUTH_TOKEN_URL, p as currentAgyVersion, t as AGY_CLIENT_ID, v as AgyAuthError, x as isProxyRouted, y as AgyPoolBlockedError } from "./constants-BpyRirvk.mjs";
 import { a as probeFetch, l as redactCredentials, o as proxiedFetch, r as isProxyUnreachableError, t as accountFetch } from "./proxy-DfaL73mL.mjs";
 import { i as generateAntigravityRequestId, r as deriveAntigravitySessionId } from "./identity-Ci8EGc1F.mjs";
 import { i as parseRefreshParts, n as calculateTokenExpiry, r as formatRefreshParts, t as accessTokenExpired } from "./auth-DPPVFwio.mjs";
@@ -552,8 +552,6 @@ const BACKOFF_TIERS_MS = [
 	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);
@@ -725,11 +723,28 @@ function pickNextAccountIndex(accounts, currentIndex, now = Date.now(), modelOrF
 	if (enabled.length === 0) return currentIndex;
 	return (enabled.find((e) => e.index > currentIndex) ?? enabled[0]).index;
 }
-/** 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;
+/**
+* Build the soft-quota cache TTL: short when low, long when healthy.
+*
+* Driven by the MOST pressured of the two windows, because they drain on
+* different clocks: an account sitting at 90% of its 5-hour bucket but 2% of its
+* week still has to be re-measured on the short interval, or a weekly exhaustion
+* is discovered only when a request fails.
+*
+* `weeklyFraction` is the optional SECOND parameter, so the two fractions sit
+* adjacent.
+*
+* Takes NO timestamp on purpose: deciding which fractions are still meaningful is
+* `isQuotaStale`'s job, because a window whose reset has passed must not drive the
+* interval either. It applies that guard before calling in here, so both
+* arguments this function sees describe windows that still exist.
+*/
+function computeSoftQuotaCacheTtlMs(remainingFraction, weeklyFraction) {
+	if (typeof remainingFraction === "number" && remainingFraction < .15) return 6e4;
+	if (typeof weeklyFraction === "number" && weeklyFraction <= .01) return 6e4;
+	if (typeof remainingFraction !== "number" && typeof weeklyFraction !== "number") return 6e5;
+	if (typeof remainingFraction === "number" && remainingFraction < .5) return 3e5;
+	if (typeof weeklyFraction === "number" && weeklyFraction < .2) return 3e5;
 	return 9e5;
 }
 //#endregion
@@ -1065,12 +1080,195 @@ function earliestResetTime(a, b) {
 	return ta <= tb ? a : b;
 }
 /**
-* 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).
+* The families a quota group's WINDOW BUCKET ID belongs to.
+*
+* `retrieveUserQuotaSummary` labels its buckets with upstream's own counters —
+* measured ids are `gemini-5h`, `gemini-weekly`, `3p-5h`, `3p-weekly` — which
+* is the same taxonomy `modelFamilyOf` mirrors. Reading the bucket id is
+* therefore a machine-readable lookup rather than a guess at a human label.
+*
+* `3p-` maps to TWO families on purpose, and that is not a shortcut: upstream
+* counts Claude and GPT under one third-party counter, so the weekly budget
+* belongs to both. No model-id prefix rule can recover that split, which is why
+* the mapping lives here rather than in `modelFamilyOf`.
+*
+* Window-aware as of #56: a bucket id resolves a family only when the window it
+* describes is one `CachedQuota` can hold AND the id agrees with the token (see
+* `agreedWindowKind`). The prefix and the window were two independent decisions
+* once, and an unrecognized window still claimed a family.
+*/
+function familiesForBucketId(bucketId, window) {
+	const id = bucketId.toLowerCase();
+	const families = [];
+	if (id.startsWith("gemini-")) families.push("google");
+	else if (id.startsWith("3p-") || id.startsWith("third_party-")) families.push("anthropic", "openai");
+	else if (id.startsWith("claude-")) families.push("anthropic");
+	else if (id.startsWith("gpt-") || id.startsWith("openai-")) families.push("openai");
+	if (families.length === 0) return [];
+	const declared = window === void 0 ? advertisedWindowOf(id) : window.toLowerCase();
+	if (declared === void 0 || agreedWindowKind(id, declared) === void 0) return [];
+	return families;
+}
+/**
+* The families a group's LABEL covers, consulted only when no bucket id was
+* recognizable.
+*
+* Upstream's groups are its own taxonomy, not ours, and the measured labels are
+* `Gemini Models` and `Claude and GPT models` — the second spans two families,
+* so this is a 1-to-N mapping. It is a FALLBACK, not the primary rule: matching
+* words in a display string is the fragile half, and it survives only so that a
+* bucket id upstream renames still lands somewhere sensible.
+*
+* A label naming nothing we recognize maps to NO family deliberately.
+* Attributing an unknown group's budget to `google` would block healthy
+* accounts; leaving it unmapped only means that family stays unmeasured, which
+* is exactly the state before this function existed.
+*/
+function familiesForGroupName(name) {
+	const label = name.toLowerCase();
+	const families = [];
+	if (label.includes("gemini") || label.includes("google")) families.push("google");
+	const claude = label.includes("claude");
+	const gpt = label.includes("gpt");
+	if (claude && gpt) families.push("anthropic", "openai");
+	else if (claude) families.push("anthropic");
+	else if (gpt) families.push("openai");
+	return families;
+}
+/**
+* Which of the two tracked windows an upstream token names, or `undefined` for a
+* token `CachedQuota` has no field for (`daily`, `monthly`).
+*
+* Read from `QUOTA_WINDOWS` (`types.ts`), the SAME table `adapter/quota-summary`
+* orders windows by. These were two independent tables once, and the gap between
+* them was a real defect: `daily` was orderable in the parser but unknown here, so
+* the group materialized an empty record that overwrote a live measurement. One
+* table makes that drift structurally impossible rather than merely tested for.
+*
+* Lookup is exact on the measured vocabulary (`5h`, `weekly`). A variant spelling
+* therefore classifies as unknown — which is safe, because the guard in
+* `ingestQuotaGroups` then skips the record rather than emptying it, and the
+* per-model probe still supplies the 5-hour reading.
+*/
+function windowKind(window) {
+	return QUOTA_WINDOWS[window.toLowerCase()]?.kind;
+}
+/** The window token a bucket id advertises, when it ends with one upstream names. */
+function advertisedWindowOf(bucketId) {
+	const id = bucketId.toLowerCase();
+	const token = id.slice(id.lastIndexOf("-") + 1);
+	return QUOTA_WINDOWS[token] ? token : void 0;
+}
+/**
+* The field a window belongs in, decided from an AGREED (id, token) pair — or
+* `undefined` when the pair cannot be agreed.
+*
+* The family used to come from the bucket id's prefix while the field came from
+* the window token, as two independent decisions nothing checked against each
+* other. A bucket whose window the cache cannot hold still claimed the family,
+* and its reading was then filed by whichever field the TOKEN named. `gemini-weekly`
+* declaring `5h` is the shape that puts a multi-day weekly fraction into
+* `remainingFraction` (the 5-hour field), where `isFamilyDrained` and
+* `parseFutureResetMs` block the account for days on a window they misread.
+*
+* Refusing an unagreed pair is deliberately the strict option: the permissive
+* mapping is exactly the coupling that let two window vocabularies drift into
+* destroying a measurement. A bucket id that advertises no recognizable token is
+* held to the declared one alone, so a rename does not silently disable the cache.
 */
-function ingestFamilyQuotas(discovered) {
+function agreedWindowKind(bucketId, window) {
+	const declared = window.toLowerCase();
+	const kind = windowKind(declared);
+	if (kind === void 0) return void 0;
+	const advertised = advertisedWindowOf(bucketId);
+	if (advertised !== void 0 && advertised !== declared) return void 0;
+	return kind;
+}
+/** The families one group belongs to: its bucket ids first, its label second. */
+function familiesForGroup(group) {
+	const families = [];
+	const add = (family) => {
+		if (!families.includes(family)) families.push(family);
+	};
+	for (const window of group.windows) for (const family of familiesForBucketId(window.bucketId, window.window)) add(family);
+	if (families.length === 0) for (const family of familiesForGroupName(group.name)) add(family);
+	return families;
+}
+/**
+* Aggregate the grouped `retrieveUserQuotaSummary` windows into per-family
+* records — the ONLY source of the weekly window.
+*
+* `fetchAvailableModels` cannot supply it: its `quotaInfo` carries exactly
+* `remainingFraction` and `resetTime`, with no window field at all, which is why
+* a weekly limit used to be invisible to rotation.
+*
+* Two groups can land on one family (upstream may split `3p` later), so the
+* family record keeps the MOST pressured reading of each window across those
+* groups (`Math.min` below) rather than letting the last group win — the same
+* rule the per-model merge uses.
+*
+* WITHIN one group the rule is deliberately different: `??=` keeps upstream's
+* FIRST bucket of each window, because a group is upstream's own 5h + weekly
+* pair and a duplicate would otherwise depend on upstream's ordering. "Most
+* pressured" therefore applies to two GROUPS landing on one family, not to two
+* buckets inside one group.
+*/
+function ingestQuotaGroups(groups) {
 	const families = /* @__PURE__ */ new Map();
+	for (const group of groups) {
+		const keys = familiesForGroup(group);
+		if (keys.length === 0) continue;
+		let rolling;
+		let weekly;
+		for (const window of group.windows) {
+			const kind = agreedWindowKind(window.bucketId, window.window);
+			if (kind === "rolling") rolling ??= window;
+			else if (kind === "weekly") weekly ??= window;
+		}
+		for (const key of keys) {
+			const current = families.get(key);
+			const record = { ...current };
+			if (typeof rolling?.remainingFraction === "number") {
+				record.remainingFraction = current?.remainingFraction === void 0 ? rolling.remainingFraction : Math.min(current.remainingFraction, rolling.remainingFraction);
+				const resetTime = earliestResetTime(current?.resetTime, rolling.resetTime ?? void 0);
+				if (resetTime) record.resetTime = resetTime;
+			}
+			if (typeof weekly?.remainingFraction === "number") {
+				record.weeklyFraction = current?.weeklyFraction === void 0 ? weekly.remainingFraction : Math.min(current.weeklyFraction, weekly.remainingFraction);
+				const weeklyResetTime = earliestResetTime(current?.weeklyResetTime, weekly.resetTime ?? void 0);
+				if (weeklyResetTime) record.weeklyResetTime = weeklyResetTime;
+			}
+			if (record.remainingFraction === void 0 && record.weeklyFraction === void 0 && !current) continue;
+			families.set(key, record);
+		}
+	}
+	return Object.fromEntries(families);
+}
+/**
+* Aggregate a `fetchAvailableModels` response, and when available the grouped
+* `retrieveUserQuotaSummary` windows, into per-family quota records.
+*
+* The two sources describe the same counters from different angles, so they are
+* merged rather than kept apart:
+*   - per MODEL `quotaInfo.remainingFraction` is the rolling 5-hour counter, and
+*     the family takes its most-pressured model (the bottleneck resets first);
+*   - per GROUP summary windows add the weekly budget, which has no per-model
+*     representation at all.
+*
+* `previous` is the account's existing cache, and it exists so a probe that
+* reports only one of the two windows cannot ERASE the other. The measured
+* reason: `fetchQuotaSummary` returns `[]` instead of throwing, so without the
+* carry-forward one timing-out endpoint would drop a known-drained weekly window
+* and put an exhausted account straight back into rotation.
+*
+* Carrying that value is safe next to a fresh 5-hour reading because it keeps its
+* own `weeklyResetTime`: once that moment passes, `isFamilyDrained` and
+* `parseFutureResetMs` both ignore the reading, so a stale weekly cannot outlive
+* the window it describes.
+*/
+function ingestFamilyQuotas(discovered, groups, previous) {
+	const families = /* @__PURE__ */ new Map();
+	if (groups && groups.length > 0) for (const [key, quota] of Object.entries(ingestQuotaGroups(groups))) families.set(key, { ...quota });
 	for (const [modelId, entry] of Object.entries(discovered.models ?? {})) {
 		const remaining = entry.quotaInfo?.remainingFraction;
 		if (typeof remaining !== "number" || !Number.isFinite(remaining)) continue;
@@ -1078,28 +1276,89 @@ function ingestFamilyQuotas(discovered) {
 		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,
+			...current,
+			remainingFraction: current?.remainingFraction === void 0 ? remaining : Math.min(current.remainingFraction, remaining),
 			...resetTime ? { resetTime } : {},
 			modelCount: (current?.modelCount ?? 0) + 1
 		});
 	}
+	if (previous) for (const [key, prev] of Object.entries(previous)) {
+		const current = families.get(key);
+		if (prev.weeklyFraction === void 0) continue;
+		if (current?.weeklyFraction !== void 0) continue;
+		families.set(key, {
+			...current,
+			weeklyFraction: prev.weeklyFraction,
+			...current?.weeklyResetTime === void 0 && prev.weeklyResetTime !== void 0 ? { weeklyResetTime: prev.weeklyResetTime } : {}
+		});
+	}
 	return Object.fromEntries(families);
 }
-/** The quota record for one family, or the most-pressured family when the model is unknown. */
-function familyQuotaFor(account, family) {
+/**
+* The lowest fraction a record reports across its LIVE windows — its overall
+* pressure.
+*
+* A window whose reset has already passed describes a window that no longer
+* exists, so it does not count — the same rule `isQuotaStale` applies when it
+* sizes the TTL from the selected record. Scoring a dead window would let one
+* family's expired weekly reading win the selection and represent the account,
+* masking another family's live pressure (issue #69: a dead weekly at 0.004
+* beat a live 0.2 and stretched the refresh TTL from 5 to 15 minutes).
+*
+* `undefined` means the record carries no usable LIVE reading at all, which is
+* deliberately different from a measured zero: only a real number can size a
+* refresh interval.
+*/
+function pressureScore(entry, now) {
+	const fractions = [];
+	if (typeof entry.remainingFraction === "number" && Number.isFinite(entry.remainingFraction) && !resetInPast(entry.resetTime, now)) fractions.push(entry.remainingFraction);
+	if (typeof entry.weeklyFraction === "number" && Number.isFinite(entry.weeklyFraction) && !resetInPast(entry.weeklyResetTime, now)) fractions.push(entry.weeklyFraction);
+	return fractions.length === 0 ? void 0 : Math.min(...fractions);
+}
+/**
+* The quota record for one family, or the most-pressured family when the model
+* is unknown.
+*
+* "Most pressured" compares BOTH windows and reports the record whose LOWEST
+* window is the lowest of all of them. That matters because `isQuotaStale` sizes
+* the refresh TTL from whichever record this returns: a family at 0.9 / weekly
+* 0.004 is more pressured than one at 0.2, and comparing the 5-hour fraction
+* alone picked the 0.2 record — so the weekly-driven 60s TTL was never applied
+* to the family actually being requested and a spent week was discovered late.
+*
+* A record carrying ONLY a weekly reading participates for the same reason: #48
+* produces that shape legitimately (the anthropic/openai entries of a
+* Gemini-only pool), and the old `typeof entry.remainingFraction !== 'number'`
+* guard skipped it outright, leaving the week invisible to TTL sizing.
+*
+* Selection considers LIVE windows only (`pressureScore` drops a window whose
+* reset has passed) — but the with-family path returns the record as-is either
+* way, because its consumers guard each window individually.
+*
+* @param account - the account whose cache to read.
+* @param family - the exact family's record; omit to select the most pressured.
+* @param now - current time (Unix ms), which decides whether a window is live.
+*/
+function familyQuotaFor(account, family, now = Date.now()) {
 	const cache = account.cachedQuota ?? {};
 	if (family) return cache[family];
 	let worst;
+	let worstScore;
 	for (const entry of Object.values(cache)) {
-		if (typeof entry.remainingFraction !== "number") continue;
-		if (!worst || entry.remainingFraction < (worst.remainingFraction ?? 1)) worst = entry;
+		const score = pressureScore(entry, now);
+		if (score === void 0) continue;
+		if (worstScore === void 0 || score < worstScore) {
+			worst = entry;
+			worstScore = score;
+		}
 	}
 	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);
+	const mostPressured = familyQuotaFor(account, void 0, now);
+	const ttl = computeSoftQuotaCacheTtlMs(resetInPast(mostPressured?.resetTime, now) ? void 0 : mostPressured?.remainingFraction, resetInPast(mostPressured?.weeklyResetTime, now) ? void 0 : mostPressured?.weeklyFraction);
 	return now - account.cachedQuotaUpdatedAt > ttl;
 }
 /** How long a measured 5h/weekly window snapshot stays fresh. */
@@ -1125,20 +1384,26 @@ function isLimitsStale(account, now = Date.now()) {
 	if (typeof updatedAt !== "number" || !Number.isFinite(updatedAt)) return true;
 	return now - updatedAt > LIMITS_CACHE_TTL_MS;
 }
-/** 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;
+/** Whether a reset moment has already passed. An absent or malformed one has not. */
+function resetInPast(resetTime, now) {
+	if (!resetTime) return false;
+	const reset = Date.parse(resetTime);
+	return !Number.isNaN(reset) && reset <= now;
 }
 /**
 * 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).
+*
+* DELIBERATELY FIVE-HOUR ONLY, and this is a decision rather than an omission.
+* The weekly window influences `blockedUntil` and `hot` instead of the ranking
+* ORDER, because a week is not a spend-by deadline: the `DAY_MS` clamp below
+* caps the horizon at 24h, so a weekly reset ~5 days out would report ~24h of
+* urgency for a budget that cannot be spent faster to any benefit — and every
+* family would then be ranked by a number that no longer distinguishes them.
+* Making this weekly-aware therefore means replacing that clamp with a horizon
+* the weekly window can actually express, not adding a second fraction to the
+* numerator.
 */
 function requiredDrainFor(quota, now = Date.now()) {
 	const remaining = quota?.remainingFraction;
@@ -1160,6 +1425,32 @@ function parseFutureResetMs(resetTime, now) {
 	return reset;
 }
 /**
+* Whether the requested family on this account is effectively quota-exhausted
+* for account STEERING (affinity pins, the active-account preference): an
+* explicit quota-exhausted cooldown in force, a spent 5-hour window
+* (`remainingFraction <= 0` with a future reset), or a weekly window at or
+* below `WEEKLY_QUOTA_THRESHOLD` — a spent week refills in days, so its rule
+* mirrors `isFamilyDrained`'s weekly branch rather than the block wall.
+*
+* Deliberately a DIFFERENT predicate from the one in `pickAccount`'s `!picked`
+* branch, which applies a strict zero to BOTH windows to mirror
+* `rankPoolCandidates`' block wall when classifying `AgyPoolBlockedError`; and
+* deliberately NARROWER than `isFamilyDrained`'s 5-hour rule
+* (`SOFT_QUOTA_THRESHOLD`): account prioritization holds a chosen account
+* until it is actually spent, not until ranking would prefer another one.
+*/
+function isFamilyQuotaExhausted(account, family, now = Date.now()) {
+	if (account.cooldownReason === "quota-exhausted" && (account.coolingDownUntil ?? 0) > now) return true;
+	const quota = familyQuotaFor(account, family);
+	if (!quota) return false;
+	const spent = (fraction, resetTime, threshold = 0) => {
+		if (typeof fraction !== "number" || fraction > threshold || !resetTime) return false;
+		const resetMs = parseFutureResetMs(resetTime, now);
+		return resetMs !== void 0 && resetMs > now;
+	};
+	return spent(quota.remainingFraction, quota.resetTime, 0) || spent(quota.weeklyFraction, quota.weeklyResetTime, .01);
+}
+/**
 * 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
@@ -1171,16 +1462,22 @@ function rankPoolCandidates(entries, modelId, now = Date.now(), startIndex = 0)
 	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 quota = familyQuotaFor(account, family, now);
+		const live5h = quota !== void 0 && !resetInPast(quota.resetTime, now);
+		const liveWeekly = quota !== void 0 && !resetInPast(quota.weeklyResetTime, now);
+		const remaining = live5h ? quota.remainingFraction : void 0;
 		const used = typeof remaining === "number" ? Math.min(Math.max(1 - remaining, 0), 1) : void 0;
+		const weeklyRemaining = liveWeekly ? quota.weeklyFraction : void 0;
+		const weeklyUsed = typeof weeklyRemaining === "number" ? Math.min(Math.max(1 - weeklyRemaining, 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 (blockedUntil === null && quota) {
+			const resetMs = typeof remaining === "number" && remaining <= 0 ? parseFutureResetMs(quota.resetTime, now) : void 0;
 			if (resetMs !== void 0) blockedUntil = resetMs;
+			const weeklyResetMs = typeof weeklyRemaining === "number" && weeklyRemaining <= 0 ? parseFutureResetMs(quota.weeklyResetTime, now) : void 0;
+			if (weeklyResetMs !== void 0) blockedUntil = blockedUntil === null ? weeklyResetMs : Math.max(blockedUntil, weeklyResetMs);
 		}
 		return {
 			account,
@@ -1189,8 +1486,8 @@ function rankPoolCandidates(entries, modelId, now = Date.now(), startIndex = 0)
 			blockedUntil,
 			usedFraction: used,
 			requiredDrain: requiredDrainFor(quota, now),
-			hot: used !== void 0 && used >= .85,
-			measured: used !== void 0
+			hot: used !== void 0 && used >= .85 || weeklyUsed !== void 0 && weeklyUsed >= .85,
+			measured: used !== void 0 || weeklyUsed !== void 0
 		};
 	});
 	candidates.sort((left, right) => {
@@ -1381,6 +1678,22 @@ var AgySessionManager = class AgySessionManager {
 	refreshInFlight = /* @__PURE__ */ new Map();
 	/** In-flight quota fetches keyed by account: concurrent selections share one fetchAvailableModels call. */
 	quotaRefreshInFlight = /* @__PURE__ */ new Map();
+	/**
+	* In-flight `retrieveUserQuotaSummary` probes keyed by account.
+	*
+	* ONE promise per account per cycle, shared by BOTH consumers:
+	* `refreshLimits` (display, writes `cachedLimits`) and `refreshQuotaCache`
+	* (scheduling, writes `cachedQuota`). Since #48 both read the same endpoint for
+	* the same account, so a stale account paid two round trips where one would
+	* do; `quotaRefreshInFlight` de-duplicated only WITHIN the scheduling path.
+	* Sharing makes the two caches agree on what upstream actually said.
+	*
+	* It carries the FETCH and nothing else: the invariant that `refreshLimits`
+	* must never write `cachedQuota` (which `rankPoolCandidates` turns into a
+	* `blockedUntil`) is about WHERE a result lands, and each path still decides
+	* that for itself.
+	*/
+	quotaSummaryInFlight = /* @__PURE__ */ new Map();
 	failureCounts = /* @__PURE__ */ new Map();
 	/** Accounts whose request-time project discovery already failed (no retry per request). */
 	projectRetryFailed = /* @__PURE__ */ new Set();
@@ -1488,6 +1801,28 @@ var AgySessionManager = class AgySessionManager {
 	clearAffinityForAccount(accountKey) {
 		for (const [conversation, pin] of this.affinity) if (pin.key === accountKey) this.affinity.delete(conversation);
 	}
+	/**
+	* Clear all session affinity pins.
+	*
+	* Called when an account is explicitly activated by the user, so all
+	* ongoing and upcoming conversations immediately steer to the newly
+	* activated account rather than staying pinned to the previous one.
+	*/
+	clearAllAffinity() {
+		this.affinity.clear();
+	}
+	/**
+	* Explicitly activate an account by index: sets `storage.activeIndex = index`,
+	* clears session affinity pins so conversations immediately switch to the
+	* activated account, and resets transient failure counts.
+	*/
+	async activateAccount(index) {
+		await this.store.mutate((storage) => {
+			if (index < 0 || index >= storage.accounts.length) throw new Error("account not found");
+			storage.activeIndex = index;
+		});
+		this.clearAllAffinity();
+	}
 	constructor(options) {
 		this.store = options.store;
 		this.onRotate = options.onRotate;
@@ -1592,6 +1927,49 @@ var AgySessionManager = class AgySessionManager {
 		return this.refreshToken(key, account, cached);
 	}
 	/**
+	* Probe `retrieveUserQuotaSummary` for one account, sharing ONE in-flight
+	* promise with every other caller in this cycle.
+	*
+	* Returns `[]` on any failure — the fetch itself already answers a dead
+	* endpoint with an empty list — so both consumers read "no groups" the same
+	* way. The promise is dropped as soon as it settles, so the NEXT cycle
+	* re-probes.
+	*
+	* The account's proxy is honoured here or the call would egress direct and
+	* leak the account's real IP, and one timeout bounds the whole endpoint
+	* fallback chain.
+	*/
+	probeQuotaSummary(account) {
+		const key = this.accountKey(account);
+		const existing = this.quotaSummaryInFlight.get(key);
+		if (existing) return existing;
+		const probe = (async () => {
+			try {
+				const auth = await this.accessTokenFor(account);
+				if (!auth) return [];
+				const { fetchQuotaSummary } = await import("./quota-summary-adID82I2.mjs");
+				const routed = accountFetch({ proxyUrl: account.proxy });
+				const bounded = (input, init) => {
+					const timeout = AbortSignal.timeout(AgySessionManager.QUOTA_FETCH_TIMEOUT_MS);
+					const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+					return routed(input, {
+						...init,
+						signal
+					});
+				};
+				return await fetchQuotaSummary(auth.access, account.projectId, bounded);
+			} catch {
+				return [];
+			}
+		})();
+		this.quotaSummaryInFlight.set(key, probe);
+		const release = () => {
+			if (this.quotaSummaryInFlight.get(key) === probe) this.quotaSummaryInFlight.delete(key);
+		};
+		probe.then(release, release);
+		return probe;
+	}
+	/**
 	* Refresh the display-only 5h/weekly windows for every enabled account.
 	*
 	* SEPARATE from `refreshQuotaCache`, and deliberately so. That method writes
@@ -1639,22 +2017,7 @@ var AgySessionManager = class AgySessionManager {
 		const probes = await Promise.all(targets.map(async (account) => {
 			const key = this.accountKey(account);
 			try {
-				const auth = await this.accessTokenFor(account);
-				if (!auth) return {
-					key,
-					ok: false
-				};
-				const { fetchQuotaSummary } = await import("./quota-summary-5CypVffd.mjs");
-				const routed = accountFetch({ proxyUrl: account.proxy });
-				const bounded = (input, init) => {
-					const timeout = AbortSignal.timeout(AgySessionManager.QUOTA_FETCH_TIMEOUT_MS);
-					const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
-					return routed(input, {
-						...init,
-						signal
-					});
-				};
-				const groups = await fetchQuotaSummary(auth.access, account.projectId, bounded);
+				const groups = await this.probeQuotaSummary(account);
 				if (groups.length === 0) return {
 					key,
 					ok: false
@@ -1716,16 +2079,18 @@ var AgySessionManager = class AgySessionManager {
 				try {
 					const auth = await this.accessTokenFor(account);
 					if (!auth) return null;
-					const { fetchAvailableModels } = await import("./models-BGuwl50d.mjs").then((n) => n.r);
+					const { fetchAvailableModels } = await import("./models-Qn0-sh6X.mjs").then((n) => n.r);
 					const routed = accountFetch({ proxyUrl: account.proxy });
-					const quotas = ingestFamilyQuotas(await fetchAvailableModels(auth.access, account.projectId, (input, init) => {
+					const bounded = (input, init) => {
 						const timeout = AbortSignal.timeout(AgySessionManager.QUOTA_FETCH_TIMEOUT_MS);
 						const signal = init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
 						return routed(input, {
 							...init,
 							signal
 						});
-					}));
+					};
+					const [discovered, groups] = await Promise.all([fetchAvailableModels(auth.access, account.projectId, bounded), this.probeQuotaSummary(account)]);
+					const quotas = ingestFamilyQuotas(discovered, groups, account.cachedQuota);
 					return {
 						key,
 						quotas,
@@ -1765,7 +2130,8 @@ var AgySessionManager = class AgySessionManager {
 	}
 	/**
 	* 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
+	* healthy, and not quota-exhausted for the requested model; the explicitly
+	* activated account wins next while it is usable; otherwise the pool is
 	* ranked by family-scoped usage (OMP-aligned) and the best candidate wins.
 	*/
 	async pickAccount(storage, model, conversationKey) {
@@ -1778,7 +2144,7 @@ var AgySessionManager = class AgySessionManager {
 			const lastIndex = storage.accounts.findIndex((a) => this.accountKey(a) === pinnedKey);
 			if (lastIndex !== -1) {
 				const last = storage.accounts[lastIndex];
-				if (last.enabled !== false && !isCoolingDown(last, now) && !isFamilyRateLimited(last, familyKey, now) && !isFamilyDrained(last, family, now)) return {
+				if (last.enabled !== false && !isCoolingDown(last, now) && !isFamilyRateLimited(last, familyKey, now) && !isFamilyQuotaExhausted(last, family, now)) return {
 					account: last,
 					index: lastIndex
 				};
@@ -1789,15 +2155,25 @@ var AgySessionManager = class AgySessionManager {
 			index
 		})).filter(({ account }) => account.enabled !== false);
 		if (eligible.length === 0) return void 0;
+		const active = storage.accounts[storage.activeIndex];
+		const isActiveUsable = (acc) => acc !== void 0 && acc.enabled !== false && !isCoolingDown(acc, now) && !isFamilyRateLimited(acc, familyKey, now) && !isFamilyQuotaExhausted(acc, family, now);
+		if (isActiveUsable(active) && this.inFlightCount(this.accountKey(active), now) < 3) return {
+			account: active,
+			index: storage.activeIndex
+		};
 		const ranked = rankPoolCandidates(eligible, model, now, storage.activeIndex);
 		const picked = ranked.find((candidate) => candidate.blockedUntil === null && this.inFlightCount(this.accountKey(candidate.account), now) < 3) ?? 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 quota = familyQuotaFor(account, family, now);
+				if (!quota) return false;
+				const spent = (fraction, resetTime) => {
+					if (typeof fraction !== "number" || fraction > 0 || !resetTime) return false;
+					const resetAt = Date.parse(resetTime);
+					return !Number.isNaN(resetAt) && resetAt > now;
+				};
+				return spent(quota.remainingFraction, quota.resetTime) || spent(quota.weeklyFraction, quota.weeklyResetTime);
 			};
 			const retryable = ranked.filter((candidate) => !quotaExhausted(candidate.account));
 			const blocked = retryable.length > 0 ? retryable : ranked;
@@ -1885,7 +2261,7 @@ var AgySessionManager = class AgySessionManager {
 			}
 			const key = this.accountKey(picked.account);
 			if (!picked.account.projectId && !this.projectRetryFailed.has(key)) try {
-				const { loadCodeAssist } = await import("./exchange-yZPIZumk.mjs").then((n) => n.n);
+				const { loadCodeAssist } = await import("./exchange-LzEyxve1.mjs").then((n) => n.n);
 				const { projectId } = await loadCodeAssist(auth.access, { proxyUrl: picked.account.proxy });
 				if (projectId) {
 					await this.store.mutate((s) => {
@@ -1967,6 +2343,13 @@ var AgySessionManager = class AgySessionManager {
 			if (decision.action === "revoke") {
 				this.tokenCache.delete(key);
 				this.failureCounts.delete(key);
+				const currentIndex = storage.accounts.findIndex((a) => this.accountKey(a) === key);
+				const nextIndex = pickNextAccountIndex(storage.accounts, currentIndex >= 0 ? currentIndex : storage.activeIndex, Date.now());
+				if (nextIndex !== storage.activeIndex) {
+					storage.activeIndex = nextIndex;
+					nextIndexToRotate = nextIndex;
+				}
+				this.clearAffinityForAccount(key);
 				return;
 			}
 			if (kind === "rate-limit" && info?.rateLimitCategory !== "soft_rate_limit") {
@@ -1982,7 +2365,7 @@ var AgySessionManager = class AgySessionManager {
 					}
 				}
 			}
-			if (decision.action === "rotate") {
+			if (decision.action === "rotate" || decision.action === "cool") {
 				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);
@@ -2040,8 +2423,8 @@ var AgySessionManager = class AgySessionManager {
 		};
 		try {
 			const account = session.account.email ?? session.account.id;
-			const { toAgyRequestBody } = await import("./translate-BQu8HLvB.mjs").then((n) => n.n);
-			const { fetchAgyFirstOk } = await import("./constants-Db4tmyfb.mjs").then((n) => n.f);
+			const { toAgyRequestBody } = await import("./translate-YhGDUuVa.mjs").then((n) => n.n);
+			const { fetchAgyFirstOk } = await import("./constants-BpyRirvk.mjs").then((n) => n.f);
 			const { parseAgySse } = await import("./parse-Bs4rPkHA.mjs").then((n) => n.n);
 			const requestId = generateAntigravityRequestId();
 			const body = toAgyRequestBody({
@@ -2483,4 +2866,4 @@ var JsonAccountStore = class {
 //#endregion
 export { resolveMasterKeyCodec as _, generateFingerprint as a, describeFetchError as b, resolveAntigravityVersionBounded as c, MASTER_KEY_REF as d, createAesGcmCodec as f, resolveDshHome as g, persistMasterKey as h, isAgyDisabled as i, clearExpiredState as l, loadMasterKey as m, maskProxyUrl as n, recordFingerprintVersion as o, deriveKey as p, AgySessionManager as r, resolveAntigravityVersion as s, JsonAccountStore as t, pickProbeProxyUrl as u, classifyFetchError as v, isSessionAccumulationOverflow as x, classifyHttpError as y };
 
-//# sourceMappingURL=accounts-CkaHhb5H.mjs.map
+//# sourceMappingURL=accounts-BN4h0AU4.mjs.map