tokentracker-cli 1.1.10 → 1.1.12

package/src/lib/rollout.js

@@ -1,3 +1,4 @@
+const { claudeUserIdentity, collectClaudeForkAliases } = require("./claude-user-identity");
 const fs = require("node:fs/promises");
 const fssync = require("node:fs");
 const os = require("node:os");
@@ -982,6 +983,35 @@ async function parseClaudeIncremental({
   const prevHashes = Array.isArray(cursors.claudeHashes) ? cursors.claudeHashes : [];
   const seenMessageHashes = new Set(prevHashes);
   const defaultSource = normalizeSourceInput(source) || "claude";
+  // Resolve all changed-file lineage before counting: fork files may sort first.
+  const forkTimes = new Map();
+  const forkAliases = await collectClaudeForkAliases(files, cursors,
+    (obj) => { if (typeof obj.timestamp === "string") forkTimes.set(obj.uuid, obj.timestamp); });
+  {
+    // Correct only copies whose old UUID identities prove they were counted.
+    // Preserve all token totals and history whose source files were removed.
+    const families = new Map();
+    const familyTimes = new Map();
+    for (const [uuid, ts] of forkTimes) familyTimes.set(claudeUserIdentity({ uuid }, forkAliases), ts);
+    for (const hash of prevHashes) {
+      if (typeof hash !== "string" || !hash.startsWith("u:")) continue;
+      const canonical = claudeUserIdentity({ uuid: hash.slice(2) }, forkAliases);
+      families.set(canonical, (families.get(canonical) || 0) + 1);
+      seenMessageHashes.delete(hash);
+      seenMessageHashes.add(canonical);
+    }
+    for (const [canonical, count] of families) {
+      if (count < 2) continue;
+      const ts = familyTimes.get(canonical);
+      const hour = ts ? toUtcHalfHourStart(ts) : null;
+      if (!hour) continue;
+      const key = bucketKey(defaultSource, DEFAULT_MODEL, hour);
+      const bucket = hourlyState.buckets[key];
+      if (!bucket || bucket.totals.conversation_count < count - 1) continue;
+      bucket.totals.conversation_count -= count - 1;
+      touchedBuckets.add(key);
+    }
+  }
 
   if (!cursors.files || typeof cursors.files !== "object") {
     cursors.files = {};
@@ -1155,11 +1185,13 @@ async function parseClaudeIncremental({
       projectRef,
       projectKey,
       seenMessageHashes,
+      forkAliases,
     });
 
     cursors.files[key] = {
       inode,
       offset: result.endOffset,
+      claudeForkIndexed: true,
       updatedAt: new Date().toISOString(),
       ...(fileId ? { fileId, fileIdSize: st.size } : {}),
       ...(projectEnabled
@@ -1198,6 +1230,7 @@ async function parseClaudeIncremental({
     cursors.projectHourly = projectState;
   }
   // Persist message hashes for cross-sync dedup; cap at 100k entries to bound size.
+  cursors.claudeForkAliases = forkAliases;
   const allHashes = Array.from(seenMessageHashes);
   cursors.claudeHashes =
     allHashes.length > 100_000 ? allHashes.slice(allHashes.length - 100_000) : allHashes;
@@ -2678,6 +2711,7 @@ async function parseClaudeFile({
   projectRef,
   projectKey,
   seenMessageHashes,
+  forkAliases,
 }) {
   const st = fileStat || (await fs.stat(filePath).catch(() => null));
   if (!st || !st.isFile()) return { endOffset: startOffset, eventsAggregated: 0 };
@@ -2712,15 +2746,9 @@ async function parseClaudeFile({
           typeof content === "string" ||
           (Array.isArray(content) && content.some((b) => b?.type === "text"));
         if (hasText) {
-          // Dedup by the line's uuid so a synced copy of the session file
-          // (WSL mirror of a divergent native file, inode-reset re-read)
-          // cannot re-count the conversation. Usage rows get the same
-          // guarantee from claudeMessageDedupKey; user lines have no
-          // message.id, so the line uuid is the identity.
-          const userKey =
-            seenMessageHashes && typeof userObj?.uuid === "string" && userObj.uuid
-              ? `u:${userObj.uuid}`
-              : null;
+          // Copied user rows share their original identity through the full
+          // fork lineage. Token dedup remains independent.
+          const userKey = seenMessageHashes ? claudeUserIdentity(userObj, forkAliases) : null;
           if (!userKey || !seenMessageHashes.has(userKey)) {
             if (userKey) seenMessageHashes.add(userKey);
             const userTs = typeof userObj?.timestamp === "string" ? userObj.timestamp : null;
@@ -3670,10 +3698,9 @@ function deriveOpencodeMessageFingerprint({ msg, totals, source }) {
   return crypto.createHash("sha256").update(raw).digest("base64url").slice(0, 22);
 }
 
-// `fingerprint -> messageKey` for counted messages in this cursor namespace.
-// Rebuilt per parse run. Pre-#426 entries are fingerprinted as they are read;
-// the first claims ownership and later cross-session matches are retracted from
-// persisted buckets once. Tombstoned copies never claim ownership themselves.
+// `fingerprint -> Set<messageKey>` for counted messages in this cursor namespace.
+// Same-session duplicates are all retained as owners; the first session remains
+// canonical for cross-session fork copies. Tombstoned copies never claim ownership.
 function buildOpencodeFingerprintIndex(messageIndex, wantedFingerprints = null) {
   const byFingerprint = new Map();
   if (!messageIndex || typeof messageIndex !== "object") return byFingerprint;
@@ -3681,12 +3708,9 @@ function buildOpencodeFingerprintIndex(messageIndex, wantedFingerprints = null)
     const entry = messageIndex[key];
     if (entry?.dedupedForkCopy === true) continue;
     const fingerprint = entry && typeof entry.fingerprint === "string" ? entry.fingerprint : null;
-    if (
-      fingerprint &&
-      (!wantedFingerprints || wantedFingerprints.has(fingerprint)) &&
-      !byFingerprint.has(fingerprint)
-    ) {
-      byFingerprint.set(fingerprint, key);
+    if (fingerprint && (!wantedFingerprints || wantedFingerprints.has(fingerprint))) {
+      if (!byFingerprint.has(fingerprint)) byFingerprint.set(fingerprint, new Set());
+      byFingerprint.get(fingerprint).add(key);
     }
   }
   return byFingerprint;
@@ -3704,12 +3728,18 @@ function opencodeMessageKeySession(messageKey) {
 // must not delete usage.
 function isOpencodeForkCopy(fingerprintIndex, fingerprint, messageKey) {
   if (!fingerprint || !fingerprintIndex) return false;
-  const owner = fingerprintIndex.get(fingerprint);
-  if (!owner || owner === messageKey) return false;
-  const ownerSession = opencodeMessageKeySession(owner);
+  const owners = fingerprintIndex.get(fingerprint);
+  if (!owners) return false;
   const session = opencodeMessageKeySession(messageKey);
-  if (!ownerSession || !session) return false;
-  return ownerSession !== session;
+  if (!session) return false;
+  let hasCrossSessionOwner = false;
+  for (const owner of owners instanceof Set ? owners : [owners]) {
+    const ownerSession = opencodeMessageKeySession(owner);
+    if (!ownerSession) continue;
+    if (owner === messageKey) return false;
+    if (ownerSession !== session) hasCrossSessionOwner = true;
+  }
+  return hasCrossSessionOwner;
 }
 
 function normalizeOpencodeAttribution(raw) {
@@ -3787,8 +3817,16 @@ function recordOpencodeMessage({
     prevDeduped === Boolean(dedupedForkCopy)
   ) return;
 
-  if (fingerprintIndex && prevFingerprint && prevFingerprint !== nextFingerprint) {
-    if (fingerprintIndex.get(prevFingerprint) === messageKey) {
+  if (
+    fingerprintIndex &&
+    prevFingerprint &&
+    (prevFingerprint !== nextFingerprint || dedupedForkCopy)
+  ) {
+    const owners = fingerprintIndex.get(prevFingerprint);
+    if (owners instanceof Set) {
+      owners.delete(messageKey);
+      if (owners.size === 0) fingerprintIndex.delete(prevFingerprint);
+    } else if (owners === messageKey) {
       fingerprintIndex.delete(prevFingerprint);
     }
   }
@@ -3797,13 +3835,12 @@ function recordOpencodeMessage({
   if (nextAttribution) entry.attribution = encodeOpencodeAttribution(nextAttribution);
   if (dedupedForkCopy) entry.dedupedForkCopy = true;
   messageIndex[messageKey] = entry;
-  if (
-    fingerprintIndex &&
-    nextFingerprint &&
-    !dedupedForkCopy &&
-    !fingerprintIndex.has(nextFingerprint)
-  ) {
-    fingerprintIndex.set(nextFingerprint, messageKey);
+  if (fingerprintIndex && nextFingerprint && !dedupedForkCopy) {
+    if (!fingerprintIndex.has(nextFingerprint)) {
+      fingerprintIndex.set(nextFingerprint, new Set());
+    }
+    const owners = fingerprintIndex.get(nextFingerprint);
+    if (owners instanceof Set) owners.add(messageKey);
   }
 }
 
@@ -5542,6 +5579,8 @@ async function parseOpencodeDbIncremental({
   source,
   cursorKey,
   publicRepoResolver,
+  opencodeCursorStore,
+  opencodeCursorNamespace = "flat",
 }) {
   await ensureDir(path.dirname(queuePath));
   let messagesProcessed = 0;
@@ -5557,22 +5596,35 @@ async function parseOpencodeDbIncremental({
   const projectMetaCache = projectEnabled ? new Map() : null;
   const publicRepoCache = projectEnabled ? new Map() : null;
   const cursorNamespace = typeof cursorKey === "string" && cursorKey.length > 0 ? cursorKey : "opencode";
-  const opencodeState = normalizeOpencodeState(cursors?.[cursorNamespace]);
-  const messageIndex = opencodeState.messages;
   const touchedBuckets = new Set();
   const defaultSource = normalizeSourceInput(source) || "opencode";
+  const candidateMessageKeys = new Set();
   const candidateFingerprints = new Set();
   for (const entry of messages) {
+    const msgForKey = { ...entry?.data };
+    if (entry?.id && !msgForKey.id) msgForKey.id = entry.id;
+    if (entry?.sessionID && !msgForKey.sessionID) msgForKey.sessionID = entry.sessionID;
+    const messageKey = deriveOpencodeMessageKey(msgForKey, null);
+    if (messageKey) candidateMessageKeys.add(messageKey);
     const totals = normalizeOpencodeTokens(entry?.data?.tokens);
     const fingerprint = totals
       ? deriveOpencodeMessageFingerprint({ msg: entry.data, totals, source: defaultSource })
       : null;
     if (fingerprint) candidateFingerprints.add(fingerprint);
   }
-  // A hook-triggered sync normally carries one changed row. Restrict the
-  // historical fingerprint map to fingerprints that can actually match this
-  // batch instead of duplicating the whole long-lived message index in memory.
-  const fingerprintIndex = buildOpencodeFingerprintIndex(messageIndex, candidateFingerprints);
+  const loaded = cursorNamespace === "opencode" && opencodeCursorStore
+    ? await opencodeCursorStore.loadOpencodeMessagesForBatch({
+        namespace: opencodeCursorNamespace,
+        messageKeys: candidateMessageKeys,
+        fingerprints: candidateFingerprints,
+      })
+    : null;
+  const opencodeState = normalizeOpencodeState(cursors?.[cursorNamespace]);
+  const messageIndex = opencodeState.messages;
+  // Direct parser callers and the legacy single-file store retain the in-memory
+  // fallback; cursor-store generations provide the bounded reverse index.
+  const fingerprintIndex = loaded?.fingerprintIndex ||
+    buildOpencodeFingerprintIndex(messageIndex, candidateFingerprints);
 
   for (let idx = 0; idx < messages.length; idx++) {
     const entry = messages[idx];

package/src/lib/usage-limits.js

@@ -36,6 +36,7 @@ const { fetchQoderLimits, fetchQoderCnLimits } = require("./qoder-limits");
 const { fetchArkCodingPlanLimits } = require("./ark-coding-plan-limits");
 const { fetchArkAgentPlanLimits } = require("./ark-agent-plan-limits");
 const { fetchProviderServiceStatus } = require("./provider-status");
+const { resolveKimiProfile } = require("./kimi-profile");
 const { readSqliteJsonRows, readSqliteJsonRowsAsync } = require("./sqlite-reader");
 const {
   runCommand,
@@ -48,14 +49,17 @@ const execFileAsync = promisify(cp.execFile);
 // 2-minute in-memory cache. It also expires early at the earliest upcoming window
 // reset in the cached data (see cacheExpiresAtMs), floored so a provider reporting
 // a reset "right now" can't turn every poll into a full upstream round.
-// Partitioned by the Devin opt-in selection so a request made while Devin is
-// off is never served (or joined onto) a response fetched while it was on.
-const cacheByDevinSelection = {
-  off: { data: null, expiresAtMs: 0 },
-  on: { data: null, expiresAtMs: 0 },
-};
-function devinSelectionKey(options) {
-  return options?.devinEnabled === true ? "on" : "off";
+// Partitioned by the Devin opt-in selection AND the Antigravity quota opt-out, so
+// a request made while Devin is off is never served (or joined onto) a response
+// fetched while it was on, and an aggregate fetched while Antigravity was enabled
+// is never served after the opt-out is set. Key = `${devin}-${antigravity}`.
+const USAGE_LIMITS_SELECTION_KEYS = ["off-on", "off-off", "on-on", "on-off"];
+const cacheBySelection = {};
+for (const key of USAGE_LIMITS_SELECTION_KEYS) cacheBySelection[key] = { data: null, expiresAtMs: 0 };
+function usageLimitsSelectionKey(options) {
+  const devin = options?.devinEnabled === true ? "on" : "off";
+  const antigravity = isAntigravityQuotaDisabled() ? "off" : "on";
+  return `${devin}-${antigravity}`;
 }
 const CACHE_TTL_MS = 2 * 60 * 1000;
 // Must stay below the macOS app's post-reset re-fetch grace (10s in
@@ -297,16 +301,21 @@ async function fetchClaudeUsageLimits(accessToken, { fetchImpl = fetch, maxAttem
       throw new Error(`Claude API returned ${res.status}`);
     }
     const body = await res.json();
-    return {
-      five_hour: body.five_hour ?? null,
-      seven_day: body.seven_day ?? null,
-      seven_day_opus: body.seven_day_opus ?? null,
-      weekly_scoped: extractClaudeScopedWeekly(body),
-      extra_usage: body.extra_usage ?? null,
-    };
+    return mapClaudeUsageBody(body);
   }
 }
 
+/** Map an /api/oauth/usage body (live, or Claude Code's cached copy) onto the limits shape. */
+function mapClaudeUsageBody(body) {
+  return {
+    five_hour: body?.five_hour ?? null,
+    seven_day: body?.seven_day ?? null,
+    seven_day_opus: body?.seven_day_opus ?? null,
+    weekly_scoped: extractClaudeScopedWeekly(body),
+    extra_usage: body?.extra_usage ?? null,
+  };
+}
+
 // Classify a wham window by `limit_window_seconds` rather than its slot name.
 // 18000s = 5h session window. 604800s = 7d weekly window. Free-tier accounts only get a
 // weekly window, often delivered in the `primary_window` slot — naive position-based
@@ -777,28 +786,9 @@ async function fetchCursorLimits({ home, fetchImpl = fetch } = {}) {
   }
 }
 
-function resolveKimiHome({ home, env } = {}) {
-  const explicit = typeof env?.KIMI_HOME === "string" ? env.KIMI_HOME.trim() : "";
-  if (explicit) return path.resolve(explicit);
-  const base = home || os.homedir();
-  // Prefer the official Kimi Code (@moonshot-ai/kimi-code, ~/.kimi-code) when it
-  // holds a login — its credential file shape (kimi-code.json) and the
-  // auth/usages endpoints are identical to the legacy kimi-cli (~/.kimi), so the
-  // existing fetch path works unchanged. Fall back to legacy when kimi-code has
-  // no credentials, keeping old kimi-cli users untouched.
-  const explicitCode = typeof env?.KIMI_CODE_HOME === "string" ? env.KIMI_CODE_HOME.trim() : "";
-  const codeHome = explicitCode ? path.resolve(explicitCode) : path.join(base, ".kimi-code");
-  const codeCredsPath = path.join(codeHome, "credentials", "kimi-code.json");
-  try {
-    const raw = fs.readFileSync(codeCredsPath, "utf8").trim();
-    if (raw && JSON.parse(raw)?.access_token) return codeHome;
-  } catch { /* missing / empty / corrupt — fall through to legacy */ }
-  return path.join(base, ".kimi");
-}
-
-function loadKimiCredentials({ home, env } = {}) {
-  const kimiHome = resolveKimiHome({ home, env });
-  const credsPath = path.join(kimiHome, "credentials", "kimi-code.json");
+function loadKimiCredentials({ home, env, profile = resolveKimiProfile({ home, env }) } = {}) {
+  if (profile.error) return null;
+  const { credsPath } = profile;
   if (!fs.existsSync(credsPath)) return null;
   try {
     return JSON.parse(fs.readFileSync(credsPath, "utf8"));
@@ -807,15 +797,10 @@ function loadKimiCredentials({ home, env } = {}) {
   }
 }
 
-function saveKimiCredentials(creds, { home, env } = {}) {
-  const kimiHome = resolveKimiHome({ home, env });
-  const credsPath = path.join(kimiHome, "credentials", "kimi-code.json");
+function saveKimiCredentials(creds, { home, env, profile = resolveKimiProfile({ home, env }) } = {}) {
+  const { credsPath } = profile;
   fs.mkdirSync(path.dirname(credsPath), { recursive: true });
-  fs.writeFileSync(credsPath, JSON.stringify(creds, null, 2));
-}
-
-function hasKimiConfig({ home, env } = {}) {
-  return fs.existsSync(path.join(resolveKimiHome({ home, env }), "config.toml"));
+  fs.writeFileSync(credsPath, JSON.stringify(creds, null, 2), { mode: 0o600 });
 }
 
 function kimiNumber(value) {
@@ -867,7 +852,7 @@ function kimiCredentialsExpired(creds, nowMs = Date.now()) {
   return expiresAt * 1000 <= nowMs + 30_000;
 }
 
-async function refreshKimiAccessToken({ refreshToken, home, env, fetchImpl = fetch } = {}) {
+async function refreshKimiAccessToken({ refreshToken, profile, fetchImpl = fetch } = {}) {
   if (typeof refreshToken !== "string" || !refreshToken.trim()) {
     throw new Error("Not logged in to Kimi. Run 'kimi' in Terminal to authenticate.");
   }
@@ -878,8 +863,9 @@ async function refreshKimiAccessToken({ refreshToken, home, env, fetchImpl = fet
     refresh_token: refreshToken,
   });
 
-  const res = await fetchImpl("https://auth.kimi.com/api/oauth/token", {
+  const res = await fetchImpl(`${profile.oauthHost}/api/oauth/token`, {
     method: "POST",
+    redirect: "error",
     headers: {
       "Content-Type": "application/x-www-form-urlencoded",
       "X-Msh-Platform": "kimi_cli",
@@ -907,13 +893,14 @@ async function refreshKimiAccessToken({ refreshToken, home, env, fetchImpl = fet
     token_type: String(json.token_type || "Bearer"),
     expires_in: Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn : 900,
   };
-  saveKimiCredentials(next, { home, env });
+  saveKimiCredentials(next, { profile });
   return next.access_token;
 }
 
-async function fetchKimiUsage(accessToken, { fetchImpl = fetch } = {}) {
-  const res = await fetchImpl("https://api.kimi.com/coding/v1/usages", {
+async function fetchKimiUsage(accessToken, { profile, fetchImpl = fetch } = {}) {
+  const res = await fetchImpl(`${profile.baseUrl}/usages`, {
     method: "GET",
+    redirect: "error",
     headers: {
       Authorization: `Bearer ${accessToken}`,
       Accept: "application/json",
@@ -929,10 +916,12 @@ async function fetchKimiUsage(accessToken, { fetchImpl = fetch } = {}) {
 }
 
 async function fetchKimiLimits({ home, env, fetchImpl = fetch } = {}) {
-  if (!hasKimiConfig({ home, env })) {
+  const profile = resolveKimiProfile({ home, env });
+  if (!profile.configured) {
     return { configured: false };
   }
-  const creds = loadKimiCredentials({ home, env });
+  if (profile.error) return { configured: true, error: profile.error };
+  const creds = loadKimiCredentials({ profile });
   let accessToken = typeof creds?.access_token === "string" ? creds.access_token.trim() : "";
   if (!accessToken) {
     return { configured: false };
@@ -941,23 +930,21 @@ async function fetchKimiLimits({ home, env, fetchImpl = fetch } = {}) {
     if (kimiCredentialsExpired(creds) && creds?.refresh_token) {
       accessToken = await refreshKimiAccessToken({
         refreshToken: creds.refresh_token,
-        home,
-        env,
+        profile,
         fetchImpl,
       });
     }
     let body;
     try {
-      body = await fetchKimiUsage(accessToken, { fetchImpl });
+      body = await fetchKimiUsage(accessToken, { profile, fetchImpl });
     } catch (error) {
       if (error?.message === "token_expired" && creds?.refresh_token) {
         accessToken = await refreshKimiAccessToken({
           refreshToken: creds.refresh_token,
-          home,
-          env,
+          profile,
           fetchImpl,
         });
-        body = await fetchKimiUsage(accessToken, { fetchImpl });
+        body = await fetchKimiUsage(accessToken, { profile, fetchImpl });
       } else {
         throw error;
       }
@@ -2262,7 +2249,12 @@ function normalizeAntigravityCachedLimits(raw, { nowMs = Date.now() } = {}) {
   return hasAntigravityWindow(cached) ? cached : null;
 }
 
+function isAntigravityQuotaDisabled() {
+  return process.env.TOKENTRACKER_DISABLE_ANTIGRAVITY_QUOTA === "1";
+}
+
 function readAntigravityLimitsCache({ home, nowMs = Date.now() } = {}) {
+  if (isAntigravityQuotaDisabled()) return null;
   const cachePath = resolveAntigravityLimitsCachePath({ home });
   try {
     const parsed = JSON.parse(fs.readFileSync(cachePath, "utf8"));
@@ -2368,7 +2360,9 @@ function readClaudeLimitsCache({
   maxAgeMs = CLAUDE_LIMITS_CACHE_MAX_AGE_MS,
   stale = true,
 } = {}) {
-  return normalizeClaudeCachedLimits(readClaudeLimitsCacheRaw({ home }), { nowMs, maxAgeMs, stale });
+  return pickNewestClaudeSnapshot(readClaudeLimitsCacheCandidates({ home }).map((raw) => (
+    normalizeClaudeCachedLimits(raw, { nowMs, maxAgeMs, stale })
+  )));
 }
 
 // A cached snapshot stops being "fresh" the moment any of its windows crosses the
@@ -2412,16 +2406,60 @@ function claudeCacheAwaitsNewWindow(raw, { home, nowMs } = {}) {
   }
 }
 
-function readFreshClaudeLimitsCache({ home, nowMs = Date.now() } = {}) {
-  const raw = readClaudeLimitsCacheRaw({ home });
-  if (!raw || claudeCacheCrossedReset(raw, { nowMs }) || claudeCacheAwaitsNewWindow(raw, { home, nowMs })) {
+// Claude Code keeps its last /api/oauth/usage response in its global config
+// (`cachedUsageUtilization` in ~/.claude.json). That endpoint is throttled hard and its
+// budget is shared with Claude Code itself, so reading this copy costs no request. Only
+// usage figures are read — no credentials. The path deliberately ignores CLAUDE_CONFIG_DIR:
+// readClaudeCodeOauthToken reads the default profile's credentials (default Keychain item,
+// ~/.claude/.credentials.json), and the cache must come from that same profile so it can
+// never describe a different account than the token this process would query with.
+function resolveClaudeCodeGlobalConfigPath({ home } = {}) {
+  return path.join(home || os.homedir(), ".claude.json");
+}
+
+/**
+ * Claude Code's cached usage as a raw cache entry (same shape as our own disk cache),
+ * or null when absent, unparsable, or recorded for a different account than the one
+ * Claude Code is currently signed in to.
+ */
+function readClaudeCodeUsageCacheRaw({ home } = {}) {
+  try {
+    const config = JSON.parse(fs.readFileSync(resolveClaudeCodeGlobalConfigPath({ home }), "utf8"));
+    const cached = config?.cachedUsageUtilization;
+    const fetchedAtMs = Number(cached?.fetchedAtMs);
+    if (!cached?.utilization || typeof cached.utilization !== "object" || !Number.isFinite(fetchedAtMs)) return null;
+    const cachedAccount = typeof cached.accountUuid === "string" ? cached.accountUuid : null;
+    const currentAccount = typeof config?.oauthAccount?.accountUuid === "string" ? config.oauthAccount.accountUuid : null;
+    if (!cachedAccount || !currentAccount || cachedAccount !== currentAccount) return null;
+    return { ...mapClaudeUsageBody(cached.utilization), cached_at: new Date(fetchedAtMs).toISOString() };
+  } catch (_error) {
     return null;
   }
-  return normalizeClaudeCachedLimits(raw, {
-    nowMs,
-    maxAgeMs: CLAUDE_LIMITS_CACHE_FRESH_TTL_MS,
-    stale: false,
-  });
+}
+
+/** Raw snapshots from both sources: our own disk cache and Claude Code's cached read. */
+function readClaudeLimitsCacheCandidates({ home } = {}) {
+  return [readClaudeLimitsCacheRaw({ home }), readClaudeCodeUsageCacheRaw({ home })].filter(Boolean);
+}
+
+/** Newest of the already-validated snapshots, by cached_at. */
+function pickNewestClaudeSnapshot(snapshots) {
+  let newest = null;
+  for (const snapshot of snapshots) {
+    if (!snapshot) continue;
+    if (!newest || parseTimeMs(snapshot.cached_at) > parseTimeMs(newest.cached_at)) newest = snapshot;
+  }
+  return newest;
+}
+
+// Each source is validated on its own before picking the newest, so a newer snapshot
+// whose windows are all unusable can never displace an older usable one.
+function readFreshClaudeLimitsCache({ home, nowMs = Date.now() } = {}) {
+  return pickNewestClaudeSnapshot(readClaudeLimitsCacheCandidates({ home }).map((raw) => (
+    claudeCacheCrossedReset(raw, { nowMs }) || claudeCacheAwaitsNewWindow(raw, { home, nowMs })
+      ? null
+      : normalizeClaudeCachedLimits(raw, { nowMs, maxAgeMs: CLAUDE_LIMITS_CACHE_FRESH_TTL_MS, stale: false })
+  )));
 }
 
 function writeClaudeLimitsCache(limits, { home, nowMs = Date.now() } = {}) {
@@ -3256,6 +3294,7 @@ function loadAntigravityCredentials({
   securityRunner,
   nowMs = Date.now(),
 } = {}) {
+  if (isAntigravityQuotaDisabled()) return null;
   const candidates = collectAntigravityFileCredentials({ home });
   if (platform === "darwin" || typeof securityRunner === "function") {
     const parsed = parseAntigravityCredentialPayload(readAntigravityKeychainRaw({ securityRunner }));
@@ -3403,6 +3442,7 @@ async function fetchAntigravityRemoteLimits({
   signal,
   creds,
 } = {}) {
+  if (isAntigravityQuotaDisabled()) return null;
   const resolvedCreds = creds !== undefined
     ? creds
     : loadAntigravityCredentials({ home, platform, securityRunner, nowMs });
@@ -3497,6 +3537,7 @@ async function fetchAntigravityLimits({
   securityRunner,
   signal,
 } = {}) {
+  if (isAntigravityQuotaDisabled()) return { configured: false, error: null };
   const creds = loadAntigravityCredentials({ home, platform, securityRunner, nowMs });
   const startedAtMs = performance.now();
   // min(this step's ceiling, budget left after reserving the fallback guard).
@@ -3721,7 +3762,8 @@ function withPlanLabel(obj, raw, brand) {
 // hammered). Survives an external resetUsageLimitsCache() (refresh=1 path in
 // local-api.js): a refresh arriving while a fetch is already running reuses that
 // in-flight fetch and returns its result.
-const inFlightByDevinSelection = { off: null, on: null };
+const inFlightBySelection = {};
+for (const key of USAGE_LIMITS_SELECTION_KEYS) inFlightBySelection[key] = null;
 
 // Codex stamps reset_at as unix seconds; every other provider (and Claude's
 // resets_at) uses ISO strings. Numbers that look like epoch milliseconds are
@@ -3759,19 +3801,19 @@ function cacheExpiresAtMs(data, fetchedAtMs) {
 }
 
 async function getUsageLimits(options = {}) {
-  const selection = devinSelectionKey(options);
-  const cache = cacheByDevinSelection[selection];
+  const selection = usageLimitsSelectionKey(options);
+  const cache = cacheBySelection[selection];
   const nowMs = Date.now();
   if (cache.data && nowMs < cache.expiresAtMs) {
     return cache.data;
   }
-  if (inFlightByDevinSelection[selection]) {
-    return inFlightByDevinSelection[selection];
+  if (inFlightBySelection[selection]) {
+    return inFlightBySelection[selection];
   }
-  const promise = fetchUsageLimitsUncached(options).finally(() => {
-    if (inFlightByDevinSelection[selection] === promise) inFlightByDevinSelection[selection] = null;
+  const promise = fetchUsageLimitsUncached({ ...options, selectionKey: selection }).finally(() => {
+    if (inFlightBySelection[selection] === promise) inFlightBySelection[selection] = null;
   });
-  inFlightByDevinSelection[selection] = promise;
+  inFlightBySelection[selection] = promise;
   return promise;
 }
 
@@ -3787,6 +3829,10 @@ async function fetchUsageLimitsUncached({
   providerTimeoutMs = DEFAULT_PROVIDER_TIMEOUT_MS,
   forceRefresh = false,
   devinEnabled = false,
+  // Selection key fixed by getUsageLimits before the fetch began. Re-deriving it
+  // here would let an opt-out flipped mid-fetch store a pre-opt-out result in the
+  // post-opt-out slot.
+  selectionKey,
 } = {}) {
   const nowMs = Date.now();
 
@@ -3840,7 +3886,8 @@ async function fetchUsageLimitsUncached({
     : null;
   // Also avoid cross-process hammering after a recent successful read: embedded-server
   // restarts and background polls read the disk cache instead of spending another Claude
-  // OAuth usage request. An explicit user refresh (refresh=1 → forceRefresh) punches
+  // OAuth usage request. Claude Code's own cached read counts too, so a session that just
+  // refreshed its usage spares this process a call against the same throttled budget. An explicit user refresh (refresh=1 → forceRefresh) punches
   // through this cache — but never through the 429 cooldown above, which is exactly the
   // hammering the cooldown exists to prevent.
   const freshClaudeCache = claudeToken && !forceRefresh
@@ -4255,7 +4302,7 @@ async function fetchUsageLimitsUncached({
     };
   }
 
-  cacheByDevinSelection[devinSelectionKey({ devinEnabled })] = {
+  cacheBySelection[selectionKey || usageLimitsSelectionKey({ devinEnabled })] = {
     data,
     expiresAtMs: cacheExpiresAtMs(data, nowMs),
   };
@@ -4263,8 +4310,9 @@ async function fetchUsageLimitsUncached({
 }
 
 function resetUsageLimitsCache() {
-  cacheByDevinSelection.off = { data: null, expiresAtMs: 0 };
-  cacheByDevinSelection.on = { data: null, expiresAtMs: 0 };
+  for (const key of USAGE_LIMITS_SELECTION_KEYS) {
+    cacheBySelection[key] = { data: null, expiresAtMs: 0 };
+  }
 }
 
 module.exports = {
@@ -4275,6 +4323,7 @@ module.exports = {
   runCommand,
   extractGeminiOauthClientCredentials,
   loadKimiCredentials,
+  fetchKimiLimits,
   normalizeCursorUsageSummary,
   normalizeCursorSandUsageStatus,
   normalizeGeminiQuotaResponse,