@bitkyc08/opencodex 2.67.0 → 2.68.0-preview.20260927

package/src/providers/quota/account-cache.ts

@@ -3,8 +3,10 @@ import { getValidAccessTokenForAccount } from "../../oauth";
 import { getAccountCredential, getAccountSet } from "../../oauth/store";
 import type { GenerationContext } from "../../lib/state-store-sweeper";
 import { ACCOUNT_QUOTA_TTL_MS, toFiniteNumber } from "../quota-wire";
-import { clearKiroAccountUsageState, reconcileKiroAccountUsageState } from "../kiro-usage";
-import { cancelPendingAccountQuotaPersist, readPersistedAccountQuotas, schedulePersistAccountQuotas } from "../account-quota-disk";
+import { clearKiroAccountUsageState, hydrateKiroUsageVerdict, kiroPersistableVerdicts, reconcileKiroAccountUsageState } from "../kiro-usage";
+import { kiroEvidenceIdentity, sanitizeKiroQuota, type KiroPersistedQuota } from "../kiro-account-state-disk";
+import { cancelPendingAccountQuotaPersist, readPersistedAccountQuotas, readPersistedKiroVerdicts, schedulePersistAccountQuotas } from "../account-quota-disk";
+import type { ProviderAccount } from "../../oauth/types";
 import { replaceCachedProviderQuotas } from "../quota-routing-cache";
 import { getProviderRegistryEntry } from "../registry";
 import { getProviderQuotaReportCache, hasQuotaRows, routingEvidence, setProviderQuotaReportCache } from "./report-cache";
@@ -102,26 +104,51 @@ let diskHydrated = false;
 export function hydrateAccountQuotaCache(): void {
   if (diskHydrated) return;
   diskHydrated = true;
-  for (const [key, quota] of readPersistedAccountQuotas()) {
+  const now = Date.now();
+  const liveKiro = new Map<string, ProviderAccount>(getAccountSet("kiro")?.accounts.map(account =>
+    [accountCacheKey("kiro", account.id), account]) ?? []);
+  for (const [key, quota] of readPersistedAccountQuotas(now)) {
+    if (key.startsWith("kiro\0")) {
+      const account = liveKiro.get(key);
+      if (!account || (quota as KiroPersistedQuota).identity !== kiroEvidenceIdentity(account)
+        || typeof quota.monthlyPercent !== "number" || !Number.isFinite(quota.monthlyPercent)
+        || quota.monthlyPercent < 0 || quota.monthlyPercent > 100
+        || now - quota.updatedAt >= ACCOUNT_QUOTA_TTL_MS
+        || (quota.monthlyResetAt !== undefined && (typeof quota.monthlyResetAt !== "number"
+          || !Number.isFinite(quota.monthlyResetAt) || quota.monthlyResetAt <= now
+          || !Number.isFinite(new Date(quota.monthlyResetAt).getTime())))) continue;
+    }
     // Disk stores observation time, not the Anthropic usage probe's clock.
     if (!accountQuotaCache.has(key)) {
       const anthropic = key.startsWith("anthropic\u0000");
       accountQuotaCache.set(key, {
         ts: anthropic ? 0 : quota.updatedAt,
-        quota: anthropic ? normalizeAnthropicQuota(quota, Date.now()) : quota,
+        quota: anthropic ? normalizeAnthropicQuota(quota, now)
+          : key.startsWith("kiro\0") ? sanitizeKiroQuota(quota) : quota,
+        ...(key.startsWith("kiro\0") ? { identity: (quota as KiroPersistedQuota).identity } : {}),
       });
     }
   }
+  for (const [key, verdict] of readPersistedKiroVerdicts(now)) {
+    const account = liveKiro.get(key);
+    if (account && verdict.identity === kiroEvidenceIdentity(account)) hydrateKiroUsageVerdict(key, verdict, account);
+  }
 }
 
 export function persistAccountQuotaCache(): void {
   schedulePersistAccountQuotas(function* () {
     const now = Date.now();
+    const liveKiro = new Map<string, ProviderAccount>(getAccountSet("kiro")?.accounts.map(account =>
+      [accountCacheKey("kiro", account.id), account]) ?? []);
     for (const [key, entry] of accountQuotaCache) {
       const quota = key.startsWith("anthropic\u0000") ? normalizeAnthropicQuota(entry.quota, now) : entry.quota;
-      if (quota) yield [key, quota] as [string, ProviderQuota];
+      if (quota && key.startsWith("kiro\0")) {
+        const account = liveKiro.get(key);
+        if (account && entry.identity === kiroEvidenceIdentity(account))
+          yield [key, { ...sanitizeKiroQuota(quota), identity: entry.identity } as KiroPersistedQuota] as [string, KiroPersistedQuota];
+      } else if (quota) yield [key, quota] as [string, ProviderQuota];
     }
-  });
+  }, () => kiroPersistableVerdicts());
 }
 export const accountQuotaInflight = new Map<string, Promise<AccountQuotaCacheEntry>>();
 let lastReconciledGeneration = 0;
