@rynfar/meridian 1.57.0 → 1.58.0

package/README.md

@@ -141,9 +141,9 @@ This error class ([#516](https://github.com/rynfar/meridian/issues/516), histori
 If you still hit the error on a current release, first check `GET /v1/usage/quota` to rule out genuinely exhausted quota, then try disabling the connecting client's system prompt for the affected adapter while keeping the Claude Code prompt enabled (in the `/settings` UI under **SDK Feature Toggles**, or `PATCH /settings/api/features/<adapter>` with `{"clientSystemPrompt":false,"codeSystemPrompt":true}`) — and please report it on [#516](https://github.com/rynfar/meridian/issues/516) with your plan type, since remaining occurrences are likely account-cohort specific (Team plans are treated differently by the API).
 
 **I'm hitting rate limits on 1M context. What do I do?**
-Meridian defaults Sonnet to 200k context because Sonnet 1M is always billed as Extra Usage on Max plans — even when regular usage isn't exhausted. This is [Anthropic's intended billing model](https://code.claude.com/docs/en/model-config#extended-context), not a bug. Set `MERIDIAN_SONNET_MODEL=sonnet[1m]` to opt in if you have Extra Usage enabled and understand the billing implications. Opus defaults to 1M context, which is included with Max/Team/Enterprise subscriptions at no extra cost. Note: there is a [known upstream bug](https://github.com/anthropics/claude-code/issues/39841) where Claude Code incorrectly gates Opus 1M behind Extra Usage on Max — this is Anthropic's to fix.
+Meridian defaults Sonnet to 200k context because Sonnet 1M is always billed as Extra Usage on Max plans — even when regular usage isn't exhausted. This is [Anthropic's intended billing model](https://code.claude.com/docs/en/model-config#extended-context), not a bug. Set `MERIDIAN_SONNET_MODEL=sonnet[1m]` to opt in if you have Extra Usage enabled and understand the billing implications. Opus defaults to 1M context, which is included with Max/Team/Enterprise subscriptions at no extra cost. Fable defaults to 1M too — verified as included on Max and Team accounts at no Extra Usage cost — and Mythos, which rides the Fable tier, inherits the same default. Note: there is a [known upstream bug](https://github.com/anthropics/claude-code/issues/39841) where Claude Code incorrectly gates Opus 1M behind Extra Usage on Max — this is Anthropic's to fix.
 
-To turn off 1M context entirely for **every** model (so Meridian never requests the extended window), set `MERIDIAN_1M_CONTEXT_SUPPORT=0`. Meridian also auto-detects the "out of extra usage" error, falls back to the 200k model, and skips 1M for an hour — so it self-heals after the first occurrence even without the env var.
+To turn off 1M context entirely for **every** model (so Meridian never requests the extended window), set `MERIDIAN_1M_CONTEXT_SUPPORT=0`. To back off a single tier instead — without giving up the other tier's included 1M context — set `MERIDIAN_FABLE_MODEL=fable` or `MERIDIAN_OPUS_MODEL=opus` (both also accept the `CLAUDE_PROXY_` prefix). Meridian also auto-detects the "out of extra usage" error, falls back to the 200k model, and skips 1M for an hour — so it self-heals after the first occurrence even without the env var.
 
 **Why does the health endpoint show `"plugin": "not-configured"`?**
 You haven't run `meridian setup`. Without the plugin, OpenCode requests won't have session tracking or subagent model selection. Run `meridian setup` and restart OpenCode.

package/dist/{cli-sz964j04.js → cli-5rkcyzzm.js}

@@ -1,4 +1,5 @@
 import {
+  AssignmentStore,
   ProfileExhaustion,
   choosePriorityProfile,
   getActiveProfileId,
@@ -9,7 +10,7 @@ import {
   resolveProfile,
   restoreActiveProfile,
   setActiveProfile
-} from "./cli-ngtexmne.js";
+} from "./cli-h6hfkg3s.js";
 import {
   isTrackedPlugin,
   recordError,
@@ -47,11 +48,11 @@ import {
   resolvePassthrough,
   resolveSdkModelDefaults,
   stripExtendedContext
-} from "./cli-bsg2dd52.js";
+} from "./cli-p3ggjwgn.js";
 import {
   getSetting,
   setSetting
-} from "./cli-340h1chz.js";
+} from "./cli-vj9cv18n.js";
 import {
   checkPluginConfigured
 } from "./cli-je60fevk.js";
@@ -59,11 +60,13 @@ import {
   claudeLog,
   createPlatformCredentialStore,
   ensureFreshToken,
+  getAuthRenewalStatus,
   refreshOAuthToken,
+  resolveRenewalWarnDays,
   startBackgroundRefresh,
   stopBackgroundRefresh,
   withClaudeLogContext
-} from "./cli-aq5zz92m.js";
+} from "./cli-khhjyk04.js";
 import {
   __commonJS,
   __esm,
@@ -4364,24 +4367,40 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/proxy/rateLimitStore.ts
 class RateLimitStore {
-  entries = new Map;
-  record(info, observedAt = Date.now()) {
+  byProfile = new Map;
+  record(profileId, info, observedAt = Date.now()) {
     if (!info || typeof info !== "object")
       return;
     const key = info.rateLimitType ?? "default";
-    this.entries.set(key, { ...info, observedAt });
-  }
-  getAll() {
-    return Array.from(this.entries.values()).sort((a, b) => b.observedAt - a.observedAt);
-  }
-  get(key) {
-    return this.entries.get(key);
-  }
-  get size() {
-    return this.entries.size;
+    let buckets = this.byProfile.get(profileId);
+    if (!buckets) {
+      buckets = new Map;
+      this.byProfile.set(profileId, buckets);
+    }
+    buckets.set(key, { ...info, observedAt });
   }
-  clear() {
-    this.entries.clear();
+  getAll(profileId) {
+    const buckets = this.byProfile.get(profileId);
+    if (!buckets)
+      return [];
+    return Array.from(buckets.values()).sort((a, b) => b.observedAt - a.observedAt);
+  }
+  get(profileId, key) {
+    return this.byProfile.get(profileId)?.get(key);
+  }
+  size(profileId) {
+    if (profileId !== undefined)
+      return this.byProfile.get(profileId)?.size ?? 0;
+    let total = 0;
+    for (const buckets of this.byProfile.values())
+      total += buckets.size;
+    return total;
+  }
+  clear(profileId) {
+    if (profileId !== undefined)
+      this.byProfile.delete(profileId);
+    else
+      this.byProfile.clear();
   }
 }
 var rateLimitStore = new RateLimitStore;
@@ -11086,13 +11105,25 @@ function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000))
 }
 
 // src/proxy/openaiResponses.ts
