mixdog 0.8.0 → 0.9.0

package/src/ui/tool-card.mjs

@@ -3,22 +3,21 @@
  *
  * Replaces the raw `[tool: name]` line with a styled card that shows the tool
  * name plus a short, human-readable summary of its most relevant argument
- * (path for read/write/edit, command for shell, pattern for grep, etc.).
+ * (path for read/apply_patch, command for shell, pattern for grep, etc.).
  *
  * Pure formatting: returns a string, never touches stdout. Robust to missing or
  * malformed argument objects (the engine hands us `{ name, arguments, id }`).
  */
-import { bold, dim, cyan, gray, yellow, green } from './ansi.mjs';
+import { bold, cyan, gray } from './ansi.mjs';
 
 const MAX_SUMMARY = 72;
 
 /** Map of tool name -> function deriving its one-line summary from args. */
 const SUMMARIZERS = {
   read: (a) => a.path ?? a.file,
-  write: (a) => a.path,
   apply_patch: (a) => a.path ?? a.base_path ?? firstPatchPath(a.patch),
-  edit: (a) => a.path ?? (Array.isArray(a.edits) ? a.edits[0]?.path : undefined),
   list: (a) => a.path ?? a.pattern,
+  find: (a) => a.query ?? a.fuzzy ?? a.path,
   glob: (a) => joinMaybe(a.pattern) ?? a.path,
   grep: (a) => joinMaybe(a.pattern),
   shell: (a) => a.command,
@@ -45,18 +44,6 @@ export function renderToolCard(call) {
   return `  ${bullet} ${label} ${gray(truncate(summary, MAX_SUMMARY))}`;
 }
 
-/** Render several calls (from one iteration) as a joined block. */
-export function renderToolCards(calls) {
-  return (calls || []).map(renderToolCard).join('\n');
-}
-
-/** A small "done" marker line for a completed tool (optional nicety). */
-export function renderToolResult(name, { ok = true, note = '' } = {}) {
-  const mark = ok ? green('ok') : yellow('x');
-  const tail = note ? ' ' + dim(truncate(String(note), 48)) : '';
-  return `  ${mark} ${dim(String(name ?? 'tool'))}${tail}`;
-}
-
 // --- helpers -----------------------------------------------------------------
 
 function safeSummary(name, args) {

package/src/vendor/statusline/bin/statusline-lib.mjs

@@ -151,7 +151,7 @@ function compactWindowForRouteLike(route) {
   const explicit = num(route.autoCompactTokenLimit ?? route.auto_compact_token_limit);
   const raw = num(route.rawContextWindow ?? route.raw_context_window ?? route.contextWindow ?? route.context_window);
   const context = num(route.contextWindow ?? route.context_window);
-  const pct = num(route.effectiveContextWindowPercent ?? route.effective_context_window_percent) || 95;
+  const pct = num(route.effectiveContextWindowPercent ?? route.effective_context_window_percent) || 90;
   const effective = context || (raw > 0 ? Math.max(1, Math.floor(raw * Math.min(100, pct) / 100)) : 0);
   if (explicit > 0 && effective > 0) return Math.min(explicit, effective);
   if (explicit > 0) return explicit;
@@ -573,6 +573,10 @@ export async function renderStatusLine(ccJsonInput) {
     if (cleanTags.length <= limit) return cleanTags.join(', ');
     return `${cleanTags.slice(0, limit).join(', ')}, +${cleanTags.length - limit}`;
   }
+  const workerSpinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  function workerSpinnerFrame(now = Date.now()) {
+    return workerSpinnerFrames[Math.floor(now / 120) % workerSpinnerFrames.length] || workerSpinnerFrames[0];
+  }
 
   const gatewayLimitSegments = formatGatewayLimitSegments(GATEWAY_STATUS, {
     COLS, D, R, RED, GRN, YLW, colourPct, epochMsToHHMM,
@@ -595,9 +599,9 @@ export async function renderStatusLine(ccJsonInput) {
   if (modelStr) {
     const m = COLS >= 120 ? modelStr : modelShort;
     if (effortStr) {
-      addL1(`${CYN}◆${R} ${B}${m}${R} ${D}·${R} ${B}${effortStr}${R}`);
+      addL1(`${B}${m}${R} ${D}·${R} ${B}${effortStr}${R}`);
     } else {
-      addL1(`${CYN}◆${R} ${B}${m}${R}`);
+      addL1(`${B}${m}${R}`);
     }
   }
 
@@ -781,7 +785,7 @@ export async function renderStatusLine(ccJsonInput) {
   function addL2(seg) { if (seg) l2Parts.push(seg); }
 
   if (workCount > 0 && workOrder) {
-    addL2(`${GRN}●${R} ${B}${workCount} Running${R} ${D}(${R}${B}${summarizeWorkerTags(workOrder.split(','))}${R}${D})${R}`);
+    addL2(`${GRN}${workerSpinnerFrame()}${R} ${B}${workCount} Running${R} ${D}(${R}${B}${summarizeWorkerTags(workOrder.split(','))}${R}${D})${R}`);
   }
 
   if (idleWorkers.length) {

package/src/vendor/statusline/bin/statusline-route.mjs

@@ -17,6 +17,11 @@ function positiveInt(value) {
   return Number.isFinite(n) && n > 0 ? n : 0;
 }
 
+// Keep the last known OAuth usage snapshot visible while idle. Live refreshes
+// replace it when available, but a delayed/failed refresh must not make the
+// statusline usage segment disappear. Previous-launch snapshots stay hidden
+// during boot until the current process captures usage once.
+const STATUSLINE_PROCESS_STARTED_AT_MS = Date.now() - Math.floor((Number(process.uptime?.()) || 0) * 1000);
 function isPidAlive(pid) {
   const n = positiveInt(pid);
   if (!n) return false;
@@ -56,6 +61,14 @@ function num(value, fallback = null) {
   return Number.isFinite(n) ? n : fallback;
 }
 
+function firstPositiveWindow(...values) {
+  for (const value of values) {
+    const n = num(value, null);
+    if (n !== null && n > 0) return n;
+  }
+  return null;
+}
+
 function money(value) {
   const n = Number(value);
   if (!Number.isFinite(n)) return '';
@@ -88,6 +101,19 @@ function cleanString(value) {
   return s || '';
 }
 
+// Mirror of route-meta.mjs providerKind(): classify a provider id into a kind
+// bucket. statusline-route.mjs derives its own status snapshot and calls this
+// the same way route-meta does, but never imported/defined it, so any route
+// status build threw `providerKind is not defined`.
+function providerKind(provider) {
+  const p = String(provider || '').toLowerCase();
+  if (!p) return 'unknown';
+  if (p === 'opencode-go') return 'quota-api';
+  if (p.includes('oauth')) return 'oauth';
+  if (p === 'ollama' || p === 'lmstudio') return 'local';
+  return 'api';
+}
+
 function slugSegment(value) {
   const s = cleanString(value);
   if (!s) return '';
@@ -163,18 +189,16 @@ function boundedPercent(value, fallback = null) {
 }
 
 function defaultEffectiveContextWindowPercent(_provider) {
-  return 95;
+  return 90;
 }
 
 function routeContextMeta(provider, info = {}, inherited = {}) {
-  const rawContextWindow = num(
-    inherited.rawContextWindow
-      ?? inherited.raw_context_window
-      ?? info.contextWindow
-      ?? info.maxContextWindow
-      ?? info.max_input_tokens
-      ?? inherited.contextWindow,
-    null,
+  const rawContextWindow = firstPositiveWindow(
+    inherited.rawContextWindow,
+    inherited.raw_context_window,
+    info.contextWindow,
+    info.maxContextWindow,
+    info.max_input_tokens,
   );
   const effectiveContextWindowPercent = boundedPercent(
     inherited.effectiveContextWindowPercent
@@ -183,9 +207,16 @@ function routeContextMeta(provider, info = {}, inherited = {}) {
       ?? info.effective_context_window_percent,
     defaultEffectiveContextWindowPercent(provider),
   );
-  const contextWindow = rawContextWindow
+  const derivedContextWindow = rawContextWindow
     ? Math.max(1, Math.floor(rawContextWindow * boundedPercent(effectiveContextWindowPercent, 100) / 100))
     : null;
+  const explicitEffectiveContextWindow = firstPositiveWindow(
+    inherited.contextWindow,
+    inherited.displayContextWindow,
+    inherited.compactBoundaryTokens,
+    inherited.compact_boundary_tokens,
+  );
+  const contextWindow = explicitEffectiveContextWindow ?? derivedContextWindow;
   const explicitCompactLimit = num(
     inherited.autoCompactTokenLimit
       ?? inherited.auto_compact_token_limit
@@ -193,10 +224,18 @@ function routeContextMeta(provider, info = {}, inherited = {}) {
       ?? info.auto_compact_token_limit,
     null,
   );
-  const derivedCompactLimit = contextWindow || rawContextWindow || null;
-  const autoCompactTokenLimit = explicitCompactLimit && derivedCompactLimit
-    ? Math.min(explicitCompactLimit, derivedCompactLimit)
-    : explicitCompactLimit ?? derivedCompactLimit;
+  // autoCompactTokenLimit must mean an EXPLICIT auto-compaction limit only.
+  // Do NOT derive it from the context/raw window: the runtime treats a present
+  // autoCompactTokenLimit as the compaction trigger, and a full-window value
+  // collapses the compaction buffer to 0. Keep boundary/window display via the
+  // separate contextWindow/rawContextWindow fields. An explicit limit is only a
+  // real trigger when STRICTLY BELOW the boundary; a legacy seed/info value
+  // equal to or above it is a derived full-window artifact and is dropped to
+  // null (Math.min would still surface the boundary). Never derive a limit.
+  const _boundary = contextWindow || rawContextWindow || null;
+  const autoCompactTokenLimit = explicitCompactLimit && explicitCompactLimit > 0
+    ? (_boundary ? (explicitCompactLimit < _boundary ? explicitCompactLimit : null) : explicitCompactLimit)
+    : null;
   return {
     contextWindow,
     rawContextWindow,
@@ -205,14 +244,49 @@ function routeContextMeta(provider, info = {}, inherited = {}) {
   };
 }
 
-function compactBoundaryForStatus(routeInfo = {}, compact = null) {
+// Test-only export of the route context-meta resolver for the auto-compact
+// limit migration smoke (scripts/compact-trigger-migration-smoke.mjs).
+export const _routeContextMeta = routeContextMeta;
+
+// Resolve the auto-compact limit displayed by loadGatewayStatus(). The active
+// value MUST be validated against the ACTIVE route's own boundary/window, never
+// configured?.contextWindow: the configured window can be larger than the
+// active window, so validating a stale active full-window value (== active
+// window) against the configured window would let it slip through as an
+// explicit limit. The configured route's limit (already sanitized by
+// routeContextMeta) is preferred when a configured route is present, but it
+// never validates a stale active value.
+function resolveStatusAutoCompactTokenLimit(configured, active = {}, lastCompact = null) {
+  if (configured) {
+    const c = num(configured.autoCompactTokenLimit, 0);
+    return c > 0 ? c : null;
+  }
+  const activeBoundary = num(
+    active?.gateway_context_window
+      ?? active?.gateway_raw_context_window
+      ?? lastCompact?.budgetWindow
+      ?? lastCompact?.contextWindow,
+    0,
+  );
+  const raw = num(active?.gateway_auto_compact_token_limit, 0);
+  if (!(raw > 0)) return null;
+  if (activeBoundary > 0) return raw < activeBoundary ? raw : null;
+  return raw;
+}
+
+// Test-only export of the status auto-compact-limit resolver.
+export const _resolveStatusAutoCompactTokenLimit = resolveStatusAutoCompactTokenLimit;
+
+export function compactBoundaryForStatus(routeInfo = {}, compact = null) {
   const compactLimit = num(routeInfo?.autoCompactTokenLimit ?? compact?.compactLimitTokens, 0);
   const contextWindow = num(routeInfo?.contextWindow ?? compact?.contextWindow, 0);
   const budgetWindow = num(compact?.budgetWindow, 0);
   const rawContextWindow = num(routeInfo?.rawContextWindow ?? compact?.rawContextWindow, 0);
-  if (contextWindow > 0) return contextWindow;
-  if (budgetWindow > 0) return budgetWindow;
+  if (compactLimit > 0 && contextWindow > 0) return Math.min(compactLimit, contextWindow);
   if (compactLimit > 0) return compactLimit;
+  if (budgetWindow > 0 && contextWindow > 0) return Math.min(budgetWindow, contextWindow);
+  if (budgetWindow > 0) return budgetWindow;
+  if (contextWindow > 0) return contextWindow;
   return rawContextWindow > 0 ? rawContextWindow : null;
 }
 
@@ -237,7 +311,7 @@ function gatewaySessionStatus(sessionId, clientHostPid = null) {
 function sessionRouteFor(gateway, sessionId, clientHostPid = null) {
   const sid = cleanString(sessionId);
   if (!sid) return { route: gateway, sessionScoped: false };
-  const route = readGatewaySessionRoute(sid, { clientHostPid })
+  const route = readGatewaySessionRoute(sid, { clientHostPid, fallbackLegacy: true })
     || readLatestGatewayHostRoute(clientHostPid, { excludeSessionId: sid });
   if (!route || typeof route !== 'object') return { route: gateway, sessionScoped: false };
   const provider = cleanString(route.defaultProvider || route.provider);
@@ -273,10 +347,9 @@ function loadCachedModel(provider, model) {
 }
 
 function cachedQuotaWindowsFallback(provider, model) {
-  // Resolve quota windows for the CURRENT route only. The oauth usage cache is
-  // keyed by `${provider}
${model}` (with a provider-only fallback key);
-  // never scan for the "most recent" entry across routes, or a sibling session
-  // on a different route would clobber this session's 5H/7D/reset display.
+  // OAuth quota is provider/account-scoped, not model-scoped. Prefer the
+  // current route key, then provider-wide cache, then the freshest same-provider
+  // route entry so a model switch keeps showing quota before the next live fetch.
   if (!provider || !model) return [];
   try {
     const cachePath = path.join(pluginDataDir(), 'gateway-oauth-usage-cache.json');
@@ -285,8 +358,17 @@ function cachedQuotaWindowsFallback(provider, model) {
     if (!routes) return [];
     const routeKey = `${String(provider).toLowerCase()}
${String(model)}`;
     const providerOnlyKey = String(provider).toLowerCase();
-    const entry = routes[routeKey] || routes[providerOnlyKey];
-    return Array.isArray(entry?.quotaWindows) ? entry.quotaWindows : [];
+    const routePrefix = `${providerOnlyKey}
`;
+    const entry = routes[routeKey] || routes[providerOnlyKey] || Object.entries(routes)
+      .filter(([key, value]) => key.startsWith(routePrefix) && Array.isArray(value?.quotaWindows))
+      .sort((a, b) => (Number(b[1]?.cachedAt) || 0) - (Number(a[1]?.cachedAt) || 0))[0]?.[1];
+    if (!Array.isArray(entry?.quotaWindows)) return [];
+    // Boot guard: do not render previous-launch usage before the current runtime
+    // has captured at least one snapshot. Once captured in this process, hold it
+    // instead of blanking it during idle/network gaps.
+    const cachedAt = Number(entry.cachedAt);
+    if (!Number.isFinite(cachedAt) || cachedAt < STATUSLINE_PROCESS_STARTED_AT_MS) return [];
+    return entry.quotaWindows;
   } catch {
     return [];
   }
@@ -336,7 +418,22 @@ function configuredGatewayStatus(options = {}) {
   const cfgPath = path.join(pluginDataDir(), 'mixdog-config.json');
   const cfg = readJson(cfgPath);
   const gatewayBase = cfg?.gateway && typeof cfg.gateway === 'object' ? cfg.gateway : {};
-  const { route: gateway, sessionScoped } = sessionRouteFor(gatewayBase, options.sessionId, options.clientHostPid);
+  let { route: gateway, sessionScoped } = sessionRouteFor(gatewayBase, options.sessionId, options.clientHostPid);
+  const currentRoute = options?.currentRoute && typeof options.currentRoute === 'object' ? options.currentRoute : null;
+  const currentProvider = cleanString(currentRoute?.provider || currentRoute?.defaultProvider);
+  const currentModel = cleanString(currentRoute?.model || currentRoute?.defaultModel);
+  if ((!cleanString(gateway?.defaultProvider) || !cleanString(gateway?.defaultModel)) && currentProvider && currentModel) {
+    gateway = {
+      ...(gateway || {}),
+      mode: cleanString(gateway?.mode) || 'fixed',
+      defaultProvider: currentProvider,
+      defaultModel: currentModel,
+      ...(cleanString(currentRoute?.effort ?? currentRoute?.displayEffort) ? { effort: cleanString(currentRoute?.effort ?? currentRoute?.displayEffort) } : {}),
+      ...(cleanBool(currentRoute?.fast) !== null ? { fast: cleanBool(currentRoute.fast) } : {}),
+      ...(num(currentRoute?.contextWindow, null) ? { contextWindow: num(currentRoute.contextWindow, null) } : {}),
+      ...(num(currentRoute?.rawContextWindow, null) ? { rawContextWindow: num(currentRoute.rawContextWindow, null) } : {}),
+    };
+  }
   const modules = cfg?.modules && typeof cfg.modules === 'object' ? cfg.modules : {};
   if (modules.gateway && modules.gateway.enabled === false) return null;
   const inherit = cleanString(gateway.mode) === CLAUDE_CURRENT_MODE;
@@ -381,11 +478,17 @@ function configuredGatewayStatus(options = {}) {
     : inherit
     ? cleanBool(aliasTarget?.fast) ?? cleanBool(inherited?.fast) ?? cleanBool(gateway.fast) ?? cleanBool(preset?.fast) ?? false
     : cleanBool(gateway.fast) ?? cleanBool(preset?.fast) ?? false;
-  const contextMeta = routeContextMeta(provider, info, aliasTarget ? {} : (inherited || {}));
+  const routeMatchesCurrent = currentProvider === provider && currentModel === model;
+  const contextSeed = {
+    ...(inherited || {}),
+    ...(routeMatchesCurrent ? currentRoute || {} : {}),
+  };
+  const contextMeta = routeContextMeta(provider, info, aliasTarget ? {} : contextSeed);
   return {
     mode: inherit ? CLAUDE_CURRENT_MODE : '',
     provider,
     model,
+    providerKind: providerKind(provider),
     modelDisplay: statuslineDisplayForModel(
       provider,
       model,
@@ -464,12 +567,29 @@ export function loadGatewayStatus(options = {}) {
       num(contextBoundary, 0),
     )
     : null;
-  const recomputedContextUsedPct = pctOf(liveContextTokens ?? (compactRequestWithLiveTokens ? liveContextTokens : (overflowContextTokens ?? lastUsage?.promptTokens)), contextBoundary);
+  const contextNumerator = liveContextTokens !== null && Number.isFinite(liveContextTokens)
+    ? liveContextTokens
+    : (overflowContextTokens ?? null);
+  const recomputedContextUsedPct = pctOf(contextNumerator, contextBoundary);
   const activeQuotaWindows = metricsMatch && Array.isArray(active.gateway_quota_windows)
     ? active.gateway_quota_windows
     : [];
+  const statusProvider = configured?.provider || active.gateway_provider;
+  const statusProviderKind = configured?.providerKind
+    || (routeMatchesConfigured ? cleanString(active.gateway_provider_kind) : '')
+    || providerKind(statusProvider);
+  // Sanitize the auto-compact limit before display: a stale boundary/window-
+  // sized active.gateway_auto_compact_token_limit must not surface as an
+  // explicit autoCompactTokenLimit (the runtime would read it as the trigger
+  // and collapse the buffer). The active value must be validated against the
+  // ACTIVE route's own boundary/window — NOT configured?.contextWindow. The
+  // configured window can be larger than the active window, so using it would
+  // let a stale active full-window value (== active window) slip through. Use
+  // the active boundary (active context/raw window, or the lastCompact budget
+  // when present) and null the active value when it is >= that boundary.
+  const statusAutoCompactTokenLimit = resolveStatusAutoCompactTokenLimit(configured, active, lastCompact);
   const activeStatus = {
-    provider: configured?.provider || active.gateway_provider,
+    provider: statusProvider,
     model: configured?.model || active.gateway_model,
     modelDisplay: configured?.modelDisplay
       || statuslineDisplayForModel(active.gateway_provider, active.gateway_model, {}, active.gateway_model_display)
@@ -479,13 +599,13 @@ export function loadGatewayStatus(options = {}) {
     contextWindow: configured?.contextWindow ?? num(active.gateway_context_window, null),
     rawContextWindow: configured?.rawContextWindow ?? num(active.gateway_raw_context_window, null),
     effectiveContextWindowPercent: configured?.effectiveContextWindowPercent ?? num(active.gateway_effective_context_window_percent, null),
-    autoCompactTokenLimit: configured?.autoCompactTokenLimit ?? num(active.gateway_auto_compact_token_limit, null),
+    autoCompactTokenLimit: statusAutoCompactTokenLimit,
     contextUsedPct: metricsMatch ? recomputedContextUsedPct ?? num(active.gateway_context_used_pct, null) : null,
     lastUsage,
     quotaWindows: activeQuotaWindows.length ? activeQuotaWindows : (configuredStatus?.quotaWindows || []),
     balance: metricsMatch && active.gateway_balance && typeof active.gateway_balance === 'object' ? active.gateway_balance : (configuredStatus?.balance || null),
     routeSpend: metricsMatch && active.gateway_route_spend && typeof active.gateway_route_spend === 'object' ? active.gateway_route_spend : (configuredStatus?.routeSpend || null),
-    providerKind: active.gateway_provider_kind || '',
+    providerKind: statusProviderKind,
   };
   if (!configured) return activeStatus;
   return activeStatus;
@@ -510,6 +630,17 @@ export function formatGatewayLimitSegments(status, fmt) {
   } = fmt || {};
   const segments = [];
   const kind = cleanString(status.providerKind || '').toLowerCase();
+  const providerId = cleanString(status.provider || '').toLowerCase();
+  const statusSource = cleanString(status.source || '').toLowerCase();
+  const balanceSource = cleanString(status.balance?.source || '').toLowerCase();
+  const isOpenAiOAuth = (kind === 'oauth' || providerId.includes('oauth'))
+    && (
+      providerId === 'openai-oauth'
+      || statusSource.includes('openai')
+      || statusSource.includes('codex')
+      || balanceSource.includes('openai')
+      || balanceSource.includes('codex')
+    );
   const isPlainApi = kind === 'api';
   const windows = !isPlainApi && Array.isArray(status.quotaWindows) ? status.quotaWindows : [];
   const maxWindows = COLS >= 120 ? 3 : COLS >= 80 ? 2 : 1;
@@ -537,6 +668,7 @@ export function formatGatewayLimitSegments(status, fmt) {
     return false;
   };
   const addApiBalance = () => {
+    if (isOpenAiOAuth) return false;
     const remaining = num(status.balance?.remainingUsd, null);
     if (remaining !== null) {
       segments.push(`${D}Credit${R} ${money(remaining)}`);
@@ -551,12 +683,12 @@ export function formatGatewayLimitSegments(status, fmt) {
   for (const w of windows.slice(0, maxWindows)) {
     const label = String(w?.label || 'USE').toUpperCase();
     const pct = num(w?.usedPct, null);
-    const remaining = num(w?.remainingUsd, null);
-    const limit = num(w?.limitUsd, null);
-    const used = num(w?.usedUsd, null);
-    const remainingCredits = num(w?.remainingCredits, null);
-    const limitCredits = num(w?.limitCredits, null);
-    const usedCredits = num(w?.usedCredits, null);
+    const remaining = isOpenAiOAuth ? null : num(w?.remainingUsd, null);
+    const limit = isOpenAiOAuth ? null : num(w?.limitUsd, null);
+    const used = isOpenAiOAuth ? null : num(w?.usedUsd, null);
+    const remainingCredits = isOpenAiOAuth ? null : num(w?.remainingCredits, null);
+    const limitCredits = isOpenAiOAuth ? null : num(w?.limitCredits, null);
+    const usedCredits = isOpenAiOAuth ? null : num(w?.usedCredits, null);
     const estimated = isLocalEstimateWindow(w);
     if (remaining !== null) {
       const color = estimated ? YLW : remaining <= 1 ? RED : remaining <= 5 ? YLW : GRN;
@@ -581,7 +713,7 @@ export function formatGatewayLimitSegments(status, fmt) {
   }
   if (segments.length) return segments;
 
-  const remaining = num(status.balance?.remainingUsd, null);
+  const remaining = isOpenAiOAuth ? null : num(status.balance?.remainingUsd, null);
   if (remaining !== null) {
     segments.push(`${D}Credit${R} ${money(remaining)}`);
     addRouteSpend();

package/src/vendor/statusline/bin/statusline-route.test.mjs

@@ -0,0 +1,80 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { formatGatewayLimitSegments } from './statusline-route.mjs';
+
+test('formatGatewayLimitSegments hides OpenAI OAuth credit balance on L1', () => {
+  const segments = formatGatewayLimitSegments({
+    provider: 'openai-oauth',
+    providerKind: 'oauth',
+    source: 'openai-codex-wham',
+    quotaWindows: [
+      { label: '5H', source: 'openai-codex-oauth', usedPct: 42 },
+      { label: '7D', source: 'openai-codex-oauth', usedPct: 5 },
+    ],
+    balance: {
+      source: 'openai-codex-credits',
+      remainingUsd: 12.34,
+    },
+  }, { COLS: 120 });
+
+  assert.deepEqual(segments, ['5H 42%', '7D 5%']);
+  assert.equal(segments.some((segment) => /Credit|\$12\.34/.test(segment)), false);
+});
+
+test('formatGatewayLimitSegments falls back to percent for OpenAI OAuth credit windows', () => {
+  const segments = formatGatewayLimitSegments({
+    provider: 'openai-oauth',
+    providerKind: 'oauth',
+    quotaWindows: [
+      {
+        label: '5H',
+        source: 'openai-codex-oauth',
+        usedPct: 55,
+        remainingUsd: 4,
+        usedUsd: 6,
+        limitUsd: 10,
+        remainingCredits: 40,
+        usedCredits: 60,
+        limitCredits: 100,
+      },
+    ],
+  }, { COLS: 120 });
+
+  assert.deepEqual(segments, ['5H 55%']);
+});
+
+test('formatGatewayLimitSegments keeps non-OpenAI OAuth credit balance on L1', () => {
+  const segments = formatGatewayLimitSegments({
+    provider: 'anthropic-oauth',
+    providerKind: 'oauth',
+    source: 'anthropic-oauth',
+    quotaWindows: [
+      { label: '5H', source: 'anthropic-oauth', usedPct: 20 },
+    ],
+    balance: {
+      source: 'anthropic-oauth-extra',
+      remainingUsd: 7.5,
+    },
+  }, { COLS: 120 });
+
+  assert.ok(segments.includes('Credit $7.50'));
+});
+
+test('formatGatewayLimitSegments suppresses OpenAI OAuth credit via providerId even without a source hint', () => {
+  // Mirrors the merged quotaStatus shape (mergeQuotaStatus) where `source` may
+  // be absent and `balance.source` is generic: the providerId === openai-oauth
+  // branch alone must still suppress any Credit/$ leak on L1.
+  const segments = formatGatewayLimitSegments({
+    provider: 'openai-oauth',
+    providerKind: 'oauth',
+    quotaWindows: [
+      { label: '5H', source: 'openai-codex-oauth', usedPct: 30 },
+    ],
+    balance: {
+      remainingUsd: 99.99,
+    },
+  }, { COLS: 120 });
+
+  assert.deepEqual(segments, ['5H 30%']);
+  assert.equal(segments.some((segment) => /Credit|\$/.test(segment)), false);
+});

package/src/vendor/statusline/scripts/lib/gateway-settings.mjs

@@ -139,7 +139,7 @@ export function setAnthropicBaseUrl(url, { dryRun = false, autoCompactWindow = n
 
 // RUNTIME base-url sync for live /model changes.
 //
-// Claude Code re-applies settings.env into process.env while the session is
+// The host client re-applies settings.env into process.env while the session is
 // alive, but deleting ANTHROPIC_BASE_URL does not unset the already-present
 // process env key. For native Claude choices, write the official Anthropic base
 // URL instead. For mixdog choices, write the local gateway URL. This helper is
@@ -190,8 +190,8 @@ export function syncAnthropicBaseUrl(url, { dryRun = false, requireExisting = tr
 }
 
 // RUNTIME compact-window sync (Stage 4) — used by the gateway request path when
-// the routed model's context window changes at runtime (/model switch). Claude
-// Code watches settings.json (chokidar) and re-applies env to process.env
+// the routed model's context window changes at runtime (/model switch). The host
+// client watches settings.json (chokidar) and re-applies env to process.env
 // without restart, and getEffectiveContextWindowSize reads process.env live, so
 // rewriting CLAUDE_CODE_AUTO_COMPACT_WINDOW here makes the auto-compact
 // threshold track the live model next turn.

package/src/vendor/statusline/src/gateway/claude-current.mjs

@@ -313,7 +313,7 @@ export function writeClaudeCodeCurrentSnapshot(ccJsonInput) {
 }
 
 export function formatClaudeCurrentChoiceLabel(route = readClaudeCodeCurrentRoute()) {
-  const parts = [`Claude Code current: ${route.modelDisplay || route.model || 'current model'}`];
+  const parts = [`Current selection: ${route.modelDisplay || route.model || 'current model'}`];
   if (route.effort) parts.push(String(route.effort).toUpperCase());
   if (route.fast === true) parts.push('fast');
   return parts.join(' · ');

package/src/vendor/statusline/src/gateway/route-meta.mjs

@@ -103,7 +103,7 @@ function defaultEffectiveContextWindowPercent(_provider) {
   // models.dev, or native provider catalogs). Reserve a small universal
   // headroom for output/tool/system tokens while keeping the raw model window
   // visible separately.
-  return 95;
+  return 90;
 }
 
 function effectiveContextWindowPercent(provider, info = {}, seed = {}) {
@@ -124,6 +124,16 @@ function effectiveContextWindow(rawContextWindow, percent) {
 }
 
 function autoCompactTokenLimit(provider, rawContextWindow, contextWindow, info = {}, seed = {}) {
+  // routeInfo.autoCompactTokenLimit is an EXPLICIT auto-compaction limit only.
+  // It must NOT be derived from the effective/raw context window: the runtime
+  // (manager.mjs resolveSessionContextMeta / loop.mjs resolveWorkerCompactPolicy)
+  // treats autoCompactTokenLimit as the compaction trigger. Deriving it from the
+  // full boundary makes autoTriggerTokens == boundary, collapses the compaction
+  // buffer to 0, and auto-compaction only fires once the window is already full
+  // (where semantic compact overflows and the turn is lost). The boundary/window
+  // fallback that status + gateway env still need lives in compactBoundaryForRoute
+  // / autoCompactWindowForRoute, which read contextWindow/rawContextWindow
+  // directly. Return null when there is no explicit provider/catalog/seed limit.
   const explicit = num(
     seed.autoCompactTokenLimit
       ?? seed.auto_compact_token_limit
@@ -131,12 +141,25 @@ function autoCompactTokenLimit(provider, rawContextWindow, contextWindow, info =
       ?? info.auto_compact_token_limit,
     0,
   );
+  if (!(explicit > 0)) return null;
+  // An explicit limit is only a real auto-compaction trigger when it sits
+  // STRICTLY BELOW the boundary/window. A legacy seed/info value equal to or
+  // above the boundary is a derived full-window artifact — returning
+  // Math.min(explicit, derived) would still surface the boundary, which the
+  // runtime then treats as the trigger and collapses the compaction buffer.
+  // Drop those to null so display + downstream fall back to the default
+  // boundary trigger.
   const derived = num(contextWindow, 0) || num(rawContextWindow, 0);
-  if (explicit > 0 && derived > 0) return Math.min(explicit, derived);
-  if (explicit > 0) return explicit;
-  return derived > 0 ? derived : null;
+  if (derived > 0) return explicit < derived ? explicit : null;
+  // No boundary known: keep the positive explicit value (cannot be proven to
+  // be a full-window artifact), but never derive one.
+  return explicit;
 }
 
+// Test-only export of the explicit-vs-derived auto-compact-limit resolver
+// (see scripts/compact-trigger-migration-smoke.mjs).
+export const _autoCompactTokenLimit = autoCompactTokenLimit;
+
 function routeIdentityKey(routeInfo = {}) {
   return [
     routeInfo.provider || '',
@@ -333,7 +356,7 @@ function compactBoundaryForRoute(routeInfo = {}, compact = null) {
   return rawContextWindow > 0 ? rawContextWindow : 0;
 }
 
-// Single source of truth for the value handed to Claude Code's
+// Single source of truth for the value synced to host env
 // CLAUDE_CODE_AUTO_COMPACT_WINDOW. BOTH the --enable-time write
 // (scripts/gateway-model.mjs) and the runtime sync (src/gateway/server.mjs)
 // must derive the window the SAME way, or they disagree on the value written to
@@ -418,7 +441,22 @@ export function summarizeGatewayUsage(routeInfo, providerOut, compact = null, du
   const routeSectionStartedAt = ensureRouteSection(routeInfo);
   const promptTokens = promptFootprintTokens(routeInfo?.provider, u);
   const boundaryTokens = contextUsageBoundary(routeInfo, compact);
-  const contextUsedPct = boundaryTokens > 0 ? round(promptTokens * 100 / boundaryTokens, 2) : null;
+  // Prefer the transcript-estimate footprint for the displayed pct: it is
+  // monotonic and window-bounded, unlike provider input_tokens which can swing
+  // wildly (and produce >1000% pct) on some providers (e.g. OpenAI gpt-5.5).
+  // compact.afterTokens / beforeTokens = estimateMessagesTokens(working)+reserve.
+  const estimateFootprintTokens = num(compact?.afterTokens, 0) || num(compact?.beforeTokens, 0);
+  let contextUsedPct = null;
+  if (boundaryTokens > 0) {
+    if (estimateFootprintTokens > 0) {
+      // Estimate-based numerator may legitimately exceed boundary -> real >100%.
+      contextUsedPct = round(estimateFootprintTokens * 100 / boundaryTokens, 2);
+    } else {
+      // Fallback to provider tokens; clamp to a sane ceiling since these are
+      // not reliably window-bounded.
+      contextUsedPct = Math.min(100, round(promptTokens * 100 / boundaryTokens, 2));
+    }
+  }
   const costUsd = usageCostUsd(routeInfo, u);
   const usageCompact = compact && typeof compact === 'object' ? { ...compact } : compact;
   return {

package/src/vendor/statusline/src/gateway/session-routes.mjs

@@ -226,7 +226,7 @@ export function gatewayConfigForSessionBoot(globalGateway = {}, sessionId = null
       }
     }
   }
-  // 3. If Claude Code did not provide a reliable prior transcript on /new,
+  // 3. If the host session did not provide a reliable prior transcript on /new,
   // carry the last explicit route for this terminal only. This keeps multiple
   // terminals isolated without falling back to the process-global default.
   if (pid) {