@@ -170,6 +197,10 @@ export function accountCacheKey(provider: string, accountId: string): string {
  */
 export function getCachedProviderAccountQuota(provider: string, accountId: string): ProviderQuota | null {
   const entry = accountQuotaCache.get(accountCacheKey(provider, accountId));
+  if (provider === "kiro") {
+    const account = getAccountSet("kiro")?.accounts.find(row => row.id === accountId);
+    if (!account || entry?.identity !== kiroEvidenceIdentity(account)) return null;
+  }
   if (entry?.isCurrent && !entry.isCurrent()) return null;
   return provider === "anthropic" ? normalizeAnthropicQuota(entry?.quota, Date.now()) : entry?.quota ?? null;
 }
@@ -185,7 +216,9 @@ export function setCachedProviderAccountQuotaForTests(
     accountQuotaCache.delete(key);
     return;
   }
-  accountQuotaCache.set(key, { ts: Date.now(), quota });
+  const account = provider === "kiro" ? getAccountSet("kiro")?.accounts.find(row => row.id === accountId) : undefined;
+  accountQuotaCache.set(key, { ts: Date.now(), quota,
+    ...(account ? { identity: kiroEvidenceIdentity(account) } : {}) });
 }
 
 /** Unified headers report utilization fractions and epoch-second reset times. */
