mixdog 0.9.16 → 0.9.17

package/src/ui/statusline.mjs

@@ -30,6 +30,14 @@ export { createSessionStats, applyUsageDelta } from './session-stats.mjs';
 export { contextPctDisplayLabel } from './statusline-format.mjs';
 
 const GATEWAY_QUOTA_STATUS_CACHE_MS = 500;
+// Render-path sync-fs guard: loadGatewayStatus() / readCached*UsageSnapshot()
+// below still read files synchronously (vendored/provider modules), but that
+// work must never run on the 500ms render tick's own call stack. Both
+// gateway-status and fallback-quota lookups below are stale-while-revalidate:
+// the render call returns the last cached value immediately and defers the
+// actual sync read to a separate macrotask (setImmediate), guarded so only
+// one refresh per cache is ever in flight at a time. Visible cache cadence
+// (500ms) is unchanged.
 const WORKER_SPINNER_FRAMES = Object.freeze(['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']);
 // L2 segment spinner: reuses the original WORKER_SPINNER_FRAMES dot glyphs (no
 // separate glyph list) but spins them at a faster 120ms step than the worker
@@ -42,7 +50,7 @@ const L2_SPINNER_FRAME_MS = 120;
 // replaces them. Snapshots from a previous launch stay hidden during boot so the
 // statusline starts empty until the current session captures usage once.
 const STATUSLINE_PROCESS_STARTED_AT_MS = Date.now() - Math.floor((Number(process.uptime?.()) || 0) * 1000);
-let _gatewayQuotaStatusCache = { key: '', at: 0, value: null };
+let _gatewayQuotaStatusCache = { key: '', routeKey: '', at: 0, value: null };
 let _fallbackQuotaStatusCache = { key: '', at: 0, value: null };
 // Holds the last non-empty rendered L1 quota/usage segments per provider+route
 // key, but ONLY for providers that have actually armed the OAuth boot latch