+function itemDiscriminator(item) {
+  if (typeof item !== "object" || item === null)
+    return;
+  const record = item;
+  if (typeof record.type === "string")
+    return record.type;
+  if (record.type === undefined && "role" in record)
+    return "message";
+  return;
+}
 function partsToText(content) {
+  if (content === undefined)
+    return "";
   if (typeof content === "string")
     return content;
   return content.filter((p) => typeof p.text === "string").map((p) => p.text).join("");
 }
 function partsToBlocks(content) {
-  if (typeof content === "string")
+  if (content === undefined || typeof content === "string")
     return null;
   const hasImage = content.some((p) => p.type === "input_image");
   if (!hasImage)
@@ -11141,7 +11172,7 @@ function translateResponsesToAnthropic(body) {
     }
   };
   for (const item of items) {
-    switch (item.type) {
+    switch (itemDiscriminator(item)) {
       case "message": {
         const msg = item;
         if (msg.role === "developer" || msg.role === "system") {
@@ -11833,6 +11864,12 @@ function getConversationFingerprint(messages, workingDirectory) {
 ${text.slice(0, 2000)}` : text.slice(0, 2000);
   return createHash("sha256").update(seed).digest("hex").slice(0, 16);
 }
+function getPriorityAssignmentKey(sessionId, messages, workingDirectory) {
+  if (sessionId)
+    return sessionId;
+  const fingerprint = getConversationFingerprint(messages, workingDirectory);
+  return fingerprint ? `fp:${fingerprint}` : null;
+}
 
 // src/proxy/adapters/opencode.ts
 init_env();
@@ -19189,36 +19226,34 @@ function findSuffixAnchorStart(storedHashes, incomingHashes, suffixOverlap) {
     return -1;
   return anchor - suffixOverlap + 1;
 }
-function verifyLineage(cached, messages, cacheKey2, cache) {
+function verifyLineage(cached, messages) {
   if (!cached.lineageHash || cached.messageCount === 0) {
-    return { type: "continuation", session: cached };
+    return { type: "diverged", reason: "unverifiable" };
   }
   const prefix = messages.slice(0, cached.messageCount);
   const prefixHash = computeLineageHash(prefix);
   if (prefixHash === cached.lineageHash) {
     if (messages.length <= cached.messageCount) {
-      cache.delete(cacheKey2);
-      return { type: "diverged" };
+      return { type: "diverged", reason: "replayed-request" };
     }
-    return { type: "continuation", session: cached };
+    return { type: "continuation", session: cached, resumeFrom: cached.messageCount };
   }
   if (!cached.messageHashes || cached.messageHashes.length === 0) {
-    cache.delete(cacheKey2);
-    return { type: "diverged" };
+    return { type: "diverged", reason: "unverifiable" };
   }
   const incomingHashes = computeMessageHashes(messages);
   const prefixOverlap = measurePrefixOverlap(cached.messageHashes, incomingHashes);
   const suffixOverlap = measureSuffixOverlap(cached.messageHashes, incomingHashes);
   const MIN_STORED_FOR_COMPACTION = 6;
   const suffixStartInIncoming = incomingHashes.length - suffixOverlap >= 0 ? findSuffixAnchorStart(cached.messageHashes, incomingHashes, suffixOverlap) : -1;
-  if (suffixOverlap >= MIN_SUFFIX_FOR_COMPACTION && cached.messageHashes.length >= MIN_STORED_FOR_COMPACTION && suffixStartInIncoming > 0) {
-    const compactionMsg = `Compaction detected (key=${cacheKey2.slice(0, 8)}…): suffix overlap ${suffixOverlap}/${cached.messageHashes.length}. Allowing resume.`;
-    console.error(`[PROXY] ${compactionMsg}`);
-    diagnosticLog2.lineage(compactionMsg);
-    cached.lineageHash = computeLineageHash(messages);
-    cached.messageHashes = incomingHashes;
-    cached.messageCount = messages.length;
-    return { type: "compaction", session: cached };
+  const compactionResumeFrom = suffixStartInIncoming + suffixOverlap;
+  if (suffixOverlap >= MIN_SUFFIX_FOR_COMPACTION && cached.messageHashes.length >= MIN_STORED_FOR_COMPACTION && suffixStartInIncoming > 0 && compactionResumeFrom < messages.length) {
+    return {
+      type: "compaction",
+      session: cached,
+      resumeFrom: compactionResumeFrom,
+      suffixOverlap
+    };
   }
   if (prefixOverlap > 0 && suffixOverlap === 0 && messages.length <= cached.messageCount) {
     let rollbackUuid;
@@ -19230,22 +19265,12 @@ function verifyLineage(cached, messages, cacheKey2, cache) {
         }
       }
     }
-    const undoMsg = `Undo detected (key=${cacheKey2.slice(0, 8)}…): prefix overlap ${prefixOverlap}/${cached.messageHashes.length}, rollback UUID: ${rollbackUuid || "none (legacy session)"}.`;
-    console.error(`[PROXY] ${undoMsg}`);
-    diagnosticLog2.lineage(undoMsg);
     return { type: "undo", session: cached, prefixOverlap, rollbackUuid };
   }
   if (prefixOverlap > 0 && messages.length > cached.messageCount) {
-    const modifiedMsg = `Modified continuation (key=${cacheKey2.slice(0, 8)}…): prefix overlap ${prefixOverlap}/${cached.messageHashes.length}, incoming ${messages.length} msgs. Allowing resume.`;
-    console.error(`[PROXY] ${modifiedMsg}`);
-    diagnosticLog2.lineage(modifiedMsg);
-    cached.lineageHash = computeLineageHash(messages.slice(0, messages.length));
-    cached.messageHashes = incomingHashes;
-    cached.messageCount = messages.length;
-    return { type: "continuation", session: cached };
+    return { type: "diverged", reason: "modified-history", prefixOverlap };
   }
-  cache.delete(cacheKey2);
-  return { type: "diverged" };
+  return { type: "diverged", reason: "unrelated-history", prefixOverlap };
 }
 
 // src/proxy/sessionStore.ts
@@ -19546,11 +19571,28 @@ function touchSession(state) {
   state.lastAccess = Date.now();
   return state;
 }
+function classifyLineage(state, messages, cacheKey2) {
+  const result = verifyLineage(state, messages);
+  if (result.type === "compaction") {
+    const msg = `Compaction detected (key=${cacheKey2.slice(0, 8)}…): suffix overlap ${result.suffixOverlap}/${state.messageCount}, resume from incoming message ${result.resumeFrom}.`;
+    console.error(`[PROXY] ${msg}`);
+    diagnosticLog2.lineage(msg);
+  } else if (result.type === "undo") {
+    const msg = `Undo detected (key=${cacheKey2.slice(0, 8)}…): prefix overlap ${result.prefixOverlap}/${state.messageCount}, rollback UUID: ${result.rollbackUuid || "none (legacy session)"}.`;
+    console.error(`[PROXY] ${msg}`);
+    diagnosticLog2.lineage(msg);
+  } else if (result.type === "diverged" && result.reason === "modified-history") {
+    const msg = `Stale session detected (key=${cacheKey2.slice(0, 8)}…): prefix overlap ${result.prefixOverlap || 0}/${state.messageCount}, incoming ${messages.length} msgs. Starting fresh replay.`;
+    console.error(`[PROXY] ${msg}`);
+    diagnosticLog2.lineage(msg);
+  }
+  return result;
+}
 function lookupSession(sessionId, messages, workingDirectory) {
   if (sessionId) {
     const cached = sessionCache.get(sessionId);
     if (cached) {
-      const result = verifyLineage(cached, messages, sessionId, sessionCache);
+      const result = classifyLineage(cached, messages, sessionId);
       if (result.type === "continuation" || result.type === "compaction")
         touchSession(result.session);
       return result;
@@ -19566,19 +19608,19 @@ function lookupSession(sessionId, messages, workingDirectory) {
         sdkMessageUuids: shared.sdkMessageUuids,
         contextUsage: shared.contextUsage
       };
-      const result = verifyLineage(state, messages, sessionId, sessionCache);
+      const result = classifyLineage(state, messages, sessionId);
       if (result.type === "continuation" || result.type === "compaction") {
         sessionCache.set(sessionId, state);
       }
       return result;
     }
-    return { type: "diverged" };
+    return { type: "diverged", reason: "not-found" };
   }
   const fp = getConversationFingerprint(messages, workingDirectory);
   if (fp) {
     const cached = fingerprintCache.get(fp);
     if (cached) {
-      const result = verifyLineage(cached, messages, fp, fingerprintCache);
+      const result = classifyLineage(cached, messages, fp);
       if (result.type === "continuation" || result.type === "compaction")
         touchSession(result.session);
       return result;
@@ -19594,14 +19636,14 @@ function lookupSession(sessionId, messages, workingDirectory) {
         sdkMessageUuids: shared.sdkMessageUuids,
         contextUsage: shared.contextUsage
       };
-      const result = verifyLineage(state, messages, fp, fingerprintCache);
+      const result = classifyLineage(state, messages, fp);
       if (result.type === "continuation" || result.type === "compaction") {
         fingerprintCache.set(fp, state);
       }
       return result;
     }
   }
-  return { type: "diverged" };
+  return { type: "diverged", reason: "not-found" };
 }
 function getSessionByClaudeId(claudeSessionId) {
   let newest;
@@ -19905,8 +19947,8 @@ function createProxyServer(config = {}) {
   app.use("/settings", requireAuth);
   app.use("/design-login", requireAuth);
   const priorityExhaustion = new ProfileExhaustion;
-  const priorityAssignments = new Map;
   const PRIORITY_ASSIGNMENTS_MAX = 5000;
+  const priorityAssignments = new AssignmentStore(PRIORITY_ASSIGNMENTS_MAX);
   const PRIORITY_DEFAULT_COOLDOWN_MS = 10 * 60000;
   const PRIORITY_COOLDOWN_CAP_MS = 6 * 60 * 60000;
   function priorityProfileOrderSetting() {
@@ -19916,11 +19958,33 @@ function createProxyServer(config = {}) {
     const setting = getSetting("profileOrder");
     return Array.isArray(setting) && setting.length > 0 ? setting : undefined;
   }
-  function priorityCooldownUntil(now) {
-    const fiveHour = rateLimitStore.getAll().find((e) => e.rateLimitType === "five_hour" && (e.resetsAt ?? 0) > now);
+  function priorityCooldownUntil(profileId, now) {
+    const fiveHour = rateLimitStore.getAll(profileId).find((e) => e.rateLimitType === "five_hour" && (e.resetsAt ?? 0) > now && (e.status === "rejected" || (e.utilization ?? 0) >= 1));
     const until = fiveHour?.resetsAt ?? now + PRIORITY_DEFAULT_COOLDOWN_MS;
     return Math.min(until, now + PRIORITY_COOLDOWN_CAP_MS);
   }
+  function refinePriorityCooldown(profileId) {
+    const target = getEffectiveProfiles(finalConfig.profiles).find((p) => p.id === profileId);
+    fetchOAuthUsage({ profileId, claudeConfigDir: target?.claudeConfigDir, force: true }).then((usage) => {
+      if (!usage || usage.stale)
+        return;
+      const fiveHour = usage.windows.find((w) => w.type === "five_hour");
+      if (!fiveHour || (fiveHour.utilization ?? 0) < 1)
+        return;
+      const now = Date.now();
+      const resetsAt = fiveHour.resetsAt;
+      if (!resetsAt || resetsAt <= now)
+        return;
+      const until = Math.min(resetsAt, now + PRIORITY_COOLDOWN_CAP_MS);
+      priorityExhaustion.mark(profileId, until, "rate_limit_error");
+      claudeLog("priority.cooldown_refined", { profile: profileId, until, source: "oauth_usage" });
+    }).catch((err) => {
+      claudeLog("priority.cooldown_refine_failed", {
+        profile: profileId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+  }
   async function sniffQuotaFailure(res) {
     const contentType = res.headers.get("content-type") ?? "";
     if (!contentType.includes("text/event-stream")) {
@@ -19995,22 +20059,18 @@ function createProxyServer(config = {}) {
       const inner = await app.fetch(new Request(c.req.url, { method: "POST", headers, body: bodyBuf }));
       const { failed, errorPayload, response } = await sniffQuotaFailure(inner);
       if (!failed) {
-        if (sessionKey) {
+        if (sessionKey)
           priorityAssignments.set(sessionKey, candidate);
-          if (priorityAssignments.size > PRIORITY_ASSIGNMENTS_MAX) {
-            const oldest = priorityAssignments.keys().next().value;
-            if (oldest !== undefined)
-              priorityAssignments.delete(oldest);
-          }
-        }
         if (previous) {
           claudeLog("profile.failover", { from: previous, to: candidate, reason: "rate_limit_error", sessionKey });
           plog(`[PROXY] PRIORITY failover ${previous} -> ${candidate}`);
         }
         return response;
       }
-      priorityExhaustion.mark(candidate, priorityCooldownUntil(Date.now()), "rate_limit_error");
-      claudeLog("priority.exhausted", { profile: candidate, until: priorityCooldownUntil(Date.now()) });
+      const cooldownUntil = priorityCooldownUntil(candidate, Date.now());
+      priorityExhaustion.mark(candidate, cooldownUntil, "rate_limit_error");
+      claudeLog("priority.exhausted", { profile: candidate, until: cooldownUntil });
+      refinePriorityCooldown(candidate);
       lastError = errorPayload;
       previous = candidate;
     }
@@ -20098,7 +20158,8 @@ data: ${JSON.stringify(lastError)}
             const { order, unknown } = resolvePriorityOrder(effectivePool.map((p) => p.id), priorityProfileOrderSetting());
             if (unknown.length > 0)
               claudeLog("priority.unknown_order_ids", { unknown });
-            const sessionKey = adapter.getSessionId(c, body) || null;
+            const assignmentCwd = adapter.extractClientWorkingDirectory?.(body) ?? adapter.extractWorkingDirectory(body);
+            const sessionKey = getPriorityAssignmentKey(adapter.getSessionId(c, body), body.messages, assignmentCwd);
             const assigned = sessionKey ? priorityAssignments.get(sessionKey) : undefined;
             let first;
             if (assigned && order.includes(assigned) && !priorityExhaustion.isExhausted(assigned)) {
@@ -20224,14 +20285,15 @@ data: ${JSON.stringify(lastError)}
             claudeLog("session.pending_store_awaited", { waitedMs: Date.now() - waitStart });
           }
         }
-        let lineageResult = isIndependentSession ? { type: "diverged" } : lookupSession(profileSessionId, body.messages || [], profileScopedCwd);
+        let lineageResult = isIndependentSession ? { type: "diverged", reason: "independent-request" } : lookupSession(profileSessionId, body.messages || [], profileScopedCwd);
         if (lineageResult.type === "undo" && adapterBase === "opencode" && !agentSessionId) {
-          lineageResult = { type: "diverged" };
+          lineageResult = { type: "diverged", reason: "missing-session-header" };
         }
         const isResume = lineageResult.type === "continuation" || lineageResult.type === "compaction";
         const isUndo = lineageResult.type === "undo";
         const cachedSession = lineageResult.type !== "diverged" ? lineageResult.session : undefined;
         const resumeSessionId = cachedSession?.claudeSessionId;
+        const resumeFrom = lineageResult.type === "continuation" || lineageResult.type === "compaction" ? lineageResult.resumeFrom : undefined;
         const undoRollbackUuid = isUndo && lineageResult.type === "undo" ? lineageResult.rollbackUuid : undefined;
         const msgSummary = body.messages?.map((m) => {
           const contentTypes = Array.isArray(m.content) ? m.content.map((b) => b.type).join(",") : "string";
@@ -20274,9 +20336,8 @@ data: ${JSON.stringify(lastError)}
           if (isUndo && undoRollbackUuid) {
             messagesToConvert = getLastUserMessage(allMessages);
           } else if (isResume) {
-            const knownCount = cachedSession.messageCount || 0;
-            if (knownCount > 0 && knownCount < allMessages.length) {
-              messagesToConvert = allMessages.slice(knownCount);
+            if (resumeFrom !== undefined && resumeFrom < allMessages.length) {
+              messagesToConvert = allMessages.slice(resumeFrom);
             } else {
               messagesToConvert = getLastUserMessage(allMessages);
             }
@@ -20569,7 +20630,7 @@ data: ${JSON.stringify(lastError)}
                     advisorModel
                   }, requestAbort.controller))) {
                     if (event.type === "rate_limit_event") {
-                      rateLimitStore.record(event.rate_limit_info);
+                      rateLimitStore.record(profile.id, event.rate_limit_info);
                     }
                     if (event.type === "assistant" && !event.error) {
                       didYieldContent = true;
@@ -21151,7 +21212,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                       advisorModel
                     }, requestAbort.controller))) {
                       if (event.type === "rate_limit_event") {
-                        rateLimitStore.record(event.rate_limit_info);
+                        rateLimitStore.record(profile.id, event.rate_limit_info);
                       }
                       if (event.type === "stream_event") {
                         didYieldClientEvent = true;
@@ -22229,13 +22290,17 @@ data: ${JSON.stringify({
         }, 503);
       }
       const claudeExecutableInfo = getResolvedClaudeExecutableInfo();
+      const warnDays = resolveRenewalWarnDays(process.env.MERIDIAN_AUTH_RENEWAL_WARN_DAYS);
+      const renewalConfigDir = profileEnvOverrides?.CLAUDE_CONFIG_DIR;
+      const renewal = await getAuthRenewalStatus(renewalConfigDir ? createPlatformCredentialStore({ claudeConfigDir: renewalConfigDir }) : undefined, warnDays).catch(() => ({ renewalRequiredSoon: false }));
       return c.json({
         status: "healthy",
         version: serverVersion,
         auth: {
           loggedIn: true,
           email: auth.email,
-          subscriptionType: auth.subscriptionType
+          subscriptionType: auth.subscriptionType,
+          ...renewal
         },
         mode: envBool("PASSTHROUGH") ? "passthrough" : "internal",
         ...claudeExecutableInfo ? { claudeExecutable: claudeExecutableInfo } : {},
@@ -22302,7 +22367,6 @@ data: ${JSON.stringify({
     const previousProfile = getActiveProfileId() ?? null;
     setActiveProfile(body.profile);
     clearSessionCache();
-    rateLimitStore.clear();
     claudeLog("profile.switched", {
       from: previousProfile,
       to: body.profile,
@@ -22356,7 +22420,7 @@ data: ${JSON.stringify({
     const store = credentialStoreForProfile(profile);
     const success = store ? await refreshOAuthToken(store) : false;
     if (success) {
-      rateLimitStore.clear();
+      rateLimitStore.clear(profile.id);
       return c.json({ success: true, message: "OAuth token refreshed successfully", profile: profile.id });
     }
     return c.json({ success: false, message: "Token refresh failed. If the problem persists, run 'claude login'." }, 500);
@@ -22579,11 +22643,11 @@ data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: {
     return c.json({ object: "list", data: buildModelList(isMax) });
   });
   app.get("/v1/usage/quota", async (c) => {
-    const sdkEntries = rateLimitStore.getAll().filter((entry) => entry.rateLimitType !== undefined);
     const requestedProfile = c.req.query("profile");
     const profilesList = getEffectiveProfiles(finalConfig.profiles);
     const targetProfileId = requestedProfile || getActiveProfileId() || finalConfig.defaultProfile || profilesList[0]?.id || null;
     const targetProfile = targetProfileId ? profilesList.find((p) => p.id === targetProfileId) : undefined;
+    const sdkEntries = rateLimitStore.getAll(targetProfileId ?? "default").filter((entry) => entry.rateLimitType !== undefined);
     const oauth = await fetchOAuthUsage({
       profileId: targetProfileId ?? undefined,
       claudeConfigDir: targetProfile?.claudeConfigDir

package/dist/{cli-ngtexmne.js → cli-h6hfkg3s.js}

@@ -1,7 +1,7 @@
 import {
   getSetting,
   setSetting
-} from "./cli-340h1chz.js";
+} from "./cli-vj9cv18n.js";
 
 // src/proxy/profiles.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -98,6 +98,34 @@ class ProfileExhaustion {
   }
 }
 
+class AssignmentStore {
+  max;
+  entries = new Map;
+  constructor(max) {
+    this.max = max;
+  }
+  get(key) {
+    const value = this.entries.get(key);
+    if (value === undefined)
+      return;
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    if (this.entries.size > this.max) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest !== undefined)
+        this.entries.delete(oldest);
+    }
+  }
+  get size() {
+    return this.entries.size;
+  }
+}
+
 // src/proxy/profiles.ts
 var CONFIG_FILE = join(homedir(), ".config", "meridian", "profiles.json");
 var DISK_CACHE_TTL_MS = 5000;
@@ -213,4 +241,4 @@ function listProfiles(profiles, defaultProfile) {
   }));
 }
 
-export { getRoutingMode, resolvePriorityOrder, choosePriorityProfile, ProfileExhaustion, loadProfilesFromDisk, setActiveProfile, getActiveProfileId, resetActiveProfile, restoreActiveProfile, enableDiskProfileDiscovery, getEffectiveProfiles, hasProfiles, resolveProfile, listProfiles };
+export { getRoutingMode, resolvePriorityOrder, choosePriorityProfile, ProfileExhaustion, AssignmentStore, loadProfilesFromDisk, setActiveProfile, getActiveProfileId, resetActiveProfile, restoreActiveProfile, enableDiskProfileDiscovery, getEffectiveProfiles, hasProfiles, resolveProfile, listProfiles };

package/dist/{cli-aq5zz92m.js → cli-khhjyk04.js}

@@ -235,16 +235,19 @@ async function doRefresh(store) {
   }
   const now = Date.now();
   const expiresAt = tokenData.expires_at ?? (tokenData.expires_in ? now + tokenData.expires_in * 1000 : now + 8 * 60 * 60 * 1000);
+  const refreshTokenExpiresAtRaw = tokenData.refresh_token_expires_at ?? (tokenData.refresh_token_expires_in ? now + tokenData.refresh_token_expires_in * 1000 : undefined);
+  const refreshTokenExpiresAt = refreshTokenExpiresAtRaw && refreshTokenExpiresAtRaw > now ? refreshTokenExpiresAtRaw : undefined;
   credentials.claudeAiOauth = {
     ...credentials.claudeAiOauth,
     accessToken: tokenData.access_token,
     refreshToken: tokenData.refresh_token ?? refreshToken,
-    expiresAt
+    expiresAt,
+    ...refreshTokenExpiresAt ? { refreshTokenExpiresAt } : {}
   };
   const written = await store.write(credentials);
   if (!written)
     return false;
-  claudeLog("token_refresh.success", { expiresAt });
+  claudeLog("token_refresh.success", { expiresAt, refreshTokenExpiresAt });
   return true;
 }
 async function ensureFreshToken(store, bufferMs = 5 * 60 * 1000) {
@@ -257,6 +260,62 @@ async function ensureFreshToken(store, bufferMs = 5 * 60 * 1000) {
     return true;
   return refreshOAuthToken(s);
 }
+var DEFAULT_RENEWAL_WARN_DAYS = 3;
+function resolveRenewalWarnDays(raw) {
+  const parsed = raw ? Number(raw) : NaN;
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_RENEWAL_WARN_DAYS;
+}
+var RENEWAL_EXPIRY_TTL_MS = 5 * 60000;
+var renewalExpiryCache = new Map;
+var renewalExpiryInflight = new Map;
+function resetAuthRenewalCache() {
+  renewalExpiryCache.clear();
+  renewalExpiryInflight.clear();
+}
+async function readRefreshTokenExpiry(s) {
+  const key = s.refreshKey;
+  if (key) {
+    const cached = renewalExpiryCache.get(key);
+    if (cached && Date.now() - cached.at < RENEWAL_EXPIRY_TTL_MS)
+      return cached.value;
+    const inflight = renewalExpiryInflight.get(key);
+    if (inflight)
+      return inflight;
+  }
+  const read = (async () => {
+    let credentials = null;
+    try {
+      credentials = await s.read();
+    } catch {
+      return;
+    }
+    const value = credentials?.claudeAiOauth?.refreshTokenExpiresAt;
+    if (key)
+      renewalExpiryCache.set(key, { value, at: Date.now() });
+    return value;
+  })();
+  if (!key)
+    return read;
+  renewalExpiryInflight.set(key, read);
+  try {
+    return await read;
+  } finally {
+    renewalExpiryInflight.delete(key);
+  }
+}
+async function getAuthRenewalStatus(store, warnDays = DEFAULT_RENEWAL_WARN_DAYS) {
+  const s = store ?? createPlatformCredentialStore();
+  const refreshTokenExpiresAt = await readRefreshTokenExpiry(s);
+  if (!refreshTokenExpiresAt)
+    return { renewalRequiredSoon: false };
+  const msRemaining = refreshTokenExpiresAt - Date.now();
+  const daysUntilRenewal = Math.ceil(msRemaining / 86400000);
+  return {
+    refreshTokenExpiresAt,
+    daysUntilRenewal,
+    renewalRequiredSoon: daysUntilRenewal <= warnDays
+  };
+}
 var scheduledRefreshTimer = null;
 var scheduledRefreshActive = false;
 var scheduledRefreshGeneration = 0;
@@ -315,4 +374,4 @@ function resetInflightRefresh() {
   inflightRefreshByKey.clear();
 }
 
-export { withClaudeLogContext, claudeLog, configDirToKeychainService, configDirToCredentialsFile, serializeCredentials, createPlatformCredentialStore, credentialsFilePathForProfile, refreshOAuthToken, ensureFreshToken, startBackgroundRefresh, stopBackgroundRefresh, isBackgroundRefreshActive, resetInflightRefresh };
+export { withClaudeLogContext, claudeLog, configDirToKeychainService, configDirToCredentialsFile, serializeCredentials, createPlatformCredentialStore, credentialsFilePathForProfile, refreshOAuthToken, ensureFreshToken, DEFAULT_RENEWAL_WARN_DAYS, resolveRenewalWarnDays, resetAuthRenewalCache, getAuthRenewalStatus, startBackgroundRefresh, stopBackgroundRefresh, isBackgroundRefreshActive, resetInflightRefresh };