@@ -335,6 +368,7 @@ export function sweepExpiredProviderAccountQuotaRows(now = Date.now()): number {
 
 export function reconcileProviderAccountQuotaRows(context: GenerationContext): number {
   if (context.generation <= lastReconciledGeneration) return 0;
+  hydrateAccountQuotaCache();
   let removed = 0;
   for (const key of accountQuotaCache.keys()) {
     if (context.oauthAccountKeys.has(key)) continue;
@@ -354,6 +388,7 @@ export function reconcileProviderAccountQuotaRows(context: GenerationContext): n
   liveAccountQuotaKeys = new Set(context.oauthAccountKeys);
   liveProviderQuotaKeys = new Set(context.providerNames);
   lastReconciledGeneration = context.generation;
+  if (removed > 0) persistAccountQuotaCache();
   return removed;
 }
 
@@ -377,6 +412,7 @@ export function clearAccountQuotaCache(provider?: string): void {
     cancelPendingAccountQuotaPersist();
     return;
   }
+  hydrateAccountQuotaCache();
   const prefix = `${provider}\u0000`;
   for (const key of [...accountQuotaCache.keys()]) {
     if (key.startsWith(prefix)) accountQuotaCache.delete(key);

package/src/providers/quota/antigravity.ts

@@ -253,16 +253,21 @@ function antigravityUnavailableFailure(
 }
 
 export async function probeAntigravityUsageQuota(accessToken: string, projectId: string): Promise<AntigravityQuotaProbeResult> {
-  const fetchQuota = (url: string) => providerOutboundPost("google-antigravity", { baseUrl: ANTIGRAVITY_ACCOUNT_QUOTA_BASE }, url, {
+  const fetchQuota = (url: string, userAgent = antigravityUserAgent()) => providerOutboundPost("google-antigravity", { baseUrl: ANTIGRAVITY_ACCOUNT_QUOTA_BASE }, url, {
     headers: {
       Accept: "application/json", "Content-Type": "application/json",
-      "User-Agent": antigravityUserAgent(), Authorization: `Bearer ${accessToken}`,
+      "User-Agent": userAgent, Authorization: `Bearer ${accessToken}`,
     },
     body: JSON.stringify({ project: projectId }), signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
   }, antigravityOutboundDependencies);
   let summaryFailure: QuotaFailureCode | undefined;
   try {
-    const response = await fetchQuota(ANTIGRAVITY_QUOTA_SUMMARY_URL);
+    let response = await fetchQuota(ANTIGRAVITY_QUOTA_SUMMARY_URL);
+    if (response.status === 403) {
+      // Some valid accounts reject the IDE fingerprint only for quota accounting.
+      try { await response.body?.cancel(); } catch { /* Best-effort release before retry. */ }
+      response = await fetchQuota(ANTIGRAVITY_QUOTA_SUMMARY_URL, "antigravity/1.0");
+    }
     if (await providerRedirectError(response, ANTIGRAVITY_QUOTA_SUMMARY_URL)) return unavailableAntigravityQuota("redirect_blocked");
     if (response.status === 401 || response.status === 403) return unavailableAntigravityQuota("access_denied");
     if (response.ok) {

package/src/providers/quota/kiro-account-probe.ts

@@ -0,0 +1,12 @@
+import { getAccountSet } from "../../oauth/store";
+import { kiroEvidenceIdentity } from "../kiro-account-state-disk";
+
+/** Capture login identity before an await and recheck it before publishing evidence. */
+export function kiroProbeIdentity(accountId: string): string | undefined {
+  const account = getAccountSet("kiro")?.accounts.find(row => row.id === accountId);
+  return account ? kiroEvidenceIdentity(account) : undefined;
+}
+
+export function kiroProbeCurrent(accountId: string, identity: string | undefined): boolean {
+  return identity !== undefined && kiroProbeIdentity(accountId) === identity;
+}

package/src/providers/quota/vendor-probes-key.ts

@@ -40,7 +40,7 @@ const OLLAMA_CLOUD_BASE_URL = "https://ollama.com";
 const OLLAMA_CLOUD_USAGE_URL = `${OLLAMA_CLOUD_BASE_URL}/api/usage`;
 const ZAI_BASE_URL = "https://api.z.ai";
 const ZAI_CN_BASE_URL = "https://open.bigmodel.cn";
-const MINIMAX_REMAINS_URL = "https://www.minimax.io/v1/token_plan/remains";
+const MINIMAX_REMAINS_PATH = "/v1/api/openplatform/coding_plan/remains";
 const MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
 const VENICE_BASE_URL = "https://api.venice.ai/api/v1";
 const SYNTHETIC_BASE_URL = "https://api.synthetic.new/v2";
@@ -652,20 +652,17 @@ async function fetchZaiQuota(provider: string, config: OcxProviderConfig): Promi
 }
 
 /**
- * MiniMax Token Plan `GET /v1/token_plan/remains` — the subscription's
- * remaining quota as a countdown-time value (ms). The endpoint does not expose
- * the plan's total duration, so no percentage is fabricated from a presumed
- * window: the remaining time is reported as a duration-only window. When the
- * API supplies a total (`total_time` / `plan_duration_ms`), a consumed share
- * is derived from it. Region selects the host: `minimax` → www.minimax.io,
- * `minimax-cn` → api.minimaxi.com.
+ * MiniMax Coding Plan `GET /v1/api/openplatform/coding_plan/remains` reports
+ * remaining percentages per model/window. Only the `general` model is the
+ * Coding Plan quota; video remains are unrelated. Region selects the host.
  */
 async function fetchMinimaxQuota(provider: string, config: OcxProviderConfig): Promise<ProviderQuotaProbeResult> {
   if (!isCanonicalMinimaxBaseUrl(config.baseUrl)) return null;
   const apiKey = resolveProviderApiKey(config.apiKey)?.trim();
   if (!apiKey) return null;
   const cnHost = normalizedBaseUrl(config.baseUrl)?.startsWith("https://api.minimaxi.com");
-  const remainsUrl = cnHost ? "https://api.minimaxi.com/v1/token_plan/remains" : MINIMAX_REMAINS_URL;
+  const canonicalHost = cnHost ? "https://api.minimaxi.com" : "https://api.minimax.io";
+  const remainsUrl = `${canonicalHost}${MINIMAX_REMAINS_PATH}`;
   const response = await quotaFetch(provider, config, remainsUrl, {
     headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
     redirect: "error",
@@ -677,24 +674,32 @@ async function fetchMinimaxQuota(provider: string, config: OcxProviderConfig): P
       : null;
   }
   const body = asRecord(await readQuotaJson(response));
-  if (!body || body.success === false) return null;
-  const data = asRecord(body.data) ?? body;
-  const remainsMs = toFiniteNumber(data.remains_time ?? data.remainsTime);
-  if (remainsMs === undefined || remainsMs < 0) return null;
-  const hours = Math.floor(remainsMs / 3_600_000);
-  const label = `Token Plan remaining (${hours}h)`;
-  // Only derive a consumed share when the API actually reports the plan total;
-  // a presumed window (e.g. 30 days) would fabricate utilization. A valid
-  // response that omits the total after a prior refresh had it is a DELIBERATE
-  // contract change — the old row must be dropped (terminal), not preserved as
-  // a transient last-good.
-  const totalMs = toFiniteNumber(data.total_time ?? data.plan_duration_ms ?? data.total_duration_ms);
-  if (totalMs === undefined || totalMs <= 0) return TERMINAL_QUOTA_FAILURE;
-  const consumed = Math.max(0, totalMs - remainsMs);
-  const percent = normalizePercent((consumed / totalMs) * 100);
-  if (percent === undefined) return null;
+  if (!body || asRecord(body.base_resp)?.status_code !== 0) return null;
+  const rows = Array.isArray(body.model_remains) ? body.model_remains : [];
+  const general = rows.map(asRecord).find(row => row?.model_name === "general");
+  if (!general) return null;
+  const customWindows: NonNullable<ProviderQuota["customWindows"]> = [];
+  const fiveHourRemaining = toFiniteNumber(general.current_interval_remaining_percent);
+  if (fiveHourRemaining !== undefined) {
+    const percent = normalizePercent(100 - fiveHourRemaining);
+    if (percent !== undefined) {
+      const resetAt = normalizeResetAt(general.end_time);
+      customWindows.push({ label: "Coding Plan 5-hour", percent, ...(resetAt ? { resetAt } : {}) });
+    }
+  }
+  if (general.current_weekly_status === 1) {
+    const weeklyRemaining = toFiniteNumber(general.current_weekly_remaining_percent);
+    if (weeklyRemaining !== undefined) {
+      const percent = normalizePercent(100 - weeklyRemaining);
+      if (percent !== undefined) {
+        const resetAt = normalizeResetAt(general.weekly_end_time);
+        customWindows.push({ label: "Coding Plan weekly", percent, ...(resetAt ? { resetAt } : {}) });
+      }
+    }
+  }
+  if (customWindows.length === 0) return null;
   return report(provider, "minimax:token-plan-remains", {
-    customWindows: [{ label, percent }],
+    customWindows,
     updatedAt: Date.now(),
   });
 }

package/src/providers/quota/vendor-probes-oauth.ts

@@ -2,6 +2,8 @@ import { effectiveCodexAuthAccountId, fetchMainAccountInfoSnapshot, listCodexAut
 import { MAIN_CODEX_ACCOUNT_ID } from "../../codex/main-account";
 import { getValidAccessToken } from "../../oauth";
 import { getAccountCredential, getAccountSet } from "../../oauth/store";
+import { hydrateKiroAccountState, persistKiroAccountState } from "../kiro-account-state-disk";
+import { kiroProbeCurrent, kiroProbeIdentity } from "./kiro-account-probe";
 import { fetchMuseKeyQuotaSnapshot } from "../muse-key-quota";
 import { CLAUDE_CLI_USER_AGENT } from "../claude-cli-identity";
 import { XAI_GROK_CLIENT_VERSION, XAI_GROK_COMPATIBILITY } from "../xai-transport";
@@ -227,7 +229,7 @@ function parseClaudeBucket(value: unknown): { percent?: number; resetAt?: number
 
 const TERMINAL_CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/gu;
 
-function parseClaudeLimit(value: unknown): { label: string; percent: number; resetAt?: number } | null {
+function parseClaudeLimit(value: unknown): ProviderQuotaWindow | null {
   const rec = asRecord(value);
   if (!rec) return null;
   const percent = normalizePercent(rec.percent);
@@ -247,7 +249,10 @@ function parseClaudeLimit(value: unknown): { label: string; percent: number; res
   // control characters still leaves attacker-chosen residue on the quota line.
   if (label === null) return null;
   const resetAt = normalizeResetAt(rec.resets_at);
-  return { label, percent, ...(resetAt !== undefined ? { resetAt } : {}) };
+  // Model scope is proven structurally here, not guessed from text: the caller admits only
+  // `kind: "weekly_scoped"`, and a limit without a recognized `scope.model.display_name` has
+  // already returned null above. Routing keys on `scope`, never on `label`.
+  return { label, scope: "model", percent, ...(resetAt !== undefined ? { resetAt } : {}) };
 }
 
 /** Claude's OAuth usage endpoint, probed with ONE account's own bearer token. */
@@ -292,9 +297,9 @@ export async function fetchAnthropicUsageQuota(accessToken: string): Promise<Pro
     const opus = parseClaudeBucket(body.seven_day_opus);
     const sonnet = parseClaudeBucket(body.seven_day_sonnet);
     const customWindows: ProviderQuotaWindow[] = [];
-    if (fable?.percent !== undefined) customWindows.push({ label: "Fable", percent: fable.percent, ...(fable.resetAt !== undefined ? { resetAt: fable.resetAt } : {}) });
-    if (opus?.percent !== undefined) customWindows.push({ label: "Opus", percent: opus.percent, ...(opus.resetAt !== undefined ? { resetAt: opus.resetAt } : {}) });
-    if (sonnet?.percent !== undefined) customWindows.push({ label: "Sonnet", percent: sonnet.percent, ...(sonnet.resetAt !== undefined ? { resetAt: sonnet.resetAt } : {}) });
+    if (fable?.percent !== undefined) customWindows.push({ label: "Fable", scope: "model", percent: fable.percent, ...(fable.resetAt !== undefined ? { resetAt: fable.resetAt } : {}) });
+    if (opus?.percent !== undefined) customWindows.push({ label: "Opus", scope: "model", percent: opus.percent, ...(opus.resetAt !== undefined ? { resetAt: opus.resetAt } : {}) });
+    if (sonnet?.percent !== undefined) customWindows.push({ label: "Sonnet", scope: "model", percent: sonnet.percent, ...(sonnet.resetAt !== undefined ? { resetAt: sonnet.resetAt } : {}) });
     const knownLabels = new Set(customWindows.map(window => window.label.toLowerCase()));
     const limits = Array.isArray(body.limits) ? body.limits : [];
     for (const rawLimit of limits) {
@@ -360,8 +365,10 @@ export async function fetchAnthropicQuota(provider: string): Promise<ProviderQuo
  * concurrent account switch cannot file this answer under the wrong account.
  */
 export async function fetchKiroQuota(provider: string): Promise<ProviderQuotaReport | null> {
+  hydrateKiroAccountState();
   const probedAccountId = getAccountSet("kiro")?.activeAccountId;
   if (!probedAccountId) return null;
+  const identity = kiroProbeIdentity(probedAccountId);
   const probedAccountKey = accountCacheKey("kiro", probedAccountId);
   const writerGeneration = captureConfigGeneration();
   let snapshot: KiroUsageSnapshot | null;
@@ -371,9 +378,11 @@ export async function fetchKiroQuota(provider: string): Promise<ProviderQuotaRep
     return null;
   }
   if (!snapshot) return null;
+  if (!kiroProbeCurrent(probedAccountId, identity)) return null;
   if (mayCommitAccountQuotaKey(probedAccountKey, writerGeneration)) {
-    accountQuotaCache.set(probedAccountKey, { ts: Date.now(), quota: snapshot.quota });
-    commitKiroAccountUsageState(probedAccountKey, snapshot);
+    accountQuotaCache.set(probedAccountKey, { ts: Date.now(), quota: snapshot.quota, identity });
+    commitKiroAccountUsageState(probedAccountKey, snapshot, identity);
+    persistKiroAccountState();
   }
   return report(provider, "kiro:usage-limits", snapshot.quota);
 }

package/src/providers/quota-types.ts

@@ -19,6 +19,17 @@ export interface ProviderQuotaWindow {
   label: string;
   percent: number;
   resetAt?: number;
+  /**
+   * Set only when the PRODUCER proved this window covers one model family, structurally rather
+   * than by reading its label: an Anthropic `seven_day_<family>` body key, or a limit with
+   * `kind: "weekly_scoped"` and a recognized `scope.model.display_name`.
+   *
+   * Absent means provider-wide, which gates every model. That is the fail-closed direction and
+   * the behaviour every other producer keeps. Routing must key on THIS, never on the label text:
+   * `quota/antigravity.ts` passes an upstream `group.displayName` straight through, so a
+   * provider-wide group named "Opus" there would otherwise be mistaken for a per-model window.
+   */
+  scope?: "model";
 }
 
 export interface ProviderQuotaCreditsUsd {
@@ -37,6 +48,9 @@ export interface ProviderQuota {
   weeklyResetAt?: number;
   monthlyPercent?: number;
   monthlyResetAt?: number;
+  /** Observed Kiro plan credits, independent of token and currency estimates. */
+  kiroCreditsUsed?: number;
+  kiroCreditsLimit?: number;
   customWindows?: ProviderQuotaWindow[];
   creditsUsd?: ProviderQuotaCreditsUsd;
   updatedAt: number;

package/src/providers/quota.ts

@@ -67,6 +67,8 @@ import {
 } from "./quota/vendor-probes-oauth";
 import { fetchCommandCodeQuota, fetchKimiQuota, keyQuotaReaderForProvider } from "./quota/vendor-probes-key";
 import { antigravityQuotaDiagnosticIdentity, fetchAntigravityQuota, probeAntigravityUsageQuota } from "./quota/antigravity";
+import { persistKiroAccountState } from "./kiro-account-state-disk";
+import { kiroProbeCurrent, kiroProbeIdentity } from "./quota/kiro-account-probe";
 
 export type { ProviderQuota, ProviderQuotaCreditsUsd, ProviderQuotaWindow } from "./quota-types";
 export { QUOTA_RESPONSE_MAX_BYTES } from "./quota-wire";
@@ -413,8 +415,6 @@ async function fetchExplicitCurrentQuota(provider: string, config: OcxProviderCo
   if (read.result && typeof read.result !== "symbol") accountReportCurrent.set(read.result, isCurrent);
   return read.result;
 }
-
-
 async function fetchAccountQuota(
   provider: string,
   accountId: string,
@@ -423,16 +423,22 @@ async function fetchAccountQuota(
 ): Promise<AccountQuotaCacheEntry> {
   if (!supportsPerAccountQuota(provider)) return { ts: Date.now(), quota: null, unavailable: true };
   if (explicitAccountReader(provider)) return fetchExplicitAccountQuota(provider, accountId, forceRefresh, providerConfig);
-  if (provider === "anthropic") hydrateAccountQuotaCache();
+  if (provider === "anthropic" || provider === "kiro") hydrateAccountQuotaCache();
   const key = accountCacheKey(provider, accountId);
   const writerGeneration = captureConfigGeneration();
-  const cached = accountQuotaCache.get(key);
+  const kiroIdentity = provider === "kiro" ? kiroProbeIdentity(accountId) : undefined;
+  const cachedCandidate = accountQuotaCache.get(key);
+  const cached = provider !== "kiro" || cachedCandidate?.identity === kiroIdentity ? cachedCandidate : undefined;
   if (!forceRefresh && cached && Date.now() - cached.ts < ACCOUNT_QUOTA_TTL_MS) {
     if (provider === "google-antigravity" && cached.quotaFailure && cached.quotaFailureIsCurrent?.() !== true) return { ...cached, quotaFailure: undefined };
     return provider === "anthropic" ? { ...cached, quota: normalizeAnthropicQuota(cached.quota, Date.now()) } : cached;
   }
   const joinable = accountQuotaInflight.get(key);
-  if (joinable) return joinable;
+  if (joinable) {
+    const joined = await joinable;
+    return provider !== "kiro" || joined.identity === kiroIdentity
+      ? joined : fetchAccountQuota(provider, accountId, true, providerConfig);
+  }
 
   const epoch = explicitAccountEpoch;
   const probe = (async (): Promise<AccountQuotaCacheEntry> => {
@@ -448,12 +454,6 @@ async function fetchAccountQuota(
       let quota: ProviderQuota | null;
       let kiroSnapshot: KiroUsageSnapshot | null = null;
       if (provider === "kiro") {
-        // Kiro resolves the bearer and its routing metadata from ONE account-scoped
-        // snapshot. It deliberately does not use getTokenForAccountQuotaProbe: that
-        // helper refuses to refresh a background `local-cli` slot because Anthropic's
-        // lock can adopt a mismatched Claude CLI identity, but Kiro marks every
-        // CLI-imported credential `local-cli`, so the same rule would blank the quota of
-        // every inactive pool account the moment its token expired.
         kiroSnapshot = await fetchKiroUsageSnapshot(await kiroUsageContextForAccount(accountId));
         quota = kiroSnapshot?.quota ?? null;
       } else {
@@ -475,31 +475,29 @@ async function fetchAccountQuota(
         }
       }
       if (!quota) {
-        // Preserve last-good bars and mark unavailable; advance TTL so failures
-        // negative-cache instead of re-probing on every GUI poll.
+        // Preserve last-good bars while negative-caching the failed probe.
         const entry: AccountQuotaCacheEntry = {
           ts: Date.now(),
-          // Settle once for all joiners against observations committed during the probe.
           quota: provider === "anthropic"
             ? normalizeAnthropicQuota(accountQuotaCache.get(key)?.quota, Date.now()) : cached?.quota ?? null,
           unavailable: true,
+          ...(provider === "kiro" ? { identity: kiroIdentity } : {}),
           ...diagnosticFields(),
         };
-        if (mayCommitAccountQuotaKey(key, writerGeneration)) {
+        if (mayCommitAccountQuotaKey(key, writerGeneration) && (provider !== "kiro" || kiroProbeCurrent(accountId, kiroIdentity))) {
           accountQuotaCache.set(key, entry);
-          if (provider === "kiro") commitKiroAccountUsageState(key, null);
+          if (provider === "kiro") persistKiroAccountState();
           sweepExpiredOnWrite(entry.ts);
         }
         return entry;
       }
       const entry: AccountQuotaCacheEntry = {
         ts: Date.now(), quota: provider === "anthropic" ? normalizeAnthropicQuota(quota, Date.now()) : quota,
+        ...(provider === "kiro" ? { identity: kiroIdentity } : {}),
       };
-      if (mayCommitAccountQuotaKey(key, writerGeneration)) {
+      if (mayCommitAccountQuotaKey(key, writerGeneration) && (provider !== "kiro" || kiroProbeCurrent(accountId, kiroIdentity))) {
         accountQuotaCache.set(key, entry);
-        // Exhaustion state rides the SAME commit guard as the quota row: a probe from a
-        // superseded config generation must not publish either half.
-        if (provider === "kiro") commitKiroAccountUsageState(key, kiroSnapshot);
+        if (provider === "kiro") { commitKiroAccountUsageState(key, kiroSnapshot, kiroIdentity); persistKiroAccountState(); }
         sweepExpiredOnWrite(entry.ts);
       }
       return entry;
@@ -510,10 +508,12 @@ async function fetchAccountQuota(
         quota: provider === "anthropic"
           ? normalizeAnthropicQuota(accountQuotaCache.get(key)?.quota, Date.now()) : cached?.quota ?? null,
         unavailable: true,
+        ...(provider === "kiro" ? { identity: kiroIdentity } : {}),
         ...diagnosticFields(),
       };
-      if (mayCommitAccountQuotaKey(key, writerGeneration)) {
+      if (mayCommitAccountQuotaKey(key, writerGeneration) && (provider !== "kiro" || kiroProbeCurrent(accountId, kiroIdentity))) {
         accountQuotaCache.set(key, entry);
+        if (provider === "kiro") persistKiroAccountState();
         sweepExpiredOnWrite(entry.ts);
       }
       return entry;

package/src/providers/registry/entries-extended.ts

@@ -1402,7 +1402,7 @@ export const PROVIDER_REGISTRY_EXTENDED: readonly ProviderRegistryEntry[] = [
     dashboardUrl: "https://www.codebuddy.ai/profile/keys",
     defaultModel: "default-model",
     models: CODEBUDDY_GLOBAL_MODELS,
-    liveModels: false,
+    liveModels: true,
     modelContextWindows: CODEBUDDY_GLOBAL_MODEL_CONTEXT_WINDOWS,
     modelMaxOutputTokens: CODEBUDDY_GLOBAL_MODEL_MAX_OUTPUT_TOKENS,
     defaultMaxOutputTokens: 32_000,
@@ -1415,7 +1415,9 @@ export const PROVIDER_REGISTRY_EXTENDED: readonly ProviderRegistryEntry[] = [
     // Official CodeBuddy Code CLI provider, CHINA / `internal` environment. Identical adapter and
     // binary as `codebuddy`; the region is fixed by the profile's CODEBUDDY_INTERNET_ENVIRONMENT
     // and this canonical baseUrl. CN key: https://copilot.tencent.com/profile/keys. The CN model
-    // roster differs from Global (see codebuddy-models.ts) and is seeded separately (§八).
+    // roster differs from Global and is discovered live from the key-authenticated product
+    // configuration roster; the seeded list in codebuddy-models.ts is only the degraded
+    // fallback (§八).
     id: "codebuddy-cn",
     label: "CodeBuddy (CN)",
     adapter: "codebuddy",
@@ -1426,7 +1428,7 @@ export const PROVIDER_REGISTRY_EXTENDED: readonly ProviderRegistryEntry[] = [
     dashboardUrl: "https://copilot.tencent.com/profile/keys",
     defaultModel: "default",
     models: CODEBUDDY_CN_MODELS,
-    liveModels: false,
+    liveModels: true,
     modelContextWindows: CODEBUDDY_CN_MODEL_CONTEXT_WINDOWS,
     modelMaxOutputTokens: CODEBUDDY_CN_MODEL_MAX_OUTPUT_TOKENS,
     defaultMaxOutputTokens: 32_000,