@@ -94,6 +102,13 @@ function rememberNonEmptyQuotaSegments(key, segments) {
 // the new provider until ITS own confirmed snapshot exists — otherwise the new
 // provider's stale fallback balance (Credit $…) could leak prematurely.
 const _oauthUsageArmedProviders = new Set();
+// Guards the background arm-check (readCachedOAuthUsageSnapshot sync read)
+// so oauthUsageSegmentReady() never runs it inline on the render call stack,
+// and so at most one in-flight check per provider is scheduled at a time.
+const _oauthArmCheckInFlight = new Set();
+// Guards the background fallbackQuotaStatus() refresh (sync snapshot reads)
+// so at most one refresh is ever in flight across render ticks.
+let _fallbackQuotaRefreshInFlight = false;
 
 function isConfirmedCurrentProcessSnapshot(snapshot) {
   if (!snapshot || typeof snapshot !== 'object') return false;
@@ -356,61 +371,76 @@ function renderNativeStatusline({
   return l2 ? `${l1}\n${l2}` : l1;
 }
 
+let _gatewayQuotaRefreshInFlight = false;
+
 function loadGatewayQuotaStatus({
   provider, model, effort, fast, contextWindow, rawContextWindow, autoCompactTokenLimit = 0,
   sessionId, activeContextTokens, clientHostPid,
 } = {}) {
-  const key = [
+  // Route identity: which route this cached value belongs to. Serving a stale
+  // value across a routeKey change would leak the previous provider/model's
+  // quota into the new route, so mismatches return null instead.
+  const routeKey = [
     String(provider || ''),
     String(model || ''),
     String(effort || ''),
     fast === true ? 'fast' : '',
     String(sessionId || ''),
     String(clientHostPid || ''),
+  ].join('\0');
+  // Freshness key: same route, but any of these changing should trigger a
+  // refresh (stale value still serveable meanwhile — same route identity).
+  const key = [
+    routeKey,
+    String(contextWindow ?? ''),
+    String(rawContextWindow ?? ''),
+    String(autoCompactTokenLimit ?? ''),
     Math.floor((Number(activeContextTokens) || 0) / 1024),
   ].join('\0');
   const now = Date.now();
-  if (_gatewayQuotaStatusCache.key === key && now - _gatewayQuotaStatusCache.at < GATEWAY_QUOTA_STATUS_CACHE_MS) {
+  const fresh = _gatewayQuotaStatusCache.key === key && now - _gatewayQuotaStatusCache.at < GATEWAY_QUOTA_STATUS_CACHE_MS;
+  if (fresh) {
     return _gatewayQuotaStatusCache.value;
   }
-  let value = null;
-  try {
-    const status = loadGatewayStatus({
-      sessionId,
-      activeContextTokens,
-      clientHostPid,
-      currentRoute: {
-        provider,
-        model,
-        effort,
-        fast,
-        contextWindow,
-        rawContextWindow,
-        autoCompactTokenLimit,
-      },
+  // Stale-while-revalidate: serve the last cached value for THIS render call
+  // only if it belongs to the SAME route, and kick a background refresh off
+  // the render call stack. Guarded so concurrent render ticks never queue
+  // more than one refresh at a time.
+  if (!_gatewayQuotaRefreshInFlight) {
+    _gatewayQuotaRefreshInFlight = true;
+    setImmediate(() => {
+      let value = null;
+      try {
+        const status = loadGatewayStatus({
+          sessionId,
+          activeContextTokens,
+          clientHostPid,
+          currentRoute: {
+            provider,
+            model,
+            effort,
+            fast,
+            contextWindow,
+            rawContextWindow,
+            autoCompactTokenLimit,
+          },
+        });
+        const statusProvider = String(status?.provider || '').trim();
+        const cliProvider = String(provider || '').trim();
+        const statusModel = String(status?.model || '').trim();
+        const cliModel = String(model || '').trim();
+        if (status && !(cliProvider && statusProvider && statusProvider !== cliProvider)
+          && !(cliModel && statusModel && statusModel !== cliModel)) {
+          value = status;
+        }
+      } catch {
+        value = null;
+      }
+      _gatewayQuotaStatusCache = { key, routeKey, at: Date.now(), value };
+      _gatewayQuotaRefreshInFlight = false;
     });
-    if (!status) {
-      _gatewayQuotaStatusCache = { key, at: now, value };
-      return value;
-    }
-    const statusProvider = String(status.provider || '').trim();
-    const cliProvider = String(provider || '').trim();
-    if (cliProvider && statusProvider && statusProvider !== cliProvider) {
-      _gatewayQuotaStatusCache = { key, at: now, value };
-      return value;
-    }
-    const statusModel = String(status.model || '').trim();
-    const cliModel = String(model || '').trim();
-    if (cliModel && statusModel && statusModel !== cliModel) {
-      _gatewayQuotaStatusCache = { key, at: now, value };
-      return value;
-    }
-    value = status;
-  } catch {
-    value = null;
   }
-  _gatewayQuotaStatusCache = { key, at: now, value };
-  return value;
+  return _gatewayQuotaStatusCache.routeKey === routeKey ? _gatewayQuotaStatusCache.value : null;
 }
 
 // Option A boot gate. Returns true once THIS process has captured its first
@@ -428,19 +458,27 @@ function oauthUsageSegmentReady({ provider, model } = {}) {
   const normalizedProvider = String(provider || '').trim().toLowerCase();
   if (!normalizedProvider.includes('oauth')) return true;
   if (_oauthUsageArmedProviders.has(normalizedProvider)) return true;
-  let snapshot = null;
-  try {
-    snapshot = readCachedOAuthUsageSnapshot({
-      provider: normalizedProvider,
-      model: String(model || '').trim(),
-      providerKind: providerKindForQuota(normalizedProvider),
-    }, { allowStale: true });
-  } catch {
-    snapshot = null;
-  }
-  if (isConfirmedCurrentProcessSnapshot(snapshot)) {
-    _oauthUsageArmedProviders.add(normalizedProvider);
-    return true;
+  // Not yet armed: never do the sync snapshot read on this render call. Kick
+  // one background check (guarded per-provider) and keep returning false
+  // (today's pre-arm behavior) until it flips the latch.
+  if (!_oauthArmCheckInFlight.has(normalizedProvider)) {
+    _oauthArmCheckInFlight.add(normalizedProvider);
+    setImmediate(() => {
+      try {
+        const snapshot = readCachedOAuthUsageSnapshot({
+          provider: normalizedProvider,
+          model: String(model || '').trim(),
+          providerKind: providerKindForQuota(normalizedProvider),
+        }, { allowStale: true });
+        if (isConfirmedCurrentProcessSnapshot(snapshot)) {
+          _oauthUsageArmedProviders.add(normalizedProvider);
+        }
+      } catch {
+        /* stay unarmed; next tick retries */
+      } finally {
+        _oauthArmCheckInFlight.delete(normalizedProvider);
+      }
+    });
   }
   return false;
 }
@@ -453,50 +491,58 @@ function fallbackQuotaStatus({ provider, model } = {}) {
   if (_fallbackQuotaStatusCache.key === cacheKey && cacheNow - _fallbackQuotaStatusCache.at < GATEWAY_QUOTA_STATUS_CACHE_MS) {
     return _fallbackQuotaStatusCache.value;
   }
-  const routeInfo = {
-    provider: normalizedProvider,
-    model: String(model || '').trim(),
-    providerKind: providerKindForQuota(normalizedProvider),
-  };
-  let usageSnapshot = null;
-  if (normalizedProvider === 'opencode-go') {
-    usageSnapshot = readCachedOpenCodeGoUsageSnapshot();
-    if (!usageSnapshot) {
-      _fallbackQuotaStatusCache = { key: cacheKey, at: cacheNow, value: null };
-      return null;
-    }
-  } else if (normalizedProvider.includes('oauth')) {
-    try {
-      usageSnapshot = readCachedOAuthUsageSnapshot(routeInfo, { allowStale: true });
-    } catch {}
-  }
-  // Boot guard: do not render previous-launch usage before the current runtime
-  // has captured at least one snapshot. Once a snapshot is captured in this
-  // process, keep it visible while idle even if refreshes are delayed.
-  if (usageSnapshot) {
-    const cachedAt = num(usageSnapshot.cachedAt, 0);
-    if (!cachedAt || cachedAt < STATUSLINE_PROCESS_STARTED_AT_MS) {
-      usageSnapshot = { ...usageSnapshot, quotaWindows: [] };
-    }
-  }
-  try {
-    const limits = buildGatewayLimits(routeInfo, null, usageSnapshot);
-    if (!limits?.quotaWindows?.length && !limits?.balance && !limits?.routeSpend) {
-      _fallbackQuotaStatusCache = { key: cacheKey, at: cacheNow, value: null };
-      return null;
-    }
-    const value = {
-      ...routeInfo,
-      quotaWindows: limits.quotaWindows || [],
-      balance: limits.balance || null,
-      routeSpend: limits.routeSpend || null,
-    };
-    _fallbackQuotaStatusCache = { key: cacheKey, at: cacheNow, value };
-    return value;
-  } catch {
-    _fallbackQuotaStatusCache = { key: cacheKey, at: cacheNow, value: null };
-    return null;
+  // Stale-while-revalidate: serve last cached value for this render call
+  // (same provider+model only — a route switch must not leak the previous
+  // route's balance/spend), refresh (sync snapshot reads included) off the
+  // render call stack.
+  if (!_fallbackQuotaRefreshInFlight) {
+    _fallbackQuotaRefreshInFlight = true;
+    setImmediate(() => {
+      const routeInfo = {
+        provider: normalizedProvider,
+        model: String(model || '').trim(),
+        providerKind: providerKindForQuota(normalizedProvider),
+      };
+      let value = null;
+      try {
+        let usageSnapshot = null;
+        if (normalizedProvider === 'opencode-go') {
+          usageSnapshot = readCachedOpenCodeGoUsageSnapshot();
+        } else if (normalizedProvider.includes('oauth')) {
+          try {
+            usageSnapshot = readCachedOAuthUsageSnapshot(routeInfo, { allowStale: true });
+          } catch {}
+        }
+        if (normalizedProvider === 'opencode-go' && !usageSnapshot) {
+          value = null;
+        } else {
+          // Boot guard: do not render previous-launch usage before the current
+          // runtime has captured at least one snapshot. Once captured in this
+          // process, keep it visible while idle even if refreshes are delayed.
+          if (usageSnapshot) {
+            const cachedAt = num(usageSnapshot.cachedAt, 0);
+            if (!cachedAt || cachedAt < STATUSLINE_PROCESS_STARTED_AT_MS) {
+              usageSnapshot = { ...usageSnapshot, quotaWindows: [] };
+            }
+          }
+          const limits = buildGatewayLimits(routeInfo, null, usageSnapshot);
+          if (limits?.quotaWindows?.length || limits?.balance || limits?.routeSpend) {
+            value = {
+              ...routeInfo,
+              quotaWindows: limits.quotaWindows || [],
+              balance: limits.balance || null,
+              routeSpend: limits.routeSpend || null,
+            };
+          }
+        }
+      } catch {
+        value = null;
+      }
+      _fallbackQuotaStatusCache = { key: cacheKey, at: Date.now(), value };
+      _fallbackQuotaRefreshInFlight = false;
+    });
   }
+  return _fallbackQuotaStatusCache.key === cacheKey ? _fallbackQuotaStatusCache.value : null;
 }
 
 function providerKindForQuota(provider) {