@eddyskywalker/dsh-chatgpt-subscription 0.12.6 → 0.13.1

package/lib/index.js

@@ -516,6 +516,17 @@ function catalogSnapshotPath(name) {
 	return path.join(dshHomeDir(), "storages", `${name}-catalog.json`);
 }
 /**
+* How many models one line's catalog holds, for the hub overview's "N/M models".
+*
+* An empty catalog is reported as `null` rather than `0`: "this line has synced
+* nothing yet" and "this line offers no models" are different statements, and
+* only the second one is a fact. The overview hides the model count for a null,
+* which is what a line that has never synced should show.
+*/
+function catalogTotal(count) {
+	return count === 0 ? null : count;
+}
+/**
 * Snapshot name for one catalog *and* one credential scope.
 *
 * A persisted snapshot answers before any credential is read — that is the whole
@@ -681,7 +692,7 @@ let snapshotRehydrated = null;
 * directly; returning it here under a different entry type would force every
 * one of them to convert it.
 */
-function getCachedCatalog() {
+function getCachedCatalog$2() {
 	return catalogCache$2?.models;
 }
 /**
@@ -740,7 +751,7 @@ async function performCatalogLoad$1(credentials, options) {
 		live = true;
 		writeCatalogSnapshot(catalogSnapshotName(SNAPSHOT_SCOPE, key), [...models], Date.now());
 	} catch {
-		models = getCachedCatalog() ?? [];
+		models = getCachedCatalog$2() ?? [];
 		live = false;
 	}
 	catalogCache$2 = {
@@ -2521,13 +2532,31 @@ var OAuthService = class {
 	*   "credentials are required" on every web search.
 	*/
 	async credentials(forceRefresh = false, access = {}) {
+		return (await this.credentialSelection(forceRefresh, access)).credentials;
+	}
+	/**
+	* The credential to use next, together with the pool row that owns it.
+	*
+	* The settings card keys each account's quota snapshot by the row the reading
+	* was made for, and the credential cannot do that job: a refresh rotates its
+	* tokens, and an account may state no id of its own. Callers that care about
+	* identity ask here; every other caller keeps using {@link credentials} and
+	* sees no difference.
+	*
+	* @param forceRefresh - refresh even a token that is not close to expiry.
+	* @param access - who is asking; see {@link credentials}.
+	*/
+	async credentialSelection(forceRefresh = false, access = {}) {
 		if (this.pool !== null) {
-			if (access.purpose === "tool") return (await this.pool.getCredentialAccount(this.fetchFn, forceRefresh)).credentials;
-			return (await this.pool.getEffectiveAccount(void 0, this.fetchFn, forceRefresh)).credentials;
+			const picked = access.purpose === "tool" ? await this.pool.getCredentialAccount(this.fetchFn, forceRefresh) : await this.pool.getEffectiveAccount(void 0, this.fetchFn, forceRefresh);
+			return {
+				accountId: picked.account.id,
+				credentials: picked.credentials
+			};
 		}
 		const stored = await this.loadAuthenticated();
-		if (forceRefresh || stored.expiresAt - this.now() <= 6e4) return this.refreshCredentials(stored);
-		return stored;
+		if (forceRefresh || stored.expiresAt - this.now() <= 6e4) return { credentials: await this.refreshCredentials(stored) };
+		return { credentials: stored };
 	}
 	dispose() {
 		if (this.disposed) return;
@@ -2823,6 +2852,49 @@ async function oauthErrorIdentifier(response) {
 	return null;
 }
 //#endregion
+//#region src/host/common/account-quota.ts
+/**
+* A reset instant as Unix milliseconds.
+*
+* Providers state this in seconds, in milliseconds, or not at all, and the two
+* numeric forms are told apart by magnitude rather than by a flag: 10^10
+* seconds is the year 2286, so anything larger is already milliseconds.
+*/
+function quotaResetMs(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return null;
+	return value > 1e10 ? value : value * 1e3;
+}
+/**
+* One window, or null when its consumed share was never measured.
+*
+* `label` may be empty: the card names an unlabeled window from its length, and
+* only falls back to a generic name when the line stated neither.
+*/
+function quotaWindow$1(label, usedPercent, options = {}) {
+	if (typeof usedPercent !== "number" || !Number.isFinite(usedPercent)) return null;
+	const windowDurationMins = typeof options.windowDurationMins === "number" && Number.isFinite(options.windowDurationMins) ? options.windowDurationMins : null;
+	return {
+		label,
+		usedPercent: Math.min(100, Math.max(0, usedPercent)),
+		windowDurationMins,
+		resetsAt: quotaResetMs(options.resetsAt)
+	};
+}
+/**
+* The snapshot to publish for one account, or undefined when there is none.
+*
+* Undefined is the honest answer for "never read" and for "read before this
+* process started": both mean the card has nothing to show, and neither means
+* the account is unspent.
+*/
+function poolQuota(fetchedAt, windows) {
+	if (typeof fetchedAt !== "number" || !Number.isFinite(fetchedAt) || fetchedAt <= 0) return void 0;
+	return {
+		windows: windows.filter((window) => window !== null),
+		fetchedAt
+	};
+}
+//#endregion
 //#region src/host/codex-account-pool.ts
 /** Encrypted pool file the ChatGPT line owns; the single-credential store stays the mirror. */
 function codexPoolPath() {
@@ -2891,13 +2963,32 @@ const concurrency = new ConcurrencyGate();
 function chatGPTConcurrency() {
 	return concurrency;
 }
+/**
+* One ChatGPT usage snapshot as the account card's per-account quota.
+*
+* A bucket lists its windows either in `windows` or, on older payloads, only as
+* the `primary`/`secondary` pair — the same fallback the quota card itself
+* applies, so the account row cannot show fewer windows than the card does. The
+* label stays empty on purpose: a ChatGPT window is named by its length, and
+* the card localizes that length in the reader's own language.
+*/
+function codexAccountQuota(snapshot) {
+	return poolQuota(snapshot.fetchedAt, snapshot.usage.buckets.flatMap((bucket) => {
+		return (bucket.windows.length > 0 ? bucket.windows : [bucket.primary, bucket.secondary].filter((window) => window !== null)).map((window) => quotaWindow$1("", window.usedPercent, {
+			windowDurationMins: window.windowDurationMins,
+			resetsAt: window.resetsAt
+		}));
+	}));
+}
 var CodexAccountPool = class extends AccountPoolCore {
 	refresherRef;
 	store;
+	quotaSnapshotRef;
 	quotaBlockedUntil;
 	constructor(options = {}) {
 		const store = options.store ?? createPlatformTokenStore();
 		const ref = {};
+		const quotaSnapshotRef = {};
 		const hooks = {
 			providerId: "codex-chatgpt",
 			displayName: "ChatGPT",
@@ -2948,7 +3039,11 @@ var CodexAccountPool = class extends AccountPoolCore {
 			extendSummary: (account, base) => ({
 				...base,
 				...account.email === void 0 ? {} : { email: account.email },
-				...account.planType === void 0 ? {} : { planLabel: account.planType }
+				...account.planType === void 0 ? {} : { planLabel: account.planType },
+				...(() => {
+					const quota = quotaSnapshotRef.current?.(account);
+					return quota === void 0 ? {} : { quota };
+				})()
 			}),
 			emptyMessage: "未登录 ChatGPT 账号，请在「设置 → 订阅服务 → ChatGPT」中添加并登录账号。",
 			...options.backend === void 0 ? {} : { backend: options.backend },
@@ -2956,6 +3051,7 @@ var CodexAccountPool = class extends AccountPoolCore {
 		};
 		super(hooks);
 		this.refresherRef = ref;
+		this.quotaSnapshotRef = quotaSnapshotRef;
 		this.store = store;
 	}
 	/** Hand the pool the OAuth service's per-account refresh implementation. */
@@ -2973,6 +3069,18 @@ var CodexAccountPool = class extends AccountPoolCore {
 	setQuotaBlockedUntil(lookup) {
 		this.quotaBlockedUntil = lookup;
 	}
+	/**
+	* Wire in the account's own newest quota snapshot, for display only.
+	*
+	* The same map that already spares an exhausted account a wasted request also
+	* answers "what did this account's window look like last time we read it".
+	* The lookup must be a memory read: it runs while the settings card builds
+	* its account list, and that page must never fan out an upstream request per
+	* pooled account.
+	*/
+	setQuotaSnapshot(lookup) {
+		this.quotaSnapshotRef.current = lookup;
+	}
 	isEligible(account, now, triedAccountIds) {
 		if (!super.isEligible(account, now, triedAccountIds)) return false;
 		const blockedUntil = this.quotaBlockedUntil?.(account, now);
@@ -4088,6 +4196,56 @@ function createControlledModelFetch(baseFetch, options) {
 	};
 }
 //#endregion
+//#region src/host/common/provider-route.ts
+/**
+* Claim one provider route for this plugin and keep claiming it.
+*
+* The route is taken immediately, and every `llm/adapters-updated` reports the
+* claim again — it is a no-op while the registration is held, and takes the
+* route back once another owner releases it. A rejected claim is remembered
+* rather than thrown, because the line whose route table asks through
+* {@link ProviderRouteClaim.conflict} still has to render.
+* @param ctx - The plugin context owning the `llm` service and the event seam.
+* @param options - The route id, the display label the two log lines name, and the adapter serving it.
+* @returns The claim's state and its disposer.
+*/
+function claimProviderRoute(ctx, options) {
+	let registration;
+	let conflict = null;
+	const claim = () => {
+		if (registration !== void 0) return;
+		try {
+			registration = ctx.llm.registerAdapter([options.providerId], options.adapter);
+			if (conflict !== null) ctx.logger.info(`[dsh-chatgpt-subscription] ${options.label} route "${options.providerId}" is now served by this plugin`);
+			conflict = null;
+		} catch (error) {
+			conflict = error instanceof Error ? error.message : String(error);
+			ctx.logger.warn(`[dsh-chatgpt-subscription] provider route "${options.providerId}" is already owned by another adapter; ${options.label} models keep being served by that one until its configuration is removed (${conflict})`);
+		}
+	};
+	claim();
+	const watch = options.watch === false || typeof ctx.on !== "function" ? void 0 : ctx.on("llm/adapters-updated", () => {
+		claim();
+	});
+	return {
+		serving: () => registration !== void 0,
+		conflict: () => conflict,
+		dispose: () => {
+			releaseHandle(watch);
+			registration?.();
+			registration = void 0;
+		}
+	};
+}
+/** Cordis event handles are either a disposer function or a disposable object. */
+function releaseHandle(handle) {
+	if (typeof handle === "function") {
+		handle();
+		return;
+	}
+	handle?.dispose?.();
+}
+//#endregion
 //#region src/host/common/request-diagnostics.ts
 /**
 * Reusable request diagnostics wrapper for model provider calls.
@@ -5126,6 +5284,100 @@ async function* wrapStreamWithWatchdog(source, upstreamSignal, timeoutMs = DEFAU
 }
 //#endregion
 //#region src/host/responses-mapper.ts
+/**
+* Base64 image payload one Codex request may carry.
+*
+* THIS ROUTE HAD NO BOUND AT ALL, which is what made a long session fail
+* intermittently (issue #50). Every turn re-inlines every image still in
+* history, so the request body grew with the number of images ever read and
+* nothing ever trimmed it. Past roughly 4 MB the transport itself gives up: the
+* report's field logs show 18/18 successes in the 3–4 MB band and 3/10 in the
+* 4–5 MB band, and a synthetic probe against the subscription endpoint returned
+* `NGHTTP2_ENHANCE_YOUR_CALM` / `NGHTTP2_INTERNAL_ERROR` on every ≥4 MB body
+* while ≤3 MB always passed.
+*
+* The NUMBER is this route's own, derived from those measurements rather than
+* borrowed. Kimi's 1.5 MB figure is sized for Kimi's 2 MB request limit and
+* would silently drop images this endpoint accepts; MiniMax's 16 MB is sized
+* for a 64 MB body ceiling this route does not have. 2 MiB of image data keeps
+* the whole body inside the band that never failed, even after the
+* conversation text, tool schemas and system prompt are added. It is a
+* transport property of this deployment, not a documented API limit, so
+* `DSH_CODEX_MAX_IMAGE_BYTES` overrides it.
+*
+* It bounds the IMAGE contribution only. A request whose text alone exceeds the
+* transport is still refused by the transport, and no image budget can fix that.
+*/
+const DEFAULT_MAX_REQUEST_IMAGE_BYTES$1 = 2 * 1024 * 1024;
+/**
+* Image budget this process enforces, honouring the deployment override.
+*
+* Parsed as bytes and ignored when it is not a positive finite number, so a
+* typo cannot silently disable the guard by producing `NaN`.
+*/
+function maxRequestImageBytes$1(env = process.env) {
+	const raw = (env.DSH_CODEX_MAX_IMAGE_BYTES ?? "").trim();
+	if (raw === "") return DEFAULT_MAX_REQUEST_IMAGE_BYTES$1;
+	const parsed = Number(raw);
+	if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_MAX_REQUEST_IMAGE_BYTES$1;
+	return Math.floor(parsed);
+}
+/**
+* Placeholder left where an over-budget image was removed. It says the picture
+* is gone rather than leaving a blank the model would answer about anyway.
+*/
+const OMITTED_IMAGE_TEXT$5 = "[image omitted to keep the request within its size limit; older images are omitted first. If this image is still needed, read its file again when a path is available; otherwise ask the user to attach it again.]";
+/**
+* Replace the oldest images with that placeholder once the built request would
+* carry more than `maxBytes` of base64 image data.
+*
+* WHY THIS RUNS ON THE BUILT INPUT rather than on `options.messages` like the
+* other routes. Two image forms reach this wire and only one of them is a
+* message block: a pasted attachment arrives as `{ type: 'image', attachment }`,
+* but the tool-read images in issue #50 arrive as local markdown links
+* (`![](/describe-image/raw/sha256:…)`) that `mapUserText` fetches and inlines
+* while building. A message-level pass cannot see the second form at all, and
+* the shared `offloadOldestRequestImages` additionally does not recurse into
+* `tool-result` content — so measuring here, after every form has become an
+* `input_image` item, is the one place that bounds what actually goes out.
+*
+* The oldest occurrences go first and durable history is untouched; only the
+* request about to be sent changes. A retry after a model fallback reuses the
+* bounded input instead of re-inflating it.
+*
+* @param input - the payload's `input` items, mutated in place.
+* @param maxBytes - base64 image budget for the whole request.
+* @returns how many images were replaced.
+*/
+function offloadOldestInputImages(input, maxBytes = maxRequestImageBytes$1()) {
+	const retained = [];
+	for (const item of input) {
+		if (!Array.isArray(item.content)) continue;
+		for (const [index, block] of item.content.entries()) {
+			if (record$3(block) === null || block.type !== "input_image") continue;
+			const url = block.image_url;
+			if (typeof url !== "string") continue;
+			retained.push({
+				content: item.content,
+				index,
+				bytes: url.length
+			});
+		}
+	}
+	let total = retained.reduce((sum, entry) => sum + entry.bytes, 0);
+	if (total <= maxBytes) return 0;
+	let omitted = 0;
+	for (const entry of retained) {
+		if (total <= maxBytes) break;
+		entry.content[entry.index] = {
+			type: "input_text",
+			text: OMITTED_IMAGE_TEXT$5
+		};
+		total -= entry.bytes;
+		omitted += 1;
+	}
+	return omitted;
+}
 function hiddenSandboxControlToolNames(options) {
 	const retryTools = recentSandboxRetryToolNames(options.messages);
 	return new Set(options.tools?.filter((tool) => hasSandboxControls(tool.parameters) && !retryTools.has(tool.name)).map((tool) => tool.name) ?? []);
@@ -5222,6 +5474,7 @@ async function buildResponsesPayload(options, attachments, localRawImages = {},
 		});
 		if (message.role === "assistant") appendMissingToolCalls(input, knownToolCalls, message, normalizeCallId);
 	}
+	offloadOldestInputImages(input);
 	const payload = {
 		model: options.model,
 		input,
@@ -5787,7 +6040,8 @@ var ResponsesClient = class {
 			});
 		} catch (cause) {
 			if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
-			throw new LlmError("Codex could not be reached.", "NETWORK", { cause });
+			const chain = errorChain(cause).trim();
+			throw new LlmError(`Codex request failed: ${chain === "" ? "the connection failed before any response arrived" : chain.slice(0, 500)}`, "NETWORK", { cause });
 		}
 	}
 };
@@ -6239,6 +6493,72 @@ function acceptIdentity(current, incoming) {
 	return typeof incoming === "string" && incoming.length > 0 ? incoming : current;
 }
 //#endregion
+//#region src/shared/hub-contracts.ts
+/**
+* Wire contracts for the subscription hub's overview route.
+*
+* The overview is the settings page's opening screen: one card per provider
+* line, annotated with how many accounts it holds and whether it is enabled.
+* Everything here is a non-secret fact a settings card may render; no
+* credential, quota figure, or upstream call ever crosses this boundary.
+*/
+/** The aggregated, read-only overview the hub's opening screen renders. */
+const HUB_OVERVIEW_PATH = `${ROUTE_PREFIX$5}/hub/overview`;
+//#endregion
+//#region src/host/hub-overview.ts
+function registerHubOverviewRoutes(ctx, sources) {
+	const handler = async (request, response) => {
+		if (request.method !== "GET") {
+			response.writeHead(405, {
+				allow: "GET",
+				"content-type": "application/json; charset=utf-8"
+			});
+			response.end(JSON.stringify({
+				ok: false,
+				error: {
+					code: "bad-request",
+					message: "Method not allowed."
+				}
+			}));
+			return;
+		}
+		const envelope = {
+			ok: true,
+			value: { providers: (await Promise.allSettled(sources.map(async (source) => ({
+				id: source.id,
+				providerId: source.providerId,
+				canToggle: source.canToggle,
+				...await source.read()
+			})))).map((result, index) => {
+				if (result.status === "fulfilled") return result.value;
+				const source = sources[index];
+				return {
+					id: source.id,
+					providerId: source.providerId,
+					canToggle: source.canToggle,
+					enabled: !source.canToggle,
+					accountCount: 0,
+					authenticated: false,
+					enabledModelCount: null,
+					totalModelCount: null,
+					error: true
+				};
+			}) }
+		};
+		response.writeHead(200, {
+			"content-type": "application/json; charset=utf-8",
+			"cache-control": "no-store",
+			"x-content-type-options": "nosniff"
+		});
+		response.end(JSON.stringify(envelope));
+	};
+	return ctx.webServer.register({
+		kind: "exact",
+		path: HUB_OVERVIEW_PATH,
+		handler
+	});
+}
+//#endregion
 //#region src/host/common/same-origin.ts
 /**
 * Whether one mutation request comes from this application's own document.
@@ -6346,9 +6666,9 @@ var UsageService = class {
 		};
 		const now = this.now();
 		if (!force && !this.invalidated && this.cache !== null && now - this.cache.fetchedAt < 6e4 && this.cacheIdentityRevision === this.oauth.currentIdentityRevision()) return this.fromCache(false);
-		let credentials;
+		let selection;
 		try {
-			credentials = await this.oauth.credentials(false, USAGE_CREDENTIAL_ACCESS);
+			selection = await this.oauth.credentialSelection(false, USAGE_CREDENTIAL_ACCESS);
 		} catch (error) {
 			const reason = error instanceof Error && error.message !== "" ? ` (${error.message})` : "";
 			return this.failure({
@@ -6356,7 +6676,8 @@ var UsageService = class {
 				message: `ChatGPT credentials could not be refreshed.${reason}`
 			});
 		}
-		const accountKey = identityKey(credentials);
+		const credentials = selection.credentials;
+		const accountKey = this.snapshotKeyFor(selection.accountId, credentials);
 		if (this.cache !== null && this.cache.accountKey !== accountKey) this.clear();
 		if (!force && !this.invalidated && this.cache !== null && now - this.cache.fetchedAt < 6e4) return this.fromCache(false);
 		if (this.cache !== null && now - this.lastUpstreamAt < 15e3) return this.fromCache(this.invalidated || now - this.cache.fetchedAt >= 6e4);
@@ -6384,9 +6705,9 @@ var UsageService = class {
 	* The rejection is absorbed here: this refresh has no caller to receive it,
 	* and {@link fromCache} keeps serving the snapshot it failed to replace.
 	*/
-	startBackgroundRefresh(credentials, accountKey) {
+	startBackgroundRefresh(credentials, snapshotKey) {
 		if (this.inFlight !== null) return;
-		const task = this.refreshUpstream(credentials, accountKey).finally(() => {
+		const task = this.refreshUpstream(credentials, snapshotKey).finally(() => {
 			if (this.inFlight === task) this.inFlight = null;
 		});
 		this.inFlight = task;
@@ -6403,8 +6724,8 @@ var UsageService = class {
 	* cooldown rather than forever, so a missing upstream field cannot strand an
 	* account permanently.
 	*/
-	blockedUntilFor(credentials, now) {
-		const snapshot = this.snapshots.get(identityKey(credentials));
+	blockedUntilFor(accountId, credentials, now) {
+		const snapshot = this.snapshots.get(this.snapshotKeyFor(accountId, credentials));
 		if (snapshot === void 0) return void 0;
 		let reopen;
 		for (const bucket of snapshot.usage.buckets) {
@@ -6417,6 +6738,32 @@ var UsageService = class {
 		}
 		return reopen !== void 0 && reopen > now ? reopen : void 0;
 	}
+	/**
+	* The newest quota snapshot held for one account, if any.
+	*
+	* Quota follows the account, so the settings card shows each account its own
+	* progress. The pool asks here with the row id it addresses the account by —
+	* the identity that survives a token refresh — while its credentials answer
+	* for a composition without a pool. This reads the remembered map only, never
+	* the network, because opening the settings page must not cost one upstream
+	* request per pooled account.
+	*/
+	snapshotFor(accountId, credentials) {
+		return this.snapshots.get(this.snapshotKeyFor(accountId, credentials));
+	}
+	/**
+	* Key one account's remembered snapshot is filed under.
+	*
+	* A pool row id when the caller names one, prefixed so it can never be
+	* confused with the credential-derived key, and otherwise the credential
+	* identity — which is all a composition without a pool has. Two pooled accounts
+	* that state neither an account id nor an email would otherwise collapse onto
+	* one key and show each other's numbers, so the row id is the answer wherever
+	* a pool is in charge.
+	*/
+	snapshotKeyFor(accountId, credentials) {
+		return accountId === void 0 || accountId === "" ? identityKey(credentials) : `row:${accountId}`;
+	}
 	/** Remember the newest snapshot for one account, bounded to the accounts in use. */
 	rememberSnapshot(accountKey, usage, fetchedAt) {
 		this.snapshots.set(accountKey, {
@@ -6436,8 +6783,8 @@ var UsageService = class {
 		this.invalidated = false;
 	}
 	/** Drop the remembered snapshot of one account, after its window is known to have reset. */
-	forgetSnapshot(credentials) {
-		this.snapshots.delete(identityKey(credentials));
+	forgetSnapshot(accountId, credentials) {
+		this.snapshots.delete(this.snapshotKeyFor(accountId, credentials));
 	}
 	async consumeResetCredit() {
 		if (this.resetConsumeInFlight !== null) return this.resetConsumeInFlight;
@@ -6448,12 +6795,17 @@ var UsageService = class {
 	}
 	async consumeResetCreditUpstream() {
 		let credentials;
+		let accountId;
 		try {
-			credentials = await this.oauth.credentials(false, USAGE_CREDENTIAL_ACCESS);
+			const selection = await this.oauth.credentialSelection(false, USAGE_CREDENTIAL_ACCESS);
+			credentials = selection.credentials;
+			accountId = selection.accountId;
 			let creditsResponse = await this.fetchResetCredits(credentials);
 			if (creditsResponse.status === 401) {
 				await creditsResponse.body?.cancel().catch(() => void 0);
-				credentials = await this.oauth.credentials(true, USAGE_CREDENTIAL_ACCESS);
+				const renewed = await this.oauth.credentialSelection(true, USAGE_CREDENTIAL_ACCESS);
+				credentials = renewed.credentials;
+				accountId = renewed.accountId;
 				creditsResponse = await this.fetchResetCredits(credentials);
 			}
 			if (!creditsResponse.ok) {
@@ -6484,7 +6836,9 @@ var UsageService = class {
 			});
 			if (consumeResponse.status === 401) {
 				await consumeResponse.body?.cancel().catch(() => void 0);
-				credentials = await this.oauth.credentials(true, USAGE_CREDENTIAL_ACCESS);
+				const renewed = await this.oauth.credentialSelection(true, USAGE_CREDENTIAL_ACCESS);
+				credentials = renewed.credentials;
+				accountId = renewed.accountId;
 				consumeResponse = await this.fetchFn(CODEX_RESET_CREDITS_CONSUME_URL, {
 					method: "POST",
 					headers: {
@@ -6508,7 +6862,7 @@ var UsageService = class {
 			}
 			await consumeResponse.body?.cancel().catch(() => void 0);
 			this.clear();
-			const refreshed = await this.refreshUpstream(credentials, identityKey(credentials));
+			const refreshed = await this.refreshUpstream(credentials, this.snapshotKeyFor(accountId, credentials));
 			if (refreshed.error !== void 0) throw new UsageServiceError({
 				code: "quota-failed",
 				message: "The reset credit was used, but usage could not be refreshed."
@@ -6535,16 +6889,17 @@ var UsageService = class {
 			checkedAt: Math.floor(this.now() / 1e3)
 		};
 	}
-	async refreshUpstream(initialCredentials, initialAccountKey) {
+	async refreshUpstream(initialCredentials, initialSnapshotKey) {
 		this.lastUpstreamAt = this.now();
 		try {
 			let credentials = initialCredentials;
-			let accountKey = initialAccountKey;
+			let snapshotKey = initialSnapshotKey;
 			let response = await this.fetch(credentials);
 			if (response.status === 401) {
 				await response.body?.cancel().catch(() => void 0);
-				credentials = await this.oauth.credentials(true, USAGE_CREDENTIAL_ACCESS);
-				accountKey = identityKey(credentials);
+				const renewed = await this.oauth.credentialSelection(true, USAGE_CREDENTIAL_ACCESS);
+				credentials = renewed.credentials;
+				snapshotKey = this.snapshotKeyFor(renewed.accountId, credentials);
 				response = await this.fetch(credentials);
 			}
 			if (response.status === 429) {
@@ -6577,10 +6932,10 @@ var UsageService = class {
 			this.cache = {
 				usage,
 				fetchedAt: this.now(),
-				accountKey
+				accountKey: snapshotKey
 			};
 			this.cacheIdentityRevision = this.oauth.currentIdentityRevision();
-			this.rememberSnapshot(accountKey, usage, this.cache.fetchedAt);
+			this.rememberSnapshot(snapshotKey, usage, this.cache.fetchedAt);
 			this.invalidated = false;
 			return this.fromCache(false);
 		} catch (error) {
@@ -7919,7 +8274,7 @@ var FileModelSettingsStore$2 = class {
 */
 /** Default loopback port the Antigravity CLI's own flow uses. */
 const DEFAULT_CALLBACK_PORT$2 = 51121;
-let cachedQuota$1;
+let cachedQuota;
 let quotaFetchInFlight = null;
 /** Bumped by every cache clear so an in-flight fetch cannot publish stale state. */
 let quotaCacheEpoch$2 = 0;
@@ -8096,7 +8451,7 @@ function parseQuotaSummary(data) {
 		for (const bucket of rawBuckets) {
 			if (typeof bucket !== "object" || bucket === null) continue;
 			const bRec = bucket;
-			const remaining = typeof bRec.remainingFraction === "number" ? Math.max(0, Math.min(1, bRec.remainingFraction)) : 0;
+			const remaining = typeof bRec.remainingFraction === "number" && Number.isFinite(bRec.remainingFraction) ? Math.max(0, Math.min(1, bRec.remainingFraction)) : null;
 			buckets.push({
 				bucketId: String(bRec.bucketId || bRec.displayName || "limit"),
 				displayName: String(bRec.displayName || bRec.bucketId || "Limit"),
@@ -8159,7 +8514,7 @@ function mergeCatalogSelection(stored, storedCatalog) {
 	return stored.filter((id) => known.has(id));
 }
 async function fetchAccountQuota(store = new FileCredentialStore$2(), modelSettings, fetchFn = fetch, force = false) {
-	if (!force && cachedQuota$1 && Date.now() - (cachedQuota$1.fetchedAt || 0) < 12e4) return cachedQuota$1;
+	if (!force && cachedQuota && Date.now() - (cachedQuota.fetchedAt || 0) < 12e4) return cachedQuota;
 	if (quotaFetchInFlight) return quotaFetchInFlight;
 	const epoch = quotaCacheEpoch$2;
 	const request = (async () => {
@@ -8195,7 +8550,7 @@ async function fetchAccountQuota(store = new FileCredentialStore$2(), modelSetti
 			fetchedAt: Date.now()
 		};
 		if (epoch !== quotaCacheEpoch$2) return snapshot;
-		cachedQuota$1 = snapshot;
+		cachedQuota = snapshot;
 		if (modelSettings && catalogModels.length > 0) {
 			const current = await modelSettings.read();
 			const mergedEnabled = mergeCatalogSelection(current.enabledModelIds, current.catalogModels);
@@ -8211,11 +8566,11 @@ async function fetchAccountQuota(store = new FileCredentialStore$2(), modelSetti
 	}
 }
 function getCachedQuota() {
-	return cachedQuota$1;
+	return cachedQuota;
 }
 function clearCachedQuota() {
 	quotaCacheEpoch$2 += 1;
-	cachedQuota$1 = void 0;
+	cachedQuota = void 0;
 	quotaFetchInFlight = null;
 }
 //#endregion
@@ -9595,6 +9950,54 @@ function createPoolCredentialBackend(filePath) {
 	throw new Error("Antigravity pool encrypted storage requires Windows, macOS, or Linux.");
 }
 /**
+* One bucket's reset moment as Unix milliseconds, when it parses as a date.
+*
+* The service states it as an ISO-ish string; anything `Date.parse` refuses is
+* dropped rather than guessed at, because a wrong instant on the card is worse
+* than none.
+*/
+function resetTimeMs(resetTime) {
+	if (resetTime === void 0 || resetTime === "") return null;
+	const parsed = Date.parse(resetTime);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+/**
+* One cached Antigravity snapshot as the shared account card renders it.
+*
+* One window per bucket. The service states what is LEFT, and the card draws what
+* is SPENT, so the used share is the complement. A bucket whose fraction is
+* `null` (never measured) or outside 0-1 is dropped rather than drawn as 0% or
+* 100%: "not stated" and "nothing used" are different claims and only one of
+* them is true. A stated 0 is a real measurement — the allowance is exhausted —
+* and is published as 100% used.
+*
+* `windowDurationMins` is deliberately absent. The bucket's `window` field is
+* carried through this line's cache verbatim and nothing in the line interprets
+* it as a duration, so naming a window from it would be a guess; the card names
+* each window from the label below instead.
+*/
+function antigravityPoolQuota(quota) {
+	if (quota === void 0) return void 0;
+	const nameCounts = /* @__PURE__ */ new Map();
+	for (const group of quota.groups) for (const bucket of group.buckets) {
+		const name = bucket.displayName.trim();
+		if (name === "") continue;
+		nameCounts.set(name, (nameCounts.get(name) ?? 0) + 1);
+	}
+	const windows = [];
+	for (const group of quota.groups) {
+		const groupName = group.displayName.trim();
+		for (const bucket of group.buckets) {
+			const remaining = bucket.remainingFraction;
+			if (remaining === null || !Number.isFinite(remaining) || remaining < 0 || remaining > 1) continue;
+			const name = bucket.displayName.trim();
+			const label = (name === "" || (nameCounts.get(name) ?? 0) > 1) && groupName !== "" ? name === "" ? groupName : groupName + " · " + name : name;
+			windows.push(quotaWindow$1(label, (1 - remaining) * 100, { resetsAt: resetTimeMs(bucket.resetTime) }));
+		}
+	}
+	return poolQuota(quota.fetchedAt, windows);
+}
+/**
 * Antigravity's account pool.
 *
 * The storage, eligibility, rotation and cooldown rules live in the shared
@@ -9658,7 +10061,11 @@ var AccountPoolStore = class {
 					...base,
 					...projectId === void 0 ? {} : { projectId },
 					...email === void 0 ? {} : { email },
-					...account.planLabel === void 0 ? {} : { planLabel: account.planLabel }
+					...account.planLabel === void 0 ? {} : { planLabel: account.planLabel },
+					...account.isPrimary === true ? (() => {
+						const quota = antigravityPoolQuota(getCachedQuota());
+						return quota === void 0 ? {} : { quota };
+					})() : {}
 				};
 			},
 			emptyMessage: "未登录 Antigravity 账号，请在「设置 → Antigravity」中添加并登录账号。",
@@ -12569,7 +12976,41 @@ function whoami(apiKey, options = {}) {
 async function verifyApiKey(apiKey, options = {}) {
 	return parseWhoami(await whoami(apiKey, options), { authenticatedAt: Date.now() });
 }
-let cachedQuotaEntry;
+/**
+* One newest snapshot PER ACCOUNT.
+*
+* Quota follows the account: rotation decides which key spends the next
+* request, so a single slot only ever described whichever key was read last.
+* The pool's card draws every account its own reading, so each account keeps
+* its own entry; past the cap the oldest read is evicted.
+*
+* This map is a memory read only. Nothing here fetches — the settings card
+* builds its account list from it, and that must never cost one upstream
+* request per pooled key.
+*/
+const cachedQuotaEntries$1 = /* @__PURE__ */ new Map();
+/** How many accounts' snapshots are remembered; mirrors the Codex usage service. */
+const QUOTA_CACHE_LIMIT$1 = 20;
+/** Key of a snapshot whose caller named no account. */
+const UNNAMED_ACCOUNT_KEY$1 = "";
+function quotaCacheKey(accountId) {
+	return accountId ?? UNNAMED_ACCOUNT_KEY$1;
+}
+/** The entry read most recently, whichever account it belongs to. */
+function newestQuotaEntry$2() {
+	let newest;
+	for (const entry of cachedQuotaEntries$1.values()) if (newest === void 0 || entry.fetchedAt > newest.fetchedAt) newest = entry;
+	return newest;
+}
+/** Remember one account's newest snapshot, bounded to the accounts in use. */
+function rememberQuotaEntry(entry) {
+	cachedQuotaEntries$1.set(quotaCacheKey(entry.accountId), entry);
+	while (cachedQuotaEntries$1.size > QUOTA_CACHE_LIMIT$1) {
+		const oldest = [...cachedQuotaEntries$1.entries()].sort((left, right) => left[1].fetchedAt - right[1].fetchedAt)[0];
+		if (oldest === void 0) break;
+		cachedQuotaEntries$1.delete(oldest[0]);
+	}
+}
 let quotaInFlight$2 = null;
 let quotaInFlightAccountId$1;
 let quotaCacheEpoch$1 = 0;
@@ -12578,21 +13019,22 @@ let quotaCacheEpoch$1 = 0;
 * Kept with a no-argument signature for backward compatibility.
 */
 function getCachedQuota$2() {
-	return cachedQuotaEntry?.quota;
+	return newestQuotaEntry$2()?.quota;
 }
 /**
 * The cached snapshot only when it belongs to this account.
 *
 * Passing no account keeps the pre-pool behavior of returning whatever was
-* fetched last.
+* fetched last. This is the lookup the account pool calls while it builds its
+* summaries: a pure memory read, never a fetch.
 */
-function getCachedQuotaFor$1(accountId) {
-	if (accountId === void 0 || accountId === null) return cachedQuotaEntry?.quota;
-	return cachedQuotaEntry?.accountId === accountId ? cachedQuotaEntry.quota : void 0;
+function getCachedQuotaFor$3(accountId) {
+	if (accountId === void 0 || accountId === null) return newestQuotaEntry$2()?.quota;
+	return cachedQuotaEntries$1.get(accountId)?.quota;
 }
 function clearCachedQuota$2() {
 	quotaCacheEpoch$1 += 1;
-	cachedQuotaEntry = void 0;
+	cachedQuotaEntries$1.clear();
 	quotaInFlight$2 = null;
 	quotaInFlightAccountId$1 = void 0;
 }
@@ -12607,8 +13049,8 @@ async function fetchAccountQuota$2(store = new FileCredentialStore$1(), fetchFnO
 	const fetchFn = typeof fetchFnOrOptions === "function" ? fetchFnOrOptions : fetchFnOrOptions?.fetchFn ?? fetch;
 	const effectiveForce = isOptionsObj ? fetchFnOrOptions.force ?? force : force;
 	const effectiveAccountId = isOptionsObj ? fetchFnOrOptions.accountId ?? accountId : accountId;
-	const sameAccount = effectiveAccountId === void 0 || cachedQuotaEntry?.accountId === effectiveAccountId;
-	if (!effectiveForce && sameAccount && cachedQuotaEntry && Date.now() - cachedQuotaEntry.fetchedAt < 12e4) return cachedQuotaEntry.quota;
+	const cached = getCachedQuotaFor$3(effectiveAccountId);
+	if (!effectiveForce && cached !== void 0 && Date.now() - (cached.fetchedAt || 0) < 12e4) return cached;
 	if (quotaInFlight$2 !== null && (effectiveAccountId === void 0 || quotaInFlightAccountId$1 === effectiveAccountId)) return quotaInFlight$2;
 	const epoch = quotaCacheEpoch$1;
 	const request = (async () => {
@@ -12664,11 +13106,11 @@ async function fetchAccountQuota$2(store = new FileCredentialStore$1(), fetchFnO
 			sources
 		};
 		if (epoch !== quotaCacheEpoch$1) return snapshot;
-		cachedQuotaEntry = {
+		rememberQuotaEntry({
 			accountId: effectiveAccountId,
 			quota: snapshot,
 			fetchedAt: snapshot.fetchedAt
-		};
+		});
 		return snapshot;
 	})();
 	quotaInFlight$2 = request;
@@ -14758,6 +15200,34 @@ function processLine$1(line, state, wire) {
 }
 //#endregion
 //#region src/host/command-code/account-pool.ts
+/**
+* One cached snapshot as the shared account card renders it.
+*
+* A usage window states its own consumed share, so it maps straight across; a
+* window whose share nobody measured is dropped rather than drawn at 0, which
+* would claim an unspent window no reading supports.
+*
+* Exported for the pool's regression tests; the card only reaches it through
+* the summary hook.
+*/
+function commandCodePoolQuota(cached) {
+	return poolQuota(cached.fetchedAt, cached.windows.map((window) => quotaWindow$1(window.label, window.usedPercent, {
+		windowDurationMins: window.windowDurationMins,
+		resetsAt: window.resetsAt
+	})));
+}
+/**
+* This key's own newest snapshot, ready for the account card.
+*
+* Quota follows the account, so the pool reports what the line already
+* remembered for THIS account id. The lookup is a pure memory read: the card
+* builds its account list here, and that must never cost one upstream request
+* per pooled key.
+*/
+function quotaFor$1(accountId) {
+	const cached = getCachedQuotaFor$3(accountId);
+	return cached === void 0 ? void 0 : commandCodePoolQuota(cached);
+}
 /** Encrypted pool file this line owns; the pre-pool credential file stays the mirror. */
 function commandCodePoolPath() {
 	return path.join(dshHomeDir(), "storages", "command-code-pool.json");
@@ -14895,7 +15365,11 @@ var CommandCodeAccountPool = class extends AccountPoolCore {
 					...account.userName === void 0 ? {} : { userName: account.userName },
 					...account.organizationName === void 0 ? {} : { organizationName: account.organizationName },
 					...account.planId === void 0 ? {} : { planId: account.planId },
-					...account.userId === void 0 ? {} : { userId: account.userId }
+					...account.userId === void 0 ? {} : { userId: account.userId },
+					...(() => {
+						const quota = quotaFor$1(account.id);
+						return quota === void 0 ? {} : { quota };
+					})()
 				};
 			},
 			emptyMessage: "Not signed in to Command Code. 请在「设置 → 订阅服务 → Command Code」中添加账号或粘贴 API Key。",
@@ -15450,7 +15924,7 @@ async function getCommandCodeWebStatus(store, modelSettings, preferences, option
 	const catalog = live.length > 0 ? live : fallbackCatalog$1();
 	const enabled = settings.enabled !== false;
 	const models = buildModelOptions$2(catalog, resolveEnabledModelIds$4(settings.enabledModelIds, catalog, enabled), settings.contextWindowOverrides);
-	const quota = getCachedQuotaFor$1(activeAccount?.id ?? null);
+	const quota = getCachedQuotaFor$3(activeAccount?.id ?? null);
 	const activeAccountView = activePoolAccount === void 0 ? null : {
 		userId: activePoolAccount.userId ?? activePoolAccount.credentials.userId ?? null,
 		userName: activePoolAccount.userName ?? activePoolAccount.credentials.userName ?? null,
@@ -15523,7 +15997,7 @@ function registerCommandCodeRoutes(ctx, store, modelSettings, preferences, optio
 					if (method !== "GET") return sendMethodNotAllowed$5(response);
 					const credentials = await store.read();
 					const targetId = await activeAccountId();
-					const cached = getCachedQuotaFor$1(targetId);
+					const cached = getCachedQuotaFor$3(targetId);
 					if ((credentials !== null || targetId !== void 0) && (cached === void 0 || Date.now() - (cached.fetchedAt || 0) > 12e4)) {
 						const refresh = () => fetchAccountQuota$2(quotaStore, fetchFn, false, targetId);
 						if (cached === void 0) await quotaRefresh.run(refresh);
@@ -19336,19 +19810,89 @@ function buildModelOptions$1(catalog, enabledModelIds, contextWindowOverrides) {
 		};
 	});
 }
-let quotaCache$1 = null;
-let quotaAccountId;
+/**
+* How many accounts' snapshots are remembered.
+*
+* Mirrors the bound the ChatGPT line's usage service applies to its own
+* per-account map: room for every account a user is likely to pool, and no way
+* for a long-lived process to accumulate one snapshot per account it has seen.
+*/
+const QUOTA_ACCOUNT_LIMIT$1 = 20;
+/** Key of a snapshot whose caller named no account: the single-credential read. */
+const UNNAMED_ACCOUNT_KEY = "";
+/**
+* One newest snapshot PER ACCOUNT, keyed by the account id the caller stated.
+*
+* Quota follows the account: rotation decides which account spends the next
+* request, so a single slot could only ever describe whichever account was read
+* last. The pool's card draws every account its own reading, so each account
+* keeps its own entry; past the cap the oldest read is evicted.
+*
+* This map is a memory read only. Nothing here fetches — the settings card
+* builds its account list from it, and that must never cost one upstream
+* request per pooled account.
+*/
+const quotaCache$1 = /* @__PURE__ */ new Map();
+/**
+* Key of the entry written most recently.
+*
+* The pre-pool card asks "whatever was fetched last"; the last WRITE answers
+* that exactly, where a scan by `fetchedAt` would break a tie between two
+* accounts read inside the same millisecond by map order.
+*/
+let quotaLastKey$1 = UNNAMED_ACCOUNT_KEY;
+function quotaCacheKeyFor(accountId) {
+	return accountId ?? UNNAMED_ACCOUNT_KEY;
+}
+/** The entry read most recently, whichever account it belongs to. */
+function newestQuotaEntry$1() {
+	return quotaCache$1.get(quotaLastKey$1);
+}
+/** Remember one account's newest snapshot, bounded to the accounts in use. */
+function rememberQuota$1(accountId, snapshot) {
+	const key = quotaCacheKeyFor(accountId);
+	quotaCache$1.set(key, snapshot);
+	quotaLastKey$1 = key;
+	while (quotaCache$1.size > QUOTA_ACCOUNT_LIMIT$1) {
+		const oldest = [...quotaCache$1.entries()].sort((left, right) => left[1].fetchedAt - right[1].fetchedAt)[0];
+		if (oldest === void 0) break;
+		quotaCache$1.delete(oldest[0]);
+		if (quotaLastKey$1 === oldest[0]) quotaLastKey$1 = UNNAMED_ACCOUNT_KEY;
+	}
+}
+/**
+* The snapshot read most recently, whichever account it belongs to.
+*
+* Kept for the pre-pool single-credential card, which has no account id to ask
+* with. A pooled caller asks {@link getCachedQuotaFor} instead.
+*/
 function getCachedQuota$3() {
-	return quotaCache$1;
+	return newestQuotaEntry$1() ?? null;
 }
-/** The cached snapshot only when it belongs to this account. */
-function getCachedQuotaFor(accountId) {
-	if (accountId === void 0 || accountId === null) return quotaCache$1;
-	return quotaAccountId === accountId ? quotaCache$1 : null;
+/**
+* The cached snapshot only when it belongs to this account.
+*
+* Passing no account keeps the pre-pool behavior of returning whatever was
+* fetched last. Passing one answers that account's own newest snapshot, or null
+* when this line has never read it — null is "never read", which is a different
+* statement from a snapshot whose windows are all at zero.
+*/
+function getCachedQuotaFor$2(accountId) {
+	if (accountId === void 0 || accountId === null) return newestQuotaEntry$1() ?? null;
+	return cachedQuotaFor$1(accountId);
+}
+/**
+* The newest snapshot held for one account, for display only.
+*
+* The pool asks here while it builds the account list for the settings card, so
+* this is a pure memory read: it never fetches.
+*/
+function cachedQuotaFor$1(accountId) {
+	return quotaCache$1.get(accountId) ?? null;
 }
 function clearCachedQuota$3() {
-	quotaCache$1 = null;
-	quotaAccountId = void 0;
+	quotaCache$1.clear();
+	quotaLastKey$1 = UNNAMED_ACCOUNT_KEY;
 }
 /**
 * Display name and nominal length for each window key the service reports.
@@ -19595,8 +20139,8 @@ function parsePlanLevel(payload) {
 * account's real usage.
 */
 async function fetchAccountQuota$3(store, options = {}) {
-	const sameAccount = options.accountId === void 0 || quotaAccountId === options.accountId;
-	if (options.force !== true && sameAccount && quotaCache$1 !== null && Date.now() - quotaCache$1.fetchedAt < 12e4) return quotaCache$1;
+	const cached = quotaCache$1.get(quotaCacheKeyFor(options.accountId));
+	if (options.force !== true && cached !== void 0 && Date.now() - cached.fetchedAt < 12e4) return cached;
 	const fetchFn = options.fetchFn ?? fetch;
 	const pooled = options.credentials !== void 0;
 	let credentials;
@@ -19645,8 +20189,7 @@ async function fetchAccountQuota$3(store, options = {}) {
 		fetchedAt: Date.now(),
 		sources: [openAIUrl(USAGES_PATH, credentials.region)]
 	};
-	quotaCache$1 = snapshot;
-	quotaAccountId = options.accountId;
+	rememberQuota$1(options.accountId, snapshot);
 	return snapshot;
 }
 /**
@@ -22547,6 +23090,34 @@ function parseKimiCodePoolData(value) {
 	return result;
 }
 /**
+* One account's own newest quota snapshot, in the shape the account card draws.
+*
+* The snapshot comes from 'client.ts''s per-account cache keyed by the pool
+* account id, and this is where this line's own numbers are translated into the
+* shared shape. Every judgement below trades a possibly-nice-looking bar for an
+* honest one:
+*
+* - a window whose consumed share nobody measured is DROPPED (`quotaWindow`
+*   returns null), because "0% used" and "not stated" are different claims. This
+*   parser only mints a window once it has a ratio, so a window that states none
+*   never reaches here at all — the drop is the second line of defence;
+* - `resetsAt` is already Unix MILLISECONDS on this line, so it is passed
+*   through and normalized rather than multiplied;
+* - the read time is the snapshot's own `fetchedAt`, which this line always
+*   sets. A snapshot with no read time is not a snapshot, and `poolQuota`
+*   reports that as undefined.
+*
+* A null snapshot means "this account was never read", which the card renders as
+* exactly that instead of drawing a zero.
+*/
+function kimiCodePoolQuota(snapshot) {
+	if (snapshot === null) return void 0;
+	return poolQuota(snapshot.fetchedAt, snapshot.windows.map((window) => quotaWindow$1(window.label, window.usedPercent, {
+		windowDurationMins: window.windowDurationMins,
+		resetsAt: window.resetsAt
+	})));
+}
+/**
 * Kimi Code's account pool.
 *
 * The credential is an OAuth pair whose refresh token rotates, so the pool owns
@@ -22625,6 +23196,7 @@ var KimiCodeAccountPool = class extends AccountPoolCore {
 				const nickname = account.nickname ?? account.credentials.nickname;
 				const planName = account.planName ?? account.credentials.planName;
 				const region = account.region ?? account.credentials.region;
+				const quota = kimiCodePoolQuota(cachedQuotaFor$1(account.id));
 				return {
 					...base,
 					...email === void 0 ? {} : { email },
@@ -22634,7 +23206,8 @@ var KimiCodeAccountPool = class extends AccountPoolCore {
 						planLabel: planName
 					},
 					...region === void 0 ? {} : { region },
-					...account.userId === void 0 ? {} : { userId: account.userId }
+					...account.userId === void 0 ? {} : { userId: account.userId },
+					...quota === void 0 ? {} : { quota }
 				};
 			},
 			emptyMessage: "Not signed in to Kimi Code. Sign in from Settings > Kimi Code.",
@@ -22748,7 +23321,7 @@ async function getKimiCodeWebStatus(store, modelSettings, preferences, options =
 	const catalog = live.length > 0 ? live : fallbackCatalog();
 	const enabled = settings.enabled !== false;
 	const models = buildModelOptions$1(catalog, resolveEnabledModelIds$3(settings.enabledModelIds, catalog, enabled), settings.contextWindowOverrides);
-	const quota = getCachedQuotaFor(activeAccount?.id ?? null);
+	const quota = getCachedQuotaFor$2(activeAccount?.id ?? null);
 	const account = quota?.account ?? (active === null || active === void 0 ? null : accountFromCredentials$2(active));
 	return {
 		enabled,
@@ -22882,7 +23455,7 @@ function registerKimiCodeRoutes(ctx, store, modelSettings, preferences, options
 				if (path === "" || path === "status") {
 					if (method !== "GET") return sendMethodNotAllowed$3(response);
 					const poolActive = await activeAccount();
-					const cached = getCachedQuotaFor(poolActive.id ?? null);
+					const cached = getCachedQuotaFor$2(poolActive.id ?? null);
 					if (poolActive.credentials !== void 0 && (cached === null || Date.now() - (cached.fetchedAt || 0) > 12e4)) {
 						const refresh = async () => {
 							const credentials = await effectiveCredentials(poolActive);
@@ -26725,29 +27298,75 @@ const QUOTA_FAILURE_CACHE_MS = 10 * 6e4;
 const QUOTA_TIMEOUT_MS = 8e3;
 let quotaHostInForce = null;
 /**
-* The last usage snapshot, plus the last failure to have one.
+* How many accounts' snapshots are remembered.
+*
+* Bounded like the ChatGPT line's own per-account map: the pool accepts a
+* handful of accounts, and a long-lived process must not accumulate one entry
+* per id it has ever seen. The oldest WRITE is evicted, which is also the read
+* least likely to be looked at again.
+*/
+const QUOTA_SNAPSHOT_ACCOUNT_LIMIT = 20;
+/**
+* The newest read, whichever account it belonged to.
 *
-* `value` and `reason` are tracked SEPARATELY from the last GOOD value on
-* purpose. A read that fails carries no information about the previous one, so
-* replacing a good snapshot with `null` turned every transient refusal into a
-* visible disappearance of the quota box; `quotaLastGood` lets the card keep
-* showing the last known numbers while saying they are old.
+* Kept beside the per-account map because the page-level block and the
+* "is a read even worth starting" test are about the line's latest reading,
+* not about one account.
 */
 let quotaSnapshot = null;
-/** The last snapshot that actually parsed, kept across failures. */
-let quotaLastGood = null;
+/** Per-account snapshots, so an account is never shown the numbers read for another. */
+const quotaByAccount = /* @__PURE__ */ new Map();
 /** How long a refused credential is remembered before asking again. */
 const QUOTA_REJECTED_CACHE_MS = 30 * 6e4;
 /** Forget the cached usage snapshot (a sign-out, a sign-in, a test). */
 function clearCachedQuota$4() {
 	quotaSnapshot = null;
-	quotaLastGood = null;
+	quotaByAccount.clear();
 	quotaHostInForce = null;
 }
 /** The last usage snapshot without touching the network. */
 function getCachedQuota$4() {
 	return quotaSnapshot?.value ?? null;
 }
+/**
+* The cached snapshot only when it belongs to this account, without touching the
+* network.
+*
+* Quota follows the account: a rotation decides whose credential is spent next,
+* so the snapshot a read produced describes the row it was made for. The pool
+* asks here while it builds the settings card's account list, which must never
+* wait on — or trigger — an upstream read.
+*
+* An absent, empty or null id keeps the pre-pool behaviour and answers with the
+* newest read, which is what the page-level block wants.
+*/
+function getCachedQuotaFor$1(accountId) {
+	if (accountId === void 0 || accountId === null || accountId === "") return getCachedQuota$4();
+	return quotaByAccount.get(accountId)?.value ?? null;
+}
+/** The entry a read for this account should consult, when there is one. */
+function quotaEntryFor(accountId) {
+	if (accountId === void 0 || accountId === "") return quotaSnapshot;
+	return quotaByAccount.get(accountId) ?? null;
+}
+/**
+* Remember one read against the account it was made for.
+*
+* Re-inserting an id moves it to the newest position, so the map's first key is
+* always the least recently written entry and eviction is a single delete.
+*/
+function rememberQuotaSnapshot(entry) {
+	quotaSnapshot = entry;
+	const accountId = entry.accountId;
+	if (accountId === void 0 || accountId === "") return;
+	quotaByAccount.delete(accountId);
+	quotaByAccount.set(accountId, entry);
+	while (quotaByAccount.size > QUOTA_SNAPSHOT_ACCOUNT_LIMIT) {
+		const oldest = quotaByAccount.keys().next().value;
+		if (oldest === void 0) break;
+		quotaByAccount.delete(oldest);
+	}
+}
 /** Why the last read produced no snapshot, or null when it produced one. */
 function getQuotaUnavailable() {
 	return quotaSnapshot?.reason ?? null;
@@ -26869,9 +27488,10 @@ function parseTokenPlanQuota(payload, now = Date.now()) {
 async function fetchTokenPlanQuota(credentials, options = {}) {
 	const fetchFn = options.fetchFn ?? fetch;
 	const now = Date.now();
-	if (options.force !== true && quotaSnapshot !== null) {
-		const ttl = quotaSnapshot.reason === "credential-not-accepted" ? QUOTA_REJECTED_CACHE_MS : quotaSnapshot.reason === "token-expired" && quotaSnapshot.value === null ? QUOTA_FAILURE_CACHE_MS : quotaSnapshot.value === null ? QUOTA_FAILURE_CACHE_MS : QUOTA_CACHE_MS;
-		if (now - quotaSnapshot.at < ttl) return quotaSnapshot.value;
+	const cached = quotaEntryFor(options.accountId);
+	if (options.force !== true && cached !== null) {
+		const ttl = cached.reason === "credential-not-accepted" ? QUOTA_REJECTED_CACHE_MS : cached.reason === "token-expired" && cached.value === null ? QUOTA_FAILURE_CACHE_MS : cached.value === null ? QUOTA_FAILURE_CACHE_MS : QUOTA_CACHE_MS;
+		if (now - cached.at < ttl) return cached.value;
 	}
 	const candidates = quotaHostCandidates(credentials.region);
 	const ordered = quotaHostInForce === null ? candidates : [quotaHostInForce, ...candidates.filter((host) => host !== quotaHostInForce)];
@@ -26911,19 +27531,19 @@ async function fetchTokenPlanQuota(credentials, options = {}) {
 		});
 	}
 	if (value === null && reason === null) reason = authRefused ? "token-expired" : "unreachable";
-	if (value !== null) quotaLastGood = {
-		value,
-		at: Date.now()
-	};
-	else if (quotaLastGood !== null) {
-		value = quotaLastGood.value;
-		reason = "stale";
+	if (value === null) {
+		const previous = quotaEntryFor(options.accountId);
+		if (previous !== null && previous.value !== null) {
+			value = previous.value;
+			reason = "stale";
+		}
 	}
-	quotaSnapshot = {
+	rememberQuotaSnapshot({
+		accountId: options.accountId,
 		at: Date.now(),
 		value,
 		reason
-	};
+	});
 	return value;
 }
 /**
@@ -27961,6 +28581,38 @@ function parseMinimaxCodePoolData(value) {
 	return result;
 }
 /**
+* Nominal length of the two windows the Token Plan reports, in minutes.
+*
+* The line's own card names these two keys (`quotaWindowInterval` = 5 小时窗口,
+* `quotaWindowWeekly` = 每周窗口), and 5 hours / 7 days is what those words mean,
+* so the shared account card can name an unlabeled window from its length
+* instead of showing a generic one. The same two numbers label the equivalent
+* windows on the Command Code and Kimi Code lines.
+*/
+const WINDOW_MINUTES = {
+	interval: 300,
+	weekly: 10080
+};
+/**
+* One cached read as the shared account card renders it.
+*
+* Every window is labeled through its LENGTH rather than with a string: the
+* canonical window names live in the client's dictionary, and the host has no
+* business shipping display text. A window whose consumed share nobody measured
+* is dropped by {@link quotaWindow} — a null percentage is not 0%, it is
+* "not stated", and a bar would lie about it. An `unlimited` window states no
+* consumed share at all and the per-account shape has no way to say
+* "unlimited", so it is dropped too rather than drawn as an empty bar.
+*/
+function minimaxCodePoolQuota(quota) {
+	if (quota === null || quota === void 0) return void 0;
+	const windows = quota.windows === void 0 || quota.windows.length === 0 ? [quotaWindow$1("", quota.usedPercent, { resetsAt: quota.resetsAtMs })] : quota.windows.map((window) => quotaWindow$1("", window.usedPercent, {
+		windowDurationMins: WINDOW_MINUTES[window.key],
+		resetsAt: window.resetsAtMs
+	}));
+	return poolQuota(quota.fetchedAtMs, windows);
+}
+/**
 * MiniMax Code's account pool.
 *
 * It owns rotation and the write-back, exactly like the sibling lines, with one
@@ -28041,7 +28693,11 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 					...planName === void 0 ? {} : {
 						planName,
 						planLabel: planName
-					}
+					},
+					...(() => {
+						const quota = minimaxCodePoolQuota(getCachedQuotaFor$1(account.id));
+						return quota === void 0 ? {} : { quota };
+					})()
 				};
 			},
 			liveCredentialsFor: (account) => this.nativeAuthority(account),
@@ -28128,6 +28784,34 @@ var MinimaxCodeAccountPool = class extends AccountPoolCore {
 		});
 	}
 	/**
+	* The account a usage read belongs to, together with the credential to read it
+	* with.
+	*
+	* Authored here rather than in the routes because it is provider-shaped: the
+	* routes need a credential and the ACCOUNT it was read for, so a snapshot can
+	* be remembered against the row whose numbers it describes. The selection is
+	* the core's own rule for a caller that names no account — the active one, then
+	* the primary, then the first — repeated in these three lines because the core
+	* exposes it only through `getFreshCredential`, which returns the credential
+	* alone; the credential (and its single-flight refresh, write-back and
+	* bookkeeping) still comes from the core, so no rotation rule lives here.
+	*
+	* No upstream request is made for the selection itself, and none of this moves
+	* the rotation: reading quota is not serving a request.
+	*/
+	async getQuotaReadTarget(fetchFn = fetch) {
+		const data = await this.read();
+		const target = data.accounts.find((account) => account.id === data.activeAccountId) ?? data.accounts.find((account) => account.isPrimary) ?? data.accounts[0];
+		if (target === void 0) {
+			await this.getFreshCredential(void 0, fetchFn);
+			throw new Error("MiniMax Code 号池中没有账号。");
+		}
+		return {
+			accountId: target.id,
+			credentials: await this.getFreshCredential(target.id, fetchFn)
+		};
+	}
+	/**
 	* Pick the account for the next request.
 	*
 	* The returned credential carries its own region and record key, so a caller
@@ -28461,8 +29145,12 @@ function registerMinimaxCodeRoutes(ctx, store = new MinimaxCodeCredentialStore()
 	* network, and the status route reads the snapshot through the cache instead.
 	*/
 	const refreshQuota = async (force) => {
-		const credentials = await (options.accountPool === void 0 ? ensureAccessToken$2(store, { fetchFn }).catch(() => null) : options.accountPool.getFreshCredential(void 0, fetchFn).catch(() => null));
-		if (credentials === null) return null;
+		const target = await (options.accountPool === void 0 ? ensureAccessToken$2(store, { fetchFn }).then((credentials) => ({
+			accountId: void 0,
+			credentials
+		})).catch(() => null) : options.accountPool.getQuotaReadTarget(fetchFn).catch(() => null));
+		if (target === null) return null;
+		const credentials = target.credentials;
 		const readToken = credentials.refreshToken;
 		const isCredentialStale = async () => {
 			const live = await store.readFresh().catch(() => null);
@@ -28472,10 +29160,11 @@ function registerMinimaxCodeRoutes(ctx, store = new MinimaxCodeCredentialStore()
 			fetchFn,
 			force,
 			isCredentialStale,
+			...target.accountId === void 0 ? {} : { accountId: target.accountId },
 			renewCredential: async () => await (options.accountPool === void 0 ? ensureAccessToken$2(store, {
 				fetchFn,
 				force: true
-			}) : options.accountPool.renewCredential(void 0, fetchFn)).catch(() => null)
+			}) : options.accountPool.renewCredential(target.accountId, fetchFn)).catch(() => null)
 		}).catch(() => null);
 	};
 	/**
@@ -30540,6 +31229,9 @@ const CATALOG_CACHE_TTL_MS$1 = 1800 * 1e3;
 * every cache miss.
 */
 const catalogSnapshotScopesLoaded = /* @__PURE__ */ new Set();
+function getCachedCatalog$1() {
+	return cachedCatalog?.models ?? [];
+}
 function clearCachedCatalog$1() {
 	cachedCatalog = void 0;
 	catalogCacheEpoch += 1;
@@ -30731,16 +31423,64 @@ function billingMeters(billing) {
 	}
 	return meters;
 }
-let cachedQuota;
+/**
+* One newest snapshot PER ACCOUNT, keyed by the snapshot's own `account.id` —
+* the same public key the pool addresses an account with.
+*
+* Quota follows the account: rotation decides which account spends the next
+* request, so a single slot only ever described whichever account was read
+* last. The pool's card draws every account its own reading, so each account
+* keeps its own entry; past the cap the oldest read is evicted.
+*
+* This map is a memory read only. Nothing here fetches — the settings card
+* builds its account list from it, and that must never cost one upstream
+* request per pooled account.
+*/
+const cachedQuotaEntries = /* @__PURE__ */ new Map();
+/** How many accounts' snapshots are remembered; mirrors the Codex usage service. */
+const QUOTA_CACHE_LIMIT = 20;
+/** The entry read most recently, whichever account it belongs to. */
+function newestCachedQuota() {
+	let newest;
+	for (const snapshot of cachedQuotaEntries.values()) if (newest === void 0 || (snapshot.fetchedAt || 0) > (newest.fetchedAt || 0)) newest = snapshot;
+	return newest;
+}
+/** Remember one account's newest snapshot, bounded to the accounts in use. */
+function rememberCachedQuota(snapshot) {
+	cachedQuotaEntries.set(snapshot.account.id, snapshot);
+	while (cachedQuotaEntries.size > QUOTA_CACHE_LIMIT) {
+		const oldest = [...cachedQuotaEntries.entries()].sort((left, right) => (left[1].fetchedAt || 0) - (right[1].fetchedAt || 0))[0];
+		if (oldest === void 0) break;
+		cachedQuotaEntries.delete(oldest[0]);
+	}
+}
 let quotaInFlight$1 = null;
 let quotaInFlightAccountId = null;
 let quotaCacheEpoch = 0;
+/**
+* The snapshot read most recently, whichever account it belongs to.
+*
+* Kept with a no-argument signature for backward compatibility; the page-level
+* facts use {@link getCachedQuotaFor} instead, because they describe one
+* account and must never be another account's numbers.
+*/
 function getCachedQuota$5() {
-	return cachedQuota;
+	return newestCachedQuota();
+}
+/**
+* The snapshot remembered for one account, if it was read before.
+*
+* This is the lookup the account pool calls while it builds its summaries: a
+* pure memory read, never a fetch. Passing no account keeps the pre-pool
+* behavior of returning whatever was fetched last.
+*/
+function getCachedQuotaFor(accountId) {
+	if (accountId === void 0 || accountId === null) return newestCachedQuota();
+	return cachedQuotaEntries.get(accountId);
 }
 function clearCachedQuota$5() {
 	quotaCacheEpoch += 1;
-	cachedQuota = void 0;
+	cachedQuotaEntries.clear();
 	quotaInFlight$1 = null;
 	quotaInFlightAccountId = null;
 }
@@ -30757,7 +31497,8 @@ async function fetchAccountQuota$4(store = new FileCredentialStore$4(), fetchFn
 	});
 	if (credentials === null) throw new Error(`Not signed in to ${PROVIDER_NAME$1}.`);
 	const requestedAccountId = workBuddyAccountId(credentials);
-	if (!force && cachedQuota && cachedQuota.account.id === requestedAccountId && Date.now() - (cachedQuota.fetchedAt || 0) < 12e4) return cachedQuota;
+	const cached = cachedQuotaEntries.get(requestedAccountId);
+	if (!force && cached !== void 0 && Date.now() - (cached.fetchedAt || 0) < 12e4) return cached;
 	if (quotaInFlight$1 && quotaInFlightAccountId === requestedAccountId) return quotaInFlight$1;
 	const epoch = quotaCacheEpoch;
 	const request = (async () => {
@@ -30793,7 +31534,7 @@ async function fetchAccountQuota$4(store = new FileCredentialStore$4(), fetchFn
 			sources: ["billing/meter/get-user-resource"]
 		};
 		if (epoch !== quotaCacheEpoch) return snapshot;
-		cachedQuota = snapshot;
+		rememberCachedQuota(snapshot);
 		return snapshot;
 	})();
 	quotaInFlight$1 = request;
@@ -31108,7 +31849,7 @@ async function getWorkBuddyWebStatus(store, modelSettings, preferences, options
 	const catalog = live.length > 0 ? live : FALLBACK_MODELS$1;
 	const available = modelsForRegion(credentials?.region ?? "intl", catalog).map((model) => model.id);
 	const models = buildModelOptions(catalog, available, resolveEnabledModelIds$2(settings.enabledModelIds, available, enabled), settings.contextWindowOverrides);
-	const quota = getCachedQuota$5();
+	const quota = getCachedQuotaFor(credentials === null ? null : accountFromCredentials$1(credentials).id);
 	const poolData = options.accountPool === void 0 ? null : await options.accountPool.read().catch(() => null);
 	const poolAccounts = options.accountPool === void 0 ? [] : await options.accountPool.listAccounts().catch(() => []);
 	const hiddenIds = new Set(settings.hiddenAccountIds);
@@ -31167,12 +31908,10 @@ function registerWorkBuddyRoutes(ctx, store, modelSettings, preferences, options
 						accountId: settings.selectedAccountId,
 						hiddenAccountIds: settings.hiddenAccountIds
 					});
-					const cached = getCachedQuota$5();
-					const quotaMatches = cached?.account.id === (credentials === null ? void 0 : accountFromCredentials$1(credentials).id);
-					if (credentials !== null && (!quotaMatches || cached === void 0 || Date.now() - (cached.fetchedAt || 0) > 12e4)) {
-						if (!quotaMatches) clearCachedQuota$5();
+					const cached = getCachedQuotaFor(credentials === null ? null : accountFromCredentials$1(credentials).id);
+					if (credentials !== null && (cached === void 0 || Date.now() - (cached.fetchedAt || 0) > 12e4)) {
 						const refresh = () => fetchAccountQuota$4(store, fetchFn, false, settings.selectedAccountId, settings.hiddenAccountIds);
-						if (cached === void 0 || !quotaMatches) await quotaRefresh.run(refresh);
+						if (cached === void 0) await quotaRefresh.run(refresh);
 						else quotaRefresh.start(refresh);
 					}
 					return sendJson$1(response, 200, {
@@ -32658,6 +33397,47 @@ function defaultAliasFor(credentials, position) {
 	return credentials.nickname || credentials.uin || credentials.uid || `账号 ${position}`;
 }
 /**
+* A meter's consumed share, from whichever fraction this line measured.
+*
+* `usedFraction` is the DTO's own "share consumed"; `remainingFraction` is the
+* same statement read from the other end, and is the one the rest of the card
+* renders. A meter that states neither is dropped (null) rather than drawn at
+* 0, which would claim a full window no reading supports.
+*/
+function meterUsedPercent(meter) {
+	if (typeof meter.usedFraction === "number" && Number.isFinite(meter.usedFraction)) return meter.usedFraction * 100;
+	if (typeof meter.remainingFraction === "number" && Number.isFinite(meter.remainingFraction)) return (1 - meter.remainingFraction) * 100;
+	return null;
+}
+/**
+* One cached snapshot as the shared account card renders it.
+*
+* Only what the DTO states is published: every meter that measured a share
+* becomes a window, and a meter that measured none is dropped rather than drawn
+* at 0 — which would claim an unspent allowance no reading supports.
+*
+* Exported for the pool's regression tests; the card only reaches it through
+* the summary hook.
+*/
+function workBuddyPoolQuota(snapshot) {
+	const windows = snapshot.meters.map((meter) => quotaWindow$1(meter.label, meterUsedPercent(meter), { resetsAt: meter.resetsAt }));
+	if (!snapshot.meters.some((meter) => meter.id === "cycle") && snapshot.cycleCredits !== null && snapshot.cycleCredits > 0 && snapshot.cycleUsedCredits !== null) windows.push(quotaWindow$1(snapshot.packageName ?? "Billing cycle", snapshot.cycleUsedCredits / snapshot.cycleCredits * 100, { resetsAt: snapshot.cycleEndsAt }));
+	return poolQuota(snapshot.fetchedAt, windows);
+}
+/**
+* This account's own newest snapshot, ready for the account card.
+*
+* Quota follows the account, so the pool reports the snapshot the line already
+* remembered for THIS account id. The lookup is a pure memory read: the card
+* builds its account list here, and that must never cost one upstream request
+* per pooled account. Undefined means exactly that — never read — which is not
+* the same statement as "nothing used".
+*/
+function quotaFor(accountId) {
+	const snapshot = getCachedQuotaFor(accountId);
+	return snapshot === void 0 ? void 0 : workBuddyPoolQuota(snapshot);
+}
+/**
 * WorkBuddy's account pool.
 *
 * Desktop accounts are adopted into the pool so they can be scheduled and
@@ -32718,7 +33498,11 @@ var WorkBuddyAccountPool = class extends AccountPoolCore {
 				...account.credentials.domain === "" ? {} : { domain: account.credentials.domain },
 				...account.credentials.backend === "" ? {} : { backend: account.credentials.backend },
 				...account.credentials.accountType === void 0 ? {} : { accountType: account.credentials.accountType },
-				...account.credentials.expiresAt > 0 ? {} : { expiresAt: void 0 }
+				...account.credentials.expiresAt > 0 ? {} : { expiresAt: void 0 },
+				...(() => {
+					const quota = quotaFor(account.id);
+					return quota === void 0 ? {} : { quota };
+				})()
 			}),
 			preferAccountId: () => this.resolveSelectionId(options.selection?.().selectedAccountId ?? null),
 			emptyMessage: `Not signed in to ${PROVIDER_NAME$1}. Sign in with the CodeBuddy desktop client, or add an account from Settings > WorkBuddy.`,
@@ -34727,6 +35511,10 @@ const catalogInFlight = /* @__PURE__ */ new Map();
 function clearCachedCatalog() {
 	catalogCache = null;
 }
+/** The listing currently held, or an empty array before the first load. */
+function getCachedCatalog() {
+	return catalogCache?.models ?? [];
+}
 /**
 * Read one entry of the live listing.
 *
@@ -35022,22 +35810,108 @@ function parseQuotaHeaders(headers) {
 		}
 	};
 }
-let quotaCache = null;
+/**
+* Cache key of one account's snapshot.
+*
+* A pool row id when the caller names one — that is the identity that survives a
+* token refresh and the one the account card asks with — and otherwise the
+* credential's token tail, which is all a single-credential process has. The
+* `acc:` prefix keeps the two apart, so no row id can ever be answered with an
+* entry written under a token tail.
+*/
+function quotaEntryKey(accountId, credentials) {
+	return accountId === void 0 || accountId === "" ? accountKeyFor(credentials) : `acc:${accountId}`;
+}
+/**
+* How many accounts' snapshots are remembered.
+*
+* Mirrors the bound the ChatGPT line's usage service applies to its own
+* per-account map: room for every account a user is likely to pool, and no way
+* for a long-lived process to accumulate one snapshot per token it has seen.
+*/
+const QUOTA_ACCOUNT_LIMIT = 20;
+/**
+* The newest snapshot of each account, keyed by {@link quotaEntryKey}.
+*
+* ONE ENTRY PER ACCOUNT rather than one slot for the line: quota follows the
+* account, and rotation decides which account spends the next request, so a
+* single slot could only ever describe whichever account was read last. This is
+* a memory read only — the settings card builds its account list from it, and
+* that must never cost one upstream request per pooled account.
+*/
+const quotaCache = /* @__PURE__ */ new Map();
+/**
+* Key of the entry written most recently.
+*
+* The pre-pool card asks "whatever was read last", and a header reading that
+* names no account may only merge into the snapshot it was read beside. Both
+* need the last WRITE rather than a scan: two accounts can be written inside one
+* millisecond, and a tie would otherwise be broken by map order.
+*/
+let quotaLastKey = null;
 const quotaInFlight = /* @__PURE__ */ new Map();
-/** Drop the cached snapshot. Called on sign-out and after a credential change. */
+/** Drop every cached snapshot. Called on sign-out and after a credential change. */
 function clearCachedQuota$1() {
-	quotaCache = null;
+	quotaCache.clear();
+	quotaLastKey = null;
+}
+/** The entry written most recently, whichever account it belongs to. */
+function newestQuotaEntry() {
+	return quotaLastKey === null ? null : quotaCache.get(quotaLastKey) ?? null;
+}
+/**
+* Remember one account's newest snapshot, bounded to the accounts in use.
+*
+* The oldest entry is measured by {@link QuotaCacheEntry.observedAt} rather than
+* by `fetchedAt`: a snapshot kept warm by response headers has no full read
+* behind it at all, and it is still the newest thing known about that account.
+*/
+function rememberQuota(entry) {
+	quotaCache.set(entry.key, entry);
+	quotaLastKey = entry.key;
+	while (quotaCache.size > QUOTA_ACCOUNT_LIMIT) {
+		const oldest = [...quotaCache.entries()].sort((left, right) => left[1].observedAt - right[1].observedAt)[0];
+		if (oldest === void 0) break;
+		quotaCache.delete(oldest[0]);
+		if (quotaLastKey === oldest[0]) quotaLastKey = null;
+	}
 }
 /**
 * The cached snapshot, optionally only when it belongs to this credential.
 *
 * With one stored account the argument is unnecessary; it exists so a later
 * pool chunk cannot render one account's usage under another account's name.
+* Given a credential the answer is THAT account's own newest snapshot, which is
+* what keeps two pooled accounts apart: a later read of a different account
+* cannot displace it. Without one the pre-pool answer is kept — whatever was
+* written last — because the single-account card has no identity to ask with.
 */
 function getCachedQuota$1(credentials) {
-	if (quotaCache === null) return null;
-	if (credentials === void 0) return quotaCache.quota;
-	return quotaCache.key === accountKeyFor(credentials) ? quotaCache.quota : null;
+	if (credentials === void 0) return newestQuotaEntry()?.quota ?? null;
+	return cachedQuotaFor(credentials);
+}
+/**
+* The newest snapshot held for one credential's account, for display only.
+*
+* The token-tail form, kept for a composition with a single stored credential.
+* A pooled caller asks {@link cachedQuotaForPool} with the row id instead: a
+* token is rotated by every refresh, so an entry filed under a tail is lost the
+* moment the account renews.
+*/
+function cachedQuotaFor(credentials) {
+	return quotaCache.get(accountKeyFor(credentials))?.quota ?? null;
+}
+/**
+* The newest snapshot held for one pool row, for display only.
+*
+* The pool asks here while it builds the account list for the settings card, so
+* this is a pure memory read: it never fetches. Null means nothing was ever read
+* for this account, which is a different statement from "nothing used". A row id
+* that is undefined falls back to the credential's own tail, which is what a
+* composition without a pool has.
+*/
+function cachedQuotaForPool(accountId, credentials) {
+	return quotaCache.get(quotaEntryKey(accountId, credentials))?.quota ?? null;
 }
 /**
 * Read the account's usage meters.
@@ -35055,12 +35929,13 @@ function getCachedQuota$1(credentials) {
 * up staring at a card that claims they are fine.
 */
 function fetchAccountQuota$1(credentials, options = {}) {
-	const key = accountKeyFor(credentials);
+	const key = quotaEntryKey(options.accountId, credentials);
 	const at = now();
-	if (options.force !== true && quotaCache !== null && quotaCache.key === key) {
-		const warm = at - quotaCache.observedAt < QUOTA_CACHE_TTL_MS;
-		const freshFullRead = quotaCache.fullReadAt !== null && at - quotaCache.fullReadAt < 3e5;
-		if (warm && freshFullRead) return Promise.resolve(quotaCache.quota);
+	const cached = quotaCache.get(key);
+	if (options.force !== true && cached !== void 0) {
+		const warm = at - cached.observedAt < QUOTA_CACHE_TTL_MS;
+		const freshFullRead = cached.fullReadAt !== null && at - cached.fullReadAt < 3e5;
+		if (warm && freshFullRead) return Promise.resolve(cached.quota);
 	}
 	const pending = quotaInFlight.get(key);
 	if (pending !== void 0) return pending;
@@ -35075,9 +35950,9 @@ function fetchAccountQuota$1(credentials, options = {}) {
 	return run;
 }
 async function performQuotaFetch(credentials, options) {
-	const key = accountKeyFor(credentials);
+	const key = quotaEntryKey(options.accountId, credentials);
 	const fetchFn = options.fetchFn ?? fetch;
-	const previous = quotaCache !== null && quotaCache.key === key ? quotaCache.quota : null;
+	const previous = quotaCache.get(key)?.quota ?? null;
 	let response;
 	try {
 		response = await fetchFn("https://api.anthropic.com/api/oauth/usage", {
@@ -35115,12 +35990,12 @@ async function performQuotaFetch(credentials, options) {
 		status: null,
 		representativeClaim: null
 	};
-	quotaCache = {
+	rememberQuota({
 		quota,
 		key,
 		fullReadAt: at,
 		observedAt: at
-	};
+	});
 	return quota;
 }
 /**
@@ -39747,6 +40622,32 @@ async function refreshClaudeCredential(credentials, fetchFn) {
 	};
 }
 /**
+* One account's own newest quota snapshot, in the shape the account card draws.
+*
+* The snapshot comes from 'client.ts''s per-account cache, and this is where
+* this line's own numbers are translated into the shared shape. Every judgement
+* below trades a possibly-nice-looking bar for an honest one:
+*
+* - a window whose consumed share nobody measured is DROPPED (`quotaWindow`
+*   returns null), because "0% used" and "not stated" are different claims;
+* - the share falls back to `100 - remainingPercent` only when that field was
+*   stated; when the payload stated NEITHER share there is nothing to draw;
+* - the read time is the full read's own `fetchedAt`, or — for a snapshot that
+*   only response headers ever kept warm, which performed no full read — the
+*   `observedAt` instant those numbers arrived. Either way it is when this line
+*   saw the numbers, never when upstream served them.
+*
+* A null snapshot means "this account was never read", which `poolQuota` reports
+* as undefined so the card can say exactly that instead of drawing a zero.
+*/
+function claudePoolQuota(snapshot) {
+	if (snapshot === null) return void 0;
+	return poolQuota(snapshot.fetchedAt ?? snapshot.observedAt, snapshot.windows.map((window) => quotaWindow$1(window.label, window.usedPercent ?? (window.remainingPercent === null ? null : 100 - window.remainingPercent), {
+		windowDurationMins: window.windowMinutes,
+		resetsAt: typeof window.resetsAt === "string" ? Date.parse(window.resetsAt) : null
+	})));
+}
+/**
 * The Claude subscription account pool.
 *
 * Read the module comment first: it carries the two rules this class exists to
@@ -39844,6 +40745,7 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 				const subscriptionType = account.subscriptionType ?? credentials.subscriptionType;
 				const adopted = account.adopted === true;
 				const expired = adopted && adoptedCredentialExpired(credentials);
+				const quota = claudePoolQuota(cachedQuotaForPool(account.id, credentials));
 				return {
 					...base,
 					...email === void 0 ? {} : { email },
@@ -39855,6 +40757,7 @@ var ClaudeAccountPool = class extends AccountPoolCore {
 					source: account.source,
 					removable: !adopted,
 					...account.sourcePath === void 0 ? {} : { sourcePath: account.sourcePath },
+					...quota === void 0 ? {} : { quota },
 					...expired ? {
 						authStatus: "expired",
 						authFailedReason: ADOPTED_CREDENTIAL_EXPIRED_HINT
@@ -40421,7 +41324,7 @@ async function getClaudeWebStatus(store, modelSettings, preferences, options = {
 	const catalog = live.length > 0 ? live : FALLBACK_MODELS;
 	const available = catalog.map((model) => model.id);
 	const models = buildClaudeModelOptions(catalog, available, resolveEnabledModelIds(settings.enabledModelIds, available, enabled), settings.contextWindowOverrides);
-	const quota = credential === void 0 ? getCachedQuota$1() : getCachedQuota$1(credential);
+	const quota = credential === void 0 ? getCachedQuota$1() : cachedQuotaForPool(active.id, credential);
 	const poolData = options.accountPool === void 0 ? null : await options.accountPool.read().catch(() => null);
 	const poolAccounts = options.accountPool === void 0 ? [] : await options.accountPool.listAccounts().catch(() => []);
 	const presence = await claudeCodeCredentialPresence(options.adoptPaths ?? claudeCodeCredentialPaths()).catch(() => ({
@@ -40555,13 +41458,14 @@ function registerClaudeRoutes(ctx, store, modelSettings, preferences, options =
 				if (path === "" || path === "status") {
 					if (method !== "GET") return sendMethodNotAllowed(response);
 					const active = await activeAccount();
-					const cached = active.credentials === void 0 ? null : getCachedQuota$1(active.credentials);
+					const cached = active.credentials === void 0 ? null : cachedQuotaForPool(active.id, active.credentials);
 					const stale = cached === null || Date.now() - (cached.fetchedAt || 0) > 12e4;
 					if (active.credentials !== void 0 && stale) {
 						const credentials = active.credentials;
 						const refresh = () => fetchAccountQuota$1(credentials, {
 							fetchFn,
-							signal: quotaAbort.signal
+							signal: quotaAbort.signal,
+							accountId: active.id
 						});
 						if (cached === null) await quotaRefresh.run(refresh);
 						else quotaRefresh.start(refresh);
@@ -40683,7 +41587,8 @@ function registerClaudeRoutes(ctx, store, modelSettings, preferences, options =
 						await fetchAccountQuota$1(credentials, {
 							fetchFn,
 							force: method === "POST",
-							signal: quotaAbort.signal
+							signal: quotaAbort.signal,
+							accountId: active.id
 						});
 					} catch (error) {
 						quotaError = error instanceof Error ? error.message : String(error);
@@ -44299,39 +45204,24 @@ function apply(ctx, pluginConfig = {}) {
 			provider,
 			limits: providerLimits
 		})]));
-		const antigravityAdapter = new AntigravityAdapter(antigravityStore, antigravityModelSettings, antigravityPreferences, {
-			fetchFn: modelFetch.antigravity,
-			attachments: ctx.attachments
-		}, antigravityAccountPool);
-		let antigravityRegistration;
-		let antigravityConflict = null;
-		const claimAntigravityRoute = () => {
-			if (antigravityRegistration !== void 0) return;
-			try {
-				antigravityRegistration = ctx.llm.registerAdapter([PROVIDER_ID$6], antigravityAdapter);
-				if (antigravityConflict !== null) ctx.logger.info(`[dsh-chatgpt-subscription] Antigravity route "${PROVIDER_ID$6}" is now served by this plugin`);
-				antigravityConflict = null;
-			} catch (error) {
-				antigravityConflict = error instanceof Error ? error.message : String(error);
-				ctx.logger.warn(`[dsh-chatgpt-subscription] provider route "${PROVIDER_ID$6}" is already owned by another adapter; Antigravity models keep being served by that one until its configuration is removed (${antigravityConflict})`);
-			}
-		};
-		claimAntigravityRoute();
-		const antigravityRouteWatch = typeof ctx.on === "function" ? ctx.on("llm/adapters-updated", () => {
-			claimAntigravityRoute();
-		}) : void 0;
+		const antigravityClaim = claimProviderRoute(ctx, {
+			providerId: PROVIDER_ID$6,
+			label: PROVIDER_NAME$6,
+			adapter: new AntigravityAdapter(antigravityStore, antigravityModelSettings, antigravityPreferences, {
+				fetchFn: modelFetch.antigravity,
+				attachments: ctx.attachments
+			}, antigravityAccountPool)
+		});
 		const disposeAntigravityRoutes = registerAntigravityRoutes(ctx, antigravityStore, antigravityModelSettings, antigravityPreferences, proxyFetch, antigravityAccountPool);
 		const disposeCommandCodeRoutes = registerCommandCodeRoutes(ctx, commandCodeStore, commandCodeModelSettings, commandCodePreferences, {
 			fetchFn: proxyFetch,
-			serving: () => commandCodeRegistration !== void 0,
-			conflict: () => commandCodeConflict
+			serving: () => commandCodeClaim.serving(),
+			conflict: () => commandCodeClaim.conflict()
 		}, commandCodeAccountPool);
 		const commandCodeAdapter = new CommandCodeAdapter(commandCodeStore, commandCodeModelSettings, commandCodePreferences, {
 			fetchFn: modelFetch["command-code"],
 			attachments: ctx.attachments
 		}, commandCodeAccountPool);
-		let commandCodeRegistration;
-		let commandCodeConflict = null;
 		const ollamaStore = new FileCredentialStore$5();
 		const ollamaModelSettings = new FileModelSettingsStore$5();
 		const ollamaAccountPool = new OllamaAccountPool({ store: ollamaStore });
@@ -44339,92 +45229,48 @@ function apply(ctx, pluginConfig = {}) {
 			fetchFn: modelFetch.ollama,
 			attachments: ctx.attachments
 		}, ollamaAccountPool);
-		let ollamaRegistration;
-		let ollamaConflict = null;
-		const kimiCodeAdapter = new KimiCodeAdapter(kimiCodeStore, kimiCodeModelSettings, kimiCodePreferences, {
-			fetchFn: modelFetch["kimi-code"],
-			attachments: ctx.attachments,
-			videos: { readVideo: async (ref) => ({
-				data: await readVideoBytes(ref),
-				mediaType: ref.mediaType
-			}) }
-		}, kimiCodeAccountPool);
-		let kimiCodeRegistration;
-		let kimiCodeConflict = null;
-		const claimKimiCodeRoute = () => {
-			if (kimiCodeRegistration !== void 0) return;
-			try {
-				kimiCodeRegistration = ctx.llm.registerAdapter([PROVIDER_ID$3], kimiCodeAdapter);
-				if (kimiCodeConflict !== null) ctx.logger.info(`[dsh-chatgpt-subscription] ${PROVIDER_NAME$3} route "${PROVIDER_ID$3}" is now served by this plugin`);
-				kimiCodeConflict = null;
-			} catch (error) {
-				kimiCodeConflict = error instanceof Error ? error.message : String(error);
-				ctx.logger.warn(`[dsh-chatgpt-subscription] provider route "${PROVIDER_ID$3}" is already owned by another adapter; ${PROVIDER_NAME$3} models keep being served by that one until its configuration is removed (${kimiCodeConflict})`);
-			}
-		};
-		claimKimiCodeRoute();
-		const kimiCodeRouteWatch = typeof ctx.on === "function" ? ctx.on("llm/adapters-updated", () => {
-			claimKimiCodeRoute();
-		}) : void 0;
-		const claimOllamaRoute = () => {
-			if (ollamaRegistration !== void 0) return;
-			try {
-				ollamaRegistration = ctx.llm.registerAdapter([PROVIDER_ID$4], ollamaAdapter);
-				if (ollamaConflict !== null) ctx.logger.info(`[dsh-chatgpt-subscription] ${PROVIDER_NAME$4} route "${PROVIDER_ID$4}" is now served by this plugin`);
-				ollamaConflict = null;
-			} catch (error) {
-				ollamaConflict = error instanceof Error ? error.message : String(error);
-				ctx.logger.warn(`[dsh-chatgpt-subscription] provider route "${PROVIDER_ID$4}" is already owned by another adapter; ${PROVIDER_NAME$4} models keep being served by that one until its configuration is removed (${ollamaConflict})`);
-			}
-		};
-		claimOllamaRoute();
+		const kimiCodeClaim = claimProviderRoute(ctx, {
+			providerId: PROVIDER_ID$3,
+			label: PROVIDER_NAME$3,
+			adapter: new KimiCodeAdapter(kimiCodeStore, kimiCodeModelSettings, kimiCodePreferences, {
+				fetchFn: modelFetch["kimi-code"],
+				attachments: ctx.attachments,
+				videos: { readVideo: async (ref) => ({
+					data: await readVideoBytes(ref),
+					mediaType: ref.mediaType
+				}) }
+			}, kimiCodeAccountPool)
+		});
+		const ollamaClaim = claimProviderRoute(ctx, {
+			providerId: PROVIDER_ID$4,
+			label: PROVIDER_NAME$4,
+			adapter: ollamaAdapter,
+			watch: false
+		});
 		const disposeOllamaRoutes = registerOllamaRoutes(ctx, {
 			accountPool: ollamaAccountPool,
 			modelSettings: ollamaModelSettings,
 			fetchFn: proxyFetch
 		});
-		const claimCommandCodeRoute = () => {
-			if (commandCodeRegistration !== void 0) return;
-			try {
-				commandCodeRegistration = ctx.llm.registerAdapter([PROVIDER_ID$5], commandCodeAdapter);
-				if (commandCodeConflict !== null) ctx.logger.info(`[dsh-chatgpt-subscription] ${PROVIDER_NAME$5} route "${PROVIDER_ID$5}" is now served by this plugin`);
-				commandCodeConflict = null;
-			} catch (error) {
-				commandCodeConflict = error instanceof Error ? error.message : String(error);
-				ctx.logger.warn(`[dsh-chatgpt-subscription] provider route "${PROVIDER_ID$5}" is already owned by another adapter; ${PROVIDER_NAME$5} models keep being served by that one until its configuration is removed (${commandCodeConflict})`);
-			}
-		};
-		claimCommandCodeRoute();
-		const commandCodeRouteWatch = typeof ctx.on === "function" ? ctx.on("llm/adapters-updated", () => {
-			claimCommandCodeRoute();
-		}) : void 0;
+		const commandCodeClaim = claimProviderRoute(ctx, {
+			providerId: PROVIDER_ID$5,
+			label: PROVIDER_NAME$5,
+			adapter: commandCodeAdapter
+		});
 		const disposeKimiCodeRoutes = registerKimiCodeRoutes(ctx, kimiCodeStore, kimiCodeModelSettings, kimiCodePreferences, {
 			fetchFn: proxyFetch,
-			serving: () => kimiCodeRegistration !== void 0,
-			conflict: () => kimiCodeConflict
+			serving: () => kimiCodeClaim.serving(),
+			conflict: () => kimiCodeClaim.conflict()
 		}, kimiCodeAccountPool);
-		const minimaxCodeAdapter = new MinimaxCodeAdapter(minimaxCodeStore, {
-			fetchFn: modelFetch["minimax-code"],
-			attachments: ctx.attachments,
-			accountPool: minimaxCodeAccountPool
-		}, minimaxCodeModelSettings, minimaxCodePreferences);
-		let minimaxCodeRegistration;
-		let minimaxCodeConflict = null;
-		const claimMinimaxCodeRoute = () => {
-			if (minimaxCodeRegistration !== void 0) return;
-			try {
-				minimaxCodeRegistration = ctx.llm.registerAdapter([PROVIDER_ID$2], minimaxCodeAdapter);
-				if (minimaxCodeConflict !== null) ctx.logger.info(`[dsh-chatgpt-subscription] ${PROVIDER_NAME$2} route "${PROVIDER_ID$2}" is now served by this plugin`);
-				minimaxCodeConflict = null;
-			} catch (error) {
-				minimaxCodeConflict = error instanceof Error ? error.message : String(error);
-				ctx.logger.warn(`[dsh-chatgpt-subscription] provider route "${PROVIDER_ID$2}" is already owned by another adapter; ${PROVIDER_NAME$2} models keep being served by that one until its configuration is removed (${minimaxCodeConflict})`);
-			}
-		};
-		claimMinimaxCodeRoute();
-		const minimaxCodeRouteWatch = typeof ctx.on === "function" ? ctx.on("llm/adapters-updated", () => {
-			claimMinimaxCodeRoute();
-		}) : void 0;
+		const minimaxCodeClaim = claimProviderRoute(ctx, {
+			providerId: PROVIDER_ID$2,
+			label: PROVIDER_NAME$2,
+			adapter: new MinimaxCodeAdapter(minimaxCodeStore, {
+				fetchFn: modelFetch["minimax-code"],
+				attachments: ctx.attachments,
+				accountPool: minimaxCodeAccountPool
+			}, minimaxCodeModelSettings, minimaxCodePreferences)
+		});
 		let minimaxCodeAppVersion;
 		try {
 			const manifest = createRequire(import.meta.url)("../package.json");
@@ -44448,33 +45294,20 @@ function apply(ctx, pluginConfig = {}) {
 		minimaxCodeCheckinTick();
 		const disposeMinimaxCodeRoutes = registerMinimaxCodeRoutes(ctx, minimaxCodeStore, {
 			fetchFn: proxyFetch,
-			serving: () => minimaxCodeRegistration !== void 0,
-			conflict: () => minimaxCodeConflict,
+			serving: () => minimaxCodeClaim.serving(),
+			conflict: () => minimaxCodeClaim.conflict(),
 			accountPool: minimaxCodeAccountPool,
 			checkin: minimaxCodeCheckin
 		}, minimaxCodeModelSettings, minimaxCodePreferences);
-		const workBuddyAdapter = new WorkBuddyAdapter(workBuddyStore, workBuddyModelSettings, workBuddyPreferences, {
-			fetchFn: modelFetch.workbuddy,
-			attachments: ctx.attachments,
-			accountPool: workBuddyAccountPool
+		const workBuddyClaim = claimProviderRoute(ctx, {
+			providerId: PROVIDER_ID$1,
+			label: PROVIDER_NAME$1,
+			adapter: new WorkBuddyAdapter(workBuddyStore, workBuddyModelSettings, workBuddyPreferences, {
+				fetchFn: modelFetch.workbuddy,
+				attachments: ctx.attachments,
+				accountPool: workBuddyAccountPool
+			})
 		});
-		let workBuddyRegistration;
-		let workBuddyConflict = null;
-		const claimWorkBuddyRoute = () => {
-			if (workBuddyRegistration !== void 0) return;
-			try {
-				workBuddyRegistration = ctx.llm.registerAdapter([PROVIDER_ID$1], workBuddyAdapter);
-				if (workBuddyConflict !== null) ctx.logger.info(`[dsh-chatgpt-subscription] ${PROVIDER_NAME$1} route "${PROVIDER_ID$1}" is now served by this plugin`);
-				workBuddyConflict = null;
-			} catch (error) {
-				workBuddyConflict = error instanceof Error ? error.message : String(error);
-				ctx.logger.warn(`[dsh-chatgpt-subscription] provider route "${PROVIDER_ID$1}" is already owned by another adapter; ${PROVIDER_NAME$1} models keep being served by that one until its configuration is removed (${workBuddyConflict})`);
-			}
-		};
-		claimWorkBuddyRoute();
-		const workBuddyRouteWatch = typeof ctx.on === "function" ? ctx.on("llm/adapters-updated", () => {
-			claimWorkBuddyRoute();
-		}) : void 0;
 		const workBuddyCheckin = new WorkBuddyCheckinService(workBuddyStore, {
 			fetchFn: proxyFetch,
 			settings: () => workBuddyPreferences.status().checkin,
@@ -44490,37 +45323,24 @@ function apply(ctx, pluginConfig = {}) {
 		checkinTick();
 		const disposeWorkBuddyRoutes = registerWorkBuddyRoutes(ctx, workBuddyStore, workBuddyModelSettings, workBuddyPreferences, {
 			fetchFn: proxyFetch,
-			serving: () => workBuddyRegistration !== void 0,
-			conflict: () => workBuddyConflict,
+			serving: () => workBuddyClaim.serving(),
+			conflict: () => workBuddyClaim.conflict(),
 			accountPool: workBuddyAccountPool,
 			checkin: workBuddyCheckin
 		});
-		const claudeAdapter = new ClaudeAdapter(claudeStore, claudeModelSettings, claudePreferences, {
-			fetchFn: modelFetch.claude,
-			attachments: ctx.attachments,
-			accountPool: claudeAccountPool
+		const claudeClaim = claimProviderRoute(ctx, {
+			providerId: PROVIDER_ID,
+			label: PROVIDER_NAME,
+			adapter: new ClaudeAdapter(claudeStore, claudeModelSettings, claudePreferences, {
+				fetchFn: modelFetch.claude,
+				attachments: ctx.attachments,
+				accountPool: claudeAccountPool
+			})
 		});
-		let claudeRegistration;
-		let claudeConflict = null;
-		const claimClaudeRoute = () => {
-			if (claudeRegistration !== void 0) return;
-			try {
-				claudeRegistration = ctx.llm.registerAdapter([PROVIDER_ID], claudeAdapter);
-				if (claudeConflict !== null) ctx.logger.info(`[dsh-chatgpt-subscription] ${PROVIDER_NAME} route "${PROVIDER_ID}" is now served by this plugin`);
-				claudeConflict = null;
-			} catch (error) {
-				claudeConflict = error instanceof Error ? error.message : String(error);
-				ctx.logger.warn(`[dsh-chatgpt-subscription] provider route "${PROVIDER_ID}" is already owned by another adapter; ${PROVIDER_NAME} models keep being served by that one until its configuration is removed (${claudeConflict})`);
-			}
-		};
-		claimClaudeRoute();
-		const claudeRouteWatch = typeof ctx.on === "function" ? ctx.on("llm/adapters-updated", () => {
-			claimClaudeRoute();
-		}) : void 0;
 		const disposeClaudeRoutes = registerClaudeRoutes(ctx, claudeStore, claudeModelSettings, claudePreferences, {
 			fetchFn: proxyFetch,
-			serving: () => claudeRegistration !== void 0,
-			conflict: () => claudeConflict,
+			serving: () => claudeClaim.serving(),
+			conflict: () => claudeClaim.conflict(),
 			accountPool: claudeAccountPool
 		});
 		workBuddyAccountPool.syncDesktopAccounts().catch(() => void 0);
@@ -44531,7 +45351,11 @@ function apply(ctx, pluginConfig = {}) {
 			pool: codexAccountPool
 		});
 		const usage = new UsageService(oauth, { fetchFn: proxyFetch });
-		codexAccountPool.setQuotaBlockedUntil((account, now) => usage.blockedUntilFor(account.credentials, now));
+		codexAccountPool.setQuotaBlockedUntil((account, now) => usage.blockedUntilFor(account.id, account.credentials, now));
+		codexAccountPool.setQuotaSnapshot((account) => {
+			const snapshot = usage.snapshotFor(account.id, account.credentials);
+			return snapshot === void 0 ? void 0 : codexAccountQuota(snapshot);
+		});
 		const adapter = new CodexChatGptAdapter(new ResponsesClient(oauth, ctx.attachments, {
 			fetchFn: modelFetch["codex-chatgpt"],
 			accountPool: codexAccountPool,
@@ -44587,6 +45411,145 @@ function apply(ctx, pluginConfig = {}) {
 			});
 		};
 		const disposeRoutes = registerRoutes(ctx, oauth, usage, preferences, proxyManager, searchSwitcher, readRouteAudit, codexAccountPool, fetchConfiguration);
+		const routable = (accounts) => accounts.some((account) => account.authStatus === void 0 || account.authStatus === "ok");
+		const disposeHubOverview = registerHubOverviewRoutes(ctx, [
+			{
+				id: "chatgpt",
+				providerId: PROVIDER_ID$7,
+				canToggle: true,
+				read: async () => {
+					const current = preferences.status();
+					const accounts = await codexAccountPool.listAccounts().catch(() => []);
+					return {
+						enabled: current.enabled !== false,
+						accountCount: accounts.length,
+						authenticated: routable(accounts),
+						enabledModelCount: current.visibleModelIds.length,
+						totalModelCount: CODEX_MODEL_CATALOG.length
+					};
+				}
+			},
+			{
+				id: "antigravity",
+				providerId: PROVIDER_ID$6,
+				canToggle: true,
+				read: async () => {
+					const current = antigravityPreferences.status();
+					const accounts = await antigravityAccountPool.listAccounts().catch(() => []);
+					const total = catalogTotal((await antigravityModelSettings.read()).catalogModels.length);
+					return {
+						enabled: current.enabled !== false,
+						accountCount: accounts.length,
+						authenticated: routable(accounts),
+						enabledModelCount: total === null ? null : Math.min(current.enabledModelIds?.length ?? 0, total),
+						totalModelCount: total
+					};
+				}
+			},
+			{
+				id: "command-code",
+				providerId: PROVIDER_ID$5,
+				canToggle: true,
+				read: async () => {
+					const current = commandCodePreferences.status();
+					const accounts = await commandCodeAccountPool.listAccounts().catch(() => []);
+					const total = catalogTotal((await commandCodeModelSettings.read()).catalogModels.length);
+					return {
+						enabled: current.enabled !== false,
+						accountCount: accounts.length,
+						authenticated: routable(accounts),
+						enabledModelCount: total === null ? null : Math.min(current.enabledModelIds?.length ?? 0, total),
+						totalModelCount: total
+					};
+				}
+			},
+			{
+				id: "kimi-code",
+				providerId: PROVIDER_ID$3,
+				canToggle: true,
+				read: async () => {
+					const current = kimiCodePreferences.status();
+					const accounts = await kimiCodeAccountPool.listAccounts().catch(() => []);
+					const total = catalogTotal((await kimiCodeModelSettings.read()).catalogModels.length);
+					return {
+						enabled: current.enabled !== false,
+						accountCount: accounts.length,
+						authenticated: routable(accounts),
+						enabledModelCount: total === null ? null : Math.min(current.enabledModelIds?.length ?? 0, total),
+						totalModelCount: total
+					};
+				}
+			},
+			{
+				id: "workbuddy",
+				providerId: PROVIDER_ID$1,
+				canToggle: true,
+				read: async () => {
+					const current = workBuddyPreferences.status();
+					const accounts = await workBuddyAccountPool.listAccounts().catch(() => []);
+					const total = catalogTotal(getCachedCatalog$1().length);
+					return {
+						enabled: current.enabled !== false,
+						accountCount: accounts.length,
+						authenticated: routable(accounts),
+						enabledModelCount: total === null ? null : Math.min(current.enabledModelIds?.length ?? 0, total),
+						totalModelCount: total
+					};
+				}
+			},
+			{
+				id: "minimax-code",
+				providerId: PROVIDER_ID$2,
+				canToggle: true,
+				read: async () => {
+					const current = minimaxCodePreferences.status();
+					const accounts = await minimaxCodeAccountPool.listAccounts().catch(() => []);
+					const total = catalogTotal(catalogSize());
+					return {
+						enabled: current.enabled !== false,
+						accountCount: accounts.length,
+						authenticated: routable(accounts),
+						enabledModelCount: total === null ? null : Math.min(current.enabledModelIds?.length ?? 0, total),
+						totalModelCount: total
+					};
+				}
+			},
+			{
+				id: "claude",
+				providerId: PROVIDER_ID,
+				canToggle: true,
+				read: async () => {
+					const current = claudePreferences.status();
+					const accounts = await claudeAccountPool.listAccounts().catch(() => []);
+					const total = catalogTotal(getCachedCatalog().length);
+					return {
+						enabled: current.enabled !== false,
+						accountCount: accounts.length,
+						authenticated: routable(accounts),
+						enabledModelCount: total === null ? null : Math.min(current.enabledModelIds?.length ?? 0, total),
+						totalModelCount: total
+					};
+				}
+			},
+			{
+				id: "ollama",
+				providerId: PROVIDER_ID$4,
+				canToggle: false,
+				read: async () => {
+					const accounts = await ollamaAccountPool.listAccounts().catch(() => []);
+					const current = ollamaModelSettings.status();
+					const total = catalogTotal(current.catalogModels.length);
+					const enabled = current.enabledModelIds.length === 0 ? total : current.enabledModelIds.length;
+					return {
+						enabled: true,
+						accountCount: accounts.length,
+						authenticated: routable(accounts),
+						enabledModelCount: total === null ? null : Math.min(enabled ?? 0, total),
+						totalModelCount: total
+					};
+				}
+			}
+		]);
 		const disposeAdapter = ctx.llm.registerAdapter([PROVIDER_ID$7], adapter);
 		const disposeImageTool = ctx.tools.register(createCodexImageTool(oauth, ctx.attachments, { fetchFn: proxyFetch }));
 		const disposeVideoTool = ctx.tools.register(createKimiVideoTool(ctx, { fetchFn: proxyFetch }));
@@ -44613,48 +45576,28 @@ function apply(ctx, pluginConfig = {}) {
 			disposeVideoTool();
 			disposeAdapter();
 			disposeRoutes();
+			disposeHubOverview();
 			disposeAntigravityRoutes();
-			releaseHandle(antigravityRouteWatch);
-			antigravityRegistration?.();
-			antigravityRegistration = void 0;
+			antigravityClaim.dispose();
 			disposeOllamaRoutes();
-			ollamaRegistration?.();
-			ollamaRegistration = void 0;
+			ollamaClaim.dispose();
 			disposeCommandCodeRoutes();
-			releaseHandle(commandCodeRouteWatch);
-			commandCodeRegistration?.();
-			commandCodeRegistration = void 0;
+			commandCodeClaim.dispose();
 			disposeKimiCodeRoutes();
-			releaseHandle(kimiCodeRouteWatch);
-			kimiCodeRegistration?.();
-			kimiCodeRegistration = void 0;
+			kimiCodeClaim.dispose();
 			disposeMinimaxCodeRoutes();
-			releaseHandle(minimaxCodeRouteWatch);
-			minimaxCodeRegistration?.();
-			minimaxCodeRegistration = void 0;
+			minimaxCodeClaim.dispose();
 			clearInterval(minimaxCodeCheckinTimer);
 			clearInterval(checkinTimer);
 			disposeWorkBuddyRoutes();
-			releaseHandle(workBuddyRouteWatch);
-			workBuddyRegistration?.();
-			workBuddyRegistration = void 0;
+			workBuddyClaim.dispose();
 			disposeClaudeRoutes();
-			releaseHandle(claudeRouteWatch);
-			claudeRegistration?.();
-			claudeRegistration = void 0;
+			claudeClaim.dispose();
 			oauth.dispose();
 			proxyManager.dispose();
 		};
 	}, "dsh-chatgpt-subscription: adapter, routes, and lifecycle");
 }
-/** Cordis event handles are either a disposer function or a disposable object. */
-function releaseHandle(handle) {
-	if (typeof handle === "function") {
-		handle();
-		return;
-	}
-	handle?.dispose?.();
-}
 function localWebServerBaseUrl(host, port) {
 	return `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${port}`;
 }