mixdog 0.8.1 → 0.9.1

package/src/ui/statusline.mjs

@@ -11,15 +11,18 @@
  */
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { basename, join } from 'node:path';
-import { bold, colorEnabled, green, rgb } from './ansi.mjs';
+import { join } from 'node:path';
+import { bold, colorEnabled, rgb } from './ansi.mjs';
+import { displayModelName, shortenModelName } from './model-display.mjs';
+import { createSessionStats } from './session-stats.mjs';
 import { forEachSessionRuntime } from '../runtime/agent/orchestrator/session/manager.mjs';
 import { listHiddenRoleNames } from '../runtime/agent/orchestrator/internal-roles.mjs';
 import { getModelMetadataSync } from '../runtime/agent/orchestrator/providers/model-catalog.mjs';
 import { readCachedOAuthUsageSnapshot } from '../runtime/agent/orchestrator/providers/oauth-usage.mjs';
 import { readCachedOpenCodeGoUsageSnapshot } from '../runtime/agent/orchestrator/providers/opencode-go-usage.mjs';
 import { buildGatewayLimits } from '../runtime/agent/orchestrator/providers/statusline-route-meta.mjs';
-import { formatGatewayLimitSegments, loadGatewayStatus } from '../vendor/statusline/bin/statusline-route.mjs';
+import { compactBoundaryForStatus, formatGatewayLimitSegments, loadGatewayStatus } from '../vendor/statusline/bin/statusline-route.mjs';
+export { createSessionStats, applyUsageDelta } from './session-stats.mjs';
 
 // Token window used to compute a fallback context% from our own session usage.
 // The live gateway (when up) overrides this with the real route's window. This
@@ -45,62 +48,63 @@ const CYN = sgr('38;2;136;136;136');
 const GREY = sgr('38;2;136;136;136');
 const SHELL_JOBS_SEGMENT_CACHE_MS = 1000;
 const GATEWAY_QUOTA_STATUS_CACHE_MS = 500;
+const WORKER_SPINNER_FRAMES = Object.freeze(['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']);
+const WORKER_SPINNER_FRAME_MS = 160;
+// 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
+// spinner's 160ms. l2SpinnerFrame() indexes straight into WORKER_SPINNER_FRAMES.
+const L2_SPINNER_FRAME_MS = 120;
+// Keep the last known usage snapshot visible while idle. The runtime still
+// refreshes OAuth usage in the background, but if that refresh is delayed or
+// fails, the statusline should not blink/drop the usage segment; it should hold
+// the last captured 5H/7D values from THIS process until a newer snapshot
+// 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);
 const DEFAULT_HIDDEN_STATUSLINE_ROLES = Object.freeze(['explorer', 'cycle1-agent', 'cycle2-agent', 'cycle3-agent', 'scheduler-task', 'webhook-handler']);
-let _shellJobsSegmentCache = { ownerPid: 0, at: 0, value: '' };
+let _shellJobsSegmentCache = { ownerPid: 0, at: 0, value: { count: 0, elapsedLabel: '' } };
 let _gatewayQuotaStatusCache = { key: '', at: 0, value: null };
 let _fallbackQuotaStatusCache = { key: '', at: 0, value: null };
 let _hiddenStatuslineRoles = null;
-
-function summarizeWorkerTags(tags, limit = 3) {
-  const cleanTags = [...new Set((Array.isArray(tags) ? tags : [])
-    .map((tag) => String(tag || '').trim())
+// Option A boot gate: the L1 usage/quota segment stays fully empty until THIS
+// process has captured its FIRST confirmed (current-process) OAuth usage
+// snapshot for THAT provider. The latch is monotonic PER PROVIDER — once a
+// provider arms it stays on for the process lifetime, so its segment turns on
+// exactly once (single clean transition) and then holds. This suppresses the
+// early gateway active-instance quota/balance (from another owning process,
+// which is NOT process-start guarded) and any stale/in-progress reads before
+// the first confirmed snapshot lands. Keyed per provider (not per global) so an
+// in-process route switch (openai-oauth → anthropic-oauth / grok-oauth) re-gates
+// 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();
+
+function isConfirmedCurrentProcessSnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== 'object') return false;
+  const cachedAt = num(snapshot.cachedAt);
+  return cachedAt > 0 && cachedAt >= STATUSLINE_PROCESS_STARTED_AT_MS;
+}
+
+function summarizeWorkerTags(workers, limit = 3) {
+  const cleanLabels = [...new Set((Array.isArray(workers) ? workers : [])
+    .map((worker) => String(worker?.tag || '').trim())
     .filter(Boolean))];
-  if (cleanTags.length <= limit) return cleanTags.join(', ');
-  return `${cleanTags.slice(0, limit).join(', ')}, +${cleanTags.length - limit}`;
+  if (cleanLabels.length <= limit) return cleanLabels.join(', ');
+  return `${cleanLabels.slice(0, limit).join(', ')}, +${cleanLabels.length - limit}`;
 }
 
-/** Create a mutable session-usage accumulator. */
-export function createSessionStats() {
-  return {
-    inputTokens: 0,
-    outputTokens: 0,
-    cachedTokens: 0,
-    cacheWriteTokens: 0,
-    promptTokens: 0,
-    latestInputTokens: 0,
-    latestOutputTokens: 0,
-    latestCachedTokens: 0,
-    latestCacheWriteTokens: 0,
-    latestPromptTokens: 0,
-    costUsd: 0,
-    turns: 0,
-  };
+function workerSpinnerFrame(now = Date.now()) {
+  const index = Math.floor(now / WORKER_SPINNER_FRAME_MS) % WORKER_SPINNER_FRAMES.length;
+  return WORKER_SPINNER_FRAMES[index] || WORKER_SPINNER_FRAMES[0];
 }
 
-/**
- * Fold one `onUsageDelta` event into the accumulator.
- * @param {object} stats — from createSessionStats()
- * @param {object} delta — { deltaInput, deltaOutput, deltaCachedRead, deltaCacheWrite, costUsd }
- */
-export function applyUsageDelta(stats, delta = {}) {
-  if (!stats || !delta) return stats;
-  stats.inputTokens += num(delta.deltaInput);
-  stats.outputTokens += num(delta.deltaOutput);
-  stats.cachedTokens += num(delta.deltaCachedRead);
-  stats.cacheWriteTokens += num(delta.deltaCacheWrite);
-  stats.promptTokens += num(delta.deltaPrompt);
-  stats.latestInputTokens = num(delta.deltaInput);
-  stats.latestOutputTokens = num(delta.deltaOutput);
-  stats.latestCachedTokens = num(delta.deltaCachedRead);
-  stats.latestCacheWriteTokens = num(delta.deltaCacheWrite);
-  stats.latestPromptTokens = num(delta.deltaPrompt);
-  // costUsd from the engine is cumulative-per-call; we sum the per-turn deltas.
-  stats.costUsd += num(delta.costUsd);
-  return stats;
+function l2SpinnerFrame(now = Date.now()) {
+  const index = Math.floor(now / L2_SPINNER_FRAME_MS) % WORKER_SPINNER_FRAMES.length;
+  return WORKER_SPINNER_FRAMES[index] || WORKER_SPINNER_FRAMES[0];
 }
 
 /**
- * Build the Claude-Code-shaped JSON the vendored renderer reads, from our REPL
+ * Build the status-line JSON the vendored renderer reads, from our REPL
  * state. Only the fields `renderStatusLine()` actually consumes are emitted:
  *   - display_name              → model name (L1)
  *   - effort.level              → effort string
@@ -125,22 +129,23 @@ function promptFootprintTokens(provider, stats) {
   return input;
 }
 
-function currentContextTokens(provider, stats) {
+function activeContextNumerator(provider, stats) {
   const s = stats || createSessionStats();
   const source = String(s.currentContextSource || '').toLowerCase();
-  const explicit = source === 'estimated'
-    ? 0
-    : num(s.currentContextTokens ?? s.contextTokens ?? s.latestPromptTokens);
-  if (explicit > 0) return explicit;
-  const latestInput = num(s.latestInputTokens);
-  const latestCacheRead = num(s.latestCachedTokens);
-  const latestCacheWrite = num(s.latestCacheWriteTokens);
-  if (latestInput || latestCacheRead || latestCacheWrite) {
-    return providerInputExcludesCache(provider)
-      ? latestInput + latestCacheRead + latestCacheWrite
-      : latestInput;
+  const estimated = num(s.currentEstimatedContextTokens);
+  if (estimated > 0) return estimated;
+  if (source === 'estimated') return 0;
+  if (source === 'last_api_request') {
+    const apiUsed = num(s.currentContextTokens);
+    if (apiUsed > 0) return apiUsed;
   }
-  return promptFootprintTokens(provider, s);
+  const explicit = num(s.currentContextTokens ?? s.contextTokens);
+  if (explicit > 0) return explicit;
+  return 0;
+}
+
+function currentContextTokens(provider, stats) {
+  return activeContextNumerator(provider, stats);
 }
 
 function modelContextWindow(provider, model, explicitContextWindow = 0) {
@@ -151,7 +156,61 @@ function modelContextWindow(provider, model, explicitContextWindow = 0) {
   return FALLBACK_CONTEXT_WINDOW;
 }
 
-function normalizeBridgeWorkerForStatusline(worker = {}) {
+function displayContextBoundary({
+  contextWindow = 0,
+  displayContextWindow = 0,
+  rawContextWindow = 0,
+  compactBoundaryTokens = 0,
+  autoCompactTokenLimit = 0,
+  compact = null,
+} = {}) {
+  const boundarySeed = num(compactBoundaryTokens) > 0
+    ? num(compactBoundaryTokens)
+    : (num(displayContextWindow) > 0 ? num(displayContextWindow) : num(contextWindow));
+  const boundary = compactBoundaryForStatus({
+    contextWindow: boundarySeed,
+    rawContextWindow: num(rawContextWindow),
+    autoCompactTokenLimit: num(autoCompactTokenLimit),
+  }, compact);
+  if (Number.isFinite(boundary) && boundary > 0) return boundary;
+  return modelContextWindow('', '', boundarySeed);
+}
+
+function resolveContextUsedPct({
+  provider = '',
+  model = '',
+  stats = null,
+  contextWindow = 0,
+  displayContextWindow = 0,
+  rawContextWindow = 0,
+  compactBoundaryTokens = 0,
+  autoCompactTokenLimit = 0,
+  gatewayStatus = null,
+} = {}) {
+  const numerator = activeContextNumerator(provider, stats);
+  const compact = gatewayStatus?.lastUsage?.compact || null;
+  const boundary = displayContextBoundary({
+    contextWindow,
+    displayContextWindow,
+    rawContextWindow,
+    compactBoundaryTokens,
+    autoCompactTokenLimit,
+    compact,
+  });
+  const gatewayRawPct = gatewayStatus?.contextUsedPct;
+  if (
+    gatewayStatus
+    && gatewayRawPct !== null
+    && gatewayRawPct !== undefined
+  ) {
+    const gatewayPct = Number(gatewayRawPct);
+    if (Number.isFinite(gatewayPct)) return gatewayPct;
+  }
+  if (boundary > 0) return (numerator / boundary) * 100;
+  return 0;
+}
+
+function normalizeAgentWorkerForStatusline(worker = {}) {
   const tag = String(worker.tag || worker.role || worker.name || '').trim();
   if (!tag) return null;
   const statusText = String(worker.stage || worker.status || '').toLowerCase();
@@ -159,6 +218,7 @@ function normalizeBridgeWorkerForStatusline(worker = {}) {
   return {
     tag,
     status,
+    startedAtMs: timeMs(worker.startedAt || worker.startTime || worker.createdAt),
     role: worker.role || null,
     stage: worker.stage || worker.status || null,
     sessionId: worker.sessionId || null,
@@ -167,7 +227,7 @@ function normalizeBridgeWorkerForStatusline(worker = {}) {
   };
 }
 
-function normalizeBridgeJobForStatusline(job = {}) {
+function normalizeAgentJobForStatusline(job = {}) {
   const statusText = String(job.status || job.stage || '').toLowerCase();
   if (!statusText) return null;
   const taskId = String(job.task_id || job.taskId || '').trim();
@@ -195,6 +255,7 @@ function normalizeBridgeJobForStatusline(job = {}) {
     tag,
     taskId,
     status: 'running',
+    startedAtMs,
     role: job.role || null,
     stage: job.stage || job.workerStatus || job.status || null,
     sessionId: job.sessionId || null,
@@ -203,15 +264,15 @@ function normalizeBridgeJobForStatusline(job = {}) {
   };
 }
 
-function bridgeStatuslinePayload(bridgeWorkers = [], bridgeJobs = []) {
+function agentStatuslinePayload(agentWorkers = [], agentJobs = []) {
   const byTag = new Map();
   const finishedJobs = [];
-  for (const worker of Array.isArray(bridgeWorkers) ? bridgeWorkers : []) {
-    const row = normalizeBridgeWorkerForStatusline(worker);
+  for (const worker of Array.isArray(agentWorkers) ? agentWorkers : []) {
+    const row = normalizeAgentWorkerForStatusline(worker);
     if (row) byTag.set(row.tag, row);
   }
-  for (const job of Array.isArray(bridgeJobs) ? bridgeJobs : []) {
-    const row = normalizeBridgeJobForStatusline(job);
+  for (const job of Array.isArray(agentJobs) ? agentJobs : []) {
+    const row = normalizeAgentJobForStatusline(job);
     if (!row) continue;
     if (row.status === 'finished') {
       finishedJobs.push(row);
@@ -246,23 +307,57 @@ function bridgeStatuslinePayload(bridgeWorkers = [], bridgeJobs = []) {
  * @param {string} [opts.sessionId]
  * @returns {Promise<string>}
  */
-export async function renderStatusline({ provider = '', model = '', effort = '', fast = false, cwd = '', stats, sessionId, contextWindow = 0, rawContextWindow = 0, bridgeWorkers = [], bridgeJobs = [], clientHostPid = process.pid } = {}) {
+export async function renderStatusline({
+  provider = '', model = '', effort = '', fast = false, cwd = '', stats, sessionId,
+  contextWindow = 0, displayContextWindow = 0, rawContextWindow = 0,
+  compactBoundaryTokens = 0, autoCompactTokenLimit = 0,
+  agentWorkers = [], agentJobs = [], activeTools = null, clientHostPid = process.pid,
+} = {}) {
+  const displayArgs = {
+    contextWindow, displayContextWindow, rawContextWindow, compactBoundaryTokens, autoCompactTokenLimit,
+  };
   try {
-    return renderNativeStatusline({ provider, model, effort, fast, cwd, stats, sessionId, contextWindow, rawContextWindow, bridgeWorkers, bridgeJobs, clientHostPid });
+    return renderNativeStatusline({
+      provider, model, effort, fast, cwd, stats, sessionId, agentWorkers, agentJobs, activeTools, clientHostPid,
+      ...displayArgs,
+    });
   } catch {
-    return fallbackLine({ provider, model, effort, fast, cwd, stats });
+    return fallbackLine({ provider, model, effort, fast, cwd, stats, ...displayArgs });
   }
 }
 
 // --- helpers -----------------------------------------------------------------
 
-function renderNativeStatusline({ provider = '', model = '', effort = '', fast = false, stats, sessionId, contextWindow = 0, rawContextWindow = 0, bridgeWorkers = [], bridgeJobs = [], clientHostPid = process.pid } = {}) {
+function renderNativeStatusline({
+  provider = '', model = '', effort = '', fast = false, stats, sessionId,
+  contextWindow = 0, displayContextWindow = 0, rawContextWindow = 0,
+  compactBoundaryTokens = 0, autoCompactTokenLimit = 0,
+  agentWorkers = [], agentJobs = [], activeTools = null, clientHostPid = process.pid,
+} = {}) {
   const cols = terminalColumns();
   const s = stats || createSessionStats();
-  const contextTokens = currentContextTokens(provider, s);
-  const resolvedContextWindow = modelContextWindow(provider, model, contextWindow);
-  const ctxPct = resolvedContextWindow > 0 ? clampPct((contextTokens / resolvedContextWindow) * 100) : 0;
-  const gatewayStatus = loadGatewayQuotaStatus({ provider, sessionId, activeContextTokens: contextTokens, clientHostPid });
+  const contextTokens = activeContextNumerator(provider, s);
+  const routeContextWindow = num(displayContextWindow) > 0 ? num(displayContextWindow) : num(contextWindow);
+  const gatewayStatus = loadGatewayQuotaStatus({
+    provider, model, effort, fast,
+    contextWindow: routeContextWindow,
+    rawContextWindow,
+    autoCompactTokenLimit,
+    sessionId,
+    activeContextTokens: contextTokens,
+    clientHostPid,
+  });
+  const ctxPct = resolveContextUsedPct({
+    provider,
+    model,
+    stats: s,
+    contextWindow,
+    displayContextWindow,
+    rawContextWindow,
+    compactBoundaryTokens,
+    autoCompactTokenLimit,
+    gatewayStatus,
+  });
 
   const sep = ` ${D}│${R} `;
   const l1Parts = [];
@@ -273,22 +368,63 @@ function renderNativeStatusline({ provider = '', model = '', effort = '', fast =
   addL1(formatModelSegment({ provider, model, effort, fast, cols }));
   addL1(formatContextSegment(ctxPct, cols));
 
-  const quotaStatus = gatewayStatus || fallbackQuotaStatus({ provider, model });
+  // Option A boot gate: for OAuth routes, render NOTHING for the usage/quota
+  // segment until this process has captured its first confirmed (current-
+  // process) OAuth usage snapshot. This suppresses the startup jitter where the
+  // gateway active-instance quota windows (not process-start guarded) and the
+  // boot-guarded OAuth cache windows would otherwise pop in/merge at different
+  // ticks. Model + context% always render (built above). Non-OAuth routes are
+  // unaffected. Once armed, the latch holds for the process lifetime so the
+  // segment turns on exactly once and then holds the last known value as today.
+  const usageReady = oauthUsageSegmentReady({ provider, model });
+  const quotaStatus = usageReady
+    ? mergeQuotaStatus(gatewayStatus, fallbackQuotaStatus({ provider, model }))
+    : null;
   const quotaSegments = quotaStatus
     ? formatGatewayLimitSegments(quotaStatus, { COLS: cols, D, R, GRN, YLW, RED, colourPct, epochMsToHHMM })
     : [];
   for (const seg of quotaSegments) addL1(seg);
 
-  const bridgePayload = bridgeStatuslinePayload([
-    ...(Array.isArray(bridgeWorkers) ? bridgeWorkers : []),
+  const agentPayload = agentStatuslinePayload([
+    ...(Array.isArray(agentWorkers) ? agentWorkers : []),
     ...activeHiddenRoleWorkers({ sessionId, clientHostPid }),
-  ], bridgeJobs);
-  const { maintenance, runningWorkers } = classifyBridgeWorkers(bridgePayload.workers);
+  ], agentJobs);
+  const { maintenance, runningWorkers } = classifyAgentWorkers(agentPayload.workers);
   if (maintenance.length) addL1(maintenance.join(' '));
-  addL1(formatShellJobsSegment({ clientHostPid }));
+  const shellStatus = shellJobsStatus({ clientHostPid });
 
+  const spinnerNow = Date.now();
+  const sp = l2SpinnerFrame(spinnerNow);
+  const spin = `${GRN}${sp}${R}`;
+  const elapsedSuffix = (label) => (label ? ` ${D}·${R} ${label}` : '');
+  // Segment order: Running Agents → Exploring → Searching → Running Shells.
   if (runningWorkers.length) {
-    addL2(`${GRN}●${R} ${B}${runningWorkers.length} Running${R} ${D}(${R}${B}${summarizeWorkerTags(runningWorkers)}${R}${D})${R}`);
+    const n = runningWorkers.length;
+    const label = `Running ${n} Agent${n === 1 ? '' : 's'}`;
+    const tagSummary = summarizeWorkerTags(runningWorkers);
+    const tags = tagSummary ? ` ${D}(${R}${B}${tagSummary}${R}${D})${R}` : '';
+    const oldestStart = runningWorkers.reduce((min, w) => {
+      const t = num(w?.startedAtMs);
+      return t > 0 && t < min ? t : min;
+    }, Infinity);
+    const elapsed = Number.isFinite(oldestStart) ? formatElapsed(Date.now() - oldestStart) : '';
+    addL2(`${spin} ${B}${label}${R}${tags}${elapsedSuffix(elapsed)}`);
+  }
+  const tools = activeTools && typeof activeTools === 'object' ? activeTools : {};
+  const exploreInfo = tools.explore || null;
+  const searchInfo = tools.search || null;
+  if (exploreInfo && num(exploreInfo.count) > 0) {
+    const elapsed = num(exploreInfo.startedAt) > 0 ? formatElapsed(Date.now() - num(exploreInfo.startedAt)) : '';
+    addL2(`${spin} ${B}Exploring${R}${elapsedSuffix(elapsed)}`);
+  }
+  if (searchInfo && num(searchInfo.count) > 0) {
+    const elapsed = num(searchInfo.startedAt) > 0 ? formatElapsed(Date.now() - num(searchInfo.startedAt)) : '';
+    addL2(`${spin} ${B}Searching${R}${elapsedSuffix(elapsed)}`);
+  }
+  if (shellStatus.count > 0) {
+    const n = shellStatus.count;
+    const label = `Running ${n} Shell${n === 1 ? '' : 's'}`;
+    addL2(`${spin} ${B}${label}${R}${elapsedSuffix(shellStatus.elapsedLabel)}`);
   }
   const l1 = l1Parts.join(sep) || 'mixdog';
   const l2 = l2Parts.join(sep);
@@ -304,9 +440,15 @@ function dataDir() {
   return process.env.MIXDOG_DATA_DIR || DEFAULT_STANDALONE_DATA_DIR;
 }
 
-function loadGatewayQuotaStatus({ provider, sessionId, activeContextTokens, clientHostPid } = {}) {
+function loadGatewayQuotaStatus({
+  provider, model, effort, fast, contextWindow, rawContextWindow, autoCompactTokenLimit = 0,
+  sessionId, activeContextTokens, clientHostPid,
+} = {}) {
   const key = [
     String(provider || ''),
+    String(model || ''),
+    String(effort || ''),
+    fast === true ? 'fast' : '',
     String(sessionId || ''),
     String(clientHostPid || ''),
     Math.floor((Number(activeContextTokens) || 0) / 1024),
@@ -317,7 +459,20 @@ function loadGatewayQuotaStatus({ provider, sessionId, activeContextTokens, clie
   }
   let value = null;
   try {
-    const status = loadGatewayStatus({ sessionId, activeContextTokens, clientHostPid });
+    const status = loadGatewayStatus({
+      sessionId,
+      activeContextTokens,
+      clientHostPid,
+      currentRoute: {
+        provider,
+        model,
+        effort,
+        fast,
+        contextWindow,
+        rawContextWindow,
+        autoCompactTokenLimit,
+      },
+    });
     if (!status) {
       _gatewayQuotaStatusCache = { key, at: now, value };
       return value;
@@ -328,6 +483,12 @@ function loadGatewayQuotaStatus({ provider, sessionId, activeContextTokens, clie
       _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;
@@ -336,6 +497,38 @@ function loadGatewayQuotaStatus({ provider, sessionId, activeContextTokens, clie
   return value;
 }
 
+// Option A boot gate. Returns true once THIS process has captured its first
+// confirmed (current-process) OAuth usage snapshot for THIS provider, and stays
+// true afterwards (monotonic, per-provider latch). Non-OAuth providers are never
+// gated (they have no async usage fetch on this path). Keyed on provider only:
+// the OAuth cache lookup is provider-keyed and snapshots are stored provider-
+// wide (oauth-usage.mjs writes a provider-only key + uses newestProviderSnapshot
+// fallback), so per-provider arming matches the data granularity — a model
+// switch within one provider shares the same provider-wide snapshot. The latch
+// reads the same cache `fallbackQuotaStatus()` consumes so it flips in lock-step
+// with the data actually becoming renderable — no extra delay, single clean
+// transition.
+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;
+  }
+  return false;
+}
+
 function fallbackQuotaStatus({ provider, model } = {}) {
   const normalizedProvider = String(provider || '').trim().toLowerCase();
   if (!normalizedProvider) return null;
@@ -358,9 +551,18 @@ function fallbackQuotaStatus({ provider, model } = {}) {
     }
   } else if (normalizedProvider.includes('oauth')) {
     try {
-      usageSnapshot = readCachedOAuthUsageSnapshot(routeInfo);
+      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) {
@@ -389,82 +591,53 @@ function providerKindForQuota(provider) {
   return 'api';
 }
 
-function formatModelSegment({ provider, model, effort, fast, cols }) {
-  const modelName = shortenModelName(displayModelName(provider, model), cols);
-  const bits = [`${CYN}◆${R} ${B}${modelName}${R}`];
-  if (effort) bits.push(`${B}${String(effort).toUpperCase()}${R}`);
-  if (fast === true) bits.push(`${B}FAST${R}`);
-  return bits.join(` ${D}·${R} `);
+function mergeQuotaStatus(primary, fallback) {
+  if (!primary) return fallback || null;
+  if (!fallback) return primary;
+  return {
+    ...fallback,
+    ...primary,
+    quotaWindows: Array.isArray(primary.quotaWindows) && primary.quotaWindows.length
+      ? primary.quotaWindows
+      : (fallback.quotaWindows || []),
+    balance: primary.balance || fallback.balance || null,
+    routeSpend: primary.routeSpend || fallback.routeSpend || null,
+    providerKind: primary.providerKind || fallback.providerKind || providerKindForQuota(primary.provider || fallback.provider),
+  };
 }
 
-function displayModelName(provider, model) {
+function formatModelSegment({ provider, model, effort, fast, cols }) {
   const raw = String(model || '').trim();
   const meta = getModelMetadataSync(raw, provider) || {};
-  const display = String(meta.displayName || meta.display || meta.name || '').trim();
-  return display || canonicalModelDisplay(raw, provider) || raw || 'model';
-}
-
-function titleModelPart(part) {
-  const text = String(part || '').trim();
-  if (!text) return '';
-  const lower = text.toLowerCase();
-  if (lower === 'gpt') return 'GPT';
-  if (lower === 'api') return 'API';
-  if (lower === 'v4') return 'V4';
-  return lower.charAt(0).toUpperCase() + lower.slice(1);
-}
-
-function canonicalModelDisplay(model, provider) {
-  const raw = String(model || '').trim().replace(/-\d{4}-\d{2}-\d{2}$/, '');
-  if (!raw) return '';
-
-  const gpt = raw.match(/^gpt-(\d+(?:\.\d+)?)(?:-(.+))?$/i);
-  if (gpt) {
-    const suffix = gpt[2]
-      ? '-' + gpt[2].split('-').map(titleModelPart).filter(Boolean).join('-')
-      : '';
-    return `GPT-${gpt[1]}${suffix}`;
-  }
-
-  const codex = raw.match(/^codex-(.+)$/i);
-  if (codex) {
-    return `Codex ${codex[1].split('-').map(titleModelPart).filter(Boolean).join(' ')}`;
-  }
-
-  const deepseek = raw.match(/^deepseek-(.+)$/i);
-  if (deepseek) {
-    return `DeepSeek ${deepseek[1].split('-').map(titleModelPart).filter(Boolean).join(' ')}`;
-  }
-
-  const grok = raw.match(/^grok-(.+)$/i);
-  if (grok) {
-    return `Grok ${grok[1].split('-').map(titleModelPart).filter(Boolean).join(' ')}`;
-  }
-
-  const claude = raw.match(/^claude-(opus|sonnet|haiku)-(.+)$/i);
-  if (claude) {
-    return `Claude ${titleModelPart(claude[1])} ${claude[2].replace(/-/g, '.')}`;
-  }
-
-  return raw;
+  const displayHint = String(meta.displayName || meta.display || meta.name || '').trim();
+  const modelName = shortenModelName(displayModelName(raw, provider, displayHint), cols);
+  const bits = [`${B}${modelName}${R}`];
+  if (effort) bits.push(`${B}${String(effort).toUpperCase()}${R}`);
+  if (fast === true) bits.push(`${B}FAST${R}`);
+  return bits.join(` ${D}·${R} `);
 }
 
-function shortenModelName(name, cols) {
-  let out = String(name || 'model').replace(/\s*\(1M context\)/i, ' (1M)');
-  out = out.replace(/^Claude\s+/i, '');
-  out = out.replace(/^OpenAI\s+/i, '');
-  if (cols < 80 && out.length > 18) return out.slice(0, 17) + '…';
-  if (cols < 120 && out.length > 28) return out.slice(0, 27) + '…';
-  return out;
+/** Display label for context % (clamped to 100); raw pct still drives bar/color thresholds. */
+export function contextPctDisplayLabel(ctxPct) {
+  const pct = Number(ctxPct);
+  if (!Number.isFinite(pct) || pct <= 0) return '0';
+  if (pct > 0 && pct < 1) return String(Math.round(pct * 10) / 10);
+  return String(Math.floor(Math.min(100, pct)));
 }
 
 function formatContextSegment(ctxPct, cols) {
-  const pct = clampPct(ctxPct);
+  const raw = Number(ctxPct);
+  const pct = Number.isFinite(raw) ? Math.max(0, raw) : 0;
+  const barPct = clampPct(pct);
   const fill = pct >= 90 ? RED : pct >= 70 ? YLW : GRN;
-  const label = pct > 0 && pct < 1 ? String(Math.round(pct * 10) / 10) : String(Math.floor(pct));
-  const cells = cols >= 120 ? 14 : cols >= 80 ? 8 : 0;
+  const label = contextPctDisplayLabel(pct);
+  // Keep a full-width bar wherever there is room for one. Below 80 cols the bar
+  // is dropped (label-only) so the footer never overflows a narrow terminal;
+  // at 80+ it stays a fixed 14 cells instead of shrinking to 8, which read as
+  // too small/cramped on mid-width terminals.
+  const cells = cols >= 80 ? 14 : 0;
   if (!cells) return `${fill}${label}%${R}`;
-  const bar = makeBar(pct, cells);
+  const bar = makeBar(barPct, cells);
   const filled = bar.replace(/░/g, '');
   const empty = bar.replace(/▓/g, '');
   return `${fill}${filled}${R}${D}${empty}${R} ${label}%`;
@@ -490,7 +663,7 @@ function epochMsToHHMM(ms) {
   return d.toLocaleTimeString('sv-SE', { hour: '2-digit', minute: '2-digit', hour12: false });
 }
 
-function classifyBridgeWorkers(workers = []) {
+function classifyAgentWorkers(workers = []) {
   const maintenance = [];
   const runningWorkers = [];
   const seenMaintenance = new Set();
@@ -508,7 +681,7 @@ function classifyBridgeWorkers(workers = []) {
     }
     if (w.status !== 'idle' && !seenRunning.has(tag)) {
       seenRunning.add(tag);
-      runningWorkers.push(tag);
+      runningWorkers.push(w);
     }
   }
   return { maintenance, runningWorkers };
@@ -559,7 +732,7 @@ function activeHiddenRoleWorkers({ sessionId = '', clientHostPid = 0 } = {}) {
       const status = String(session?.status || stage || '').trim().toLowerCase();
       if (!isActiveHiddenStatus(stage || status)) continue;
       rows.push({
-        tag: String(session?.bridgeTag || `${role}:${id || rows.length}`).trim(),
+        tag: String(session?.agentTag || `${role}:${id || rows.length}`).trim(),
         role,
         status: 'running',
         stage: stage || status || 'running',
@@ -594,14 +767,15 @@ function maintenanceLabel(tag) {
   }
 }
 
-function formatShellJobsSegment({ clientHostPid } = {}) {
+function shellJobsStatus({ clientHostPid } = {}) {
   const ownerPid = positiveInt(clientHostPid);
-  if (!ownerPid) return '';
+  const empty = { count: 0, elapsedLabel: '' };
+  if (!ownerPid) return empty;
   const now = Date.now();
   if (_shellJobsSegmentCache.ownerPid === ownerPid && now - _shellJobsSegmentCache.at < SHELL_JOBS_SEGMENT_CACHE_MS) {
-    return _shellJobsSegmentCache.value;
+    return _shellJobsSegmentCache.value || empty;
   }
-  let value = '';
+  let value = empty;
   try {
     const dir = join(dataDir(), 'shell-jobs');
     if (!existsSync(dir)) {
@@ -642,10 +816,9 @@ function formatShellJobsSegment({ clientHostPid } = {}) {
       return value;
     }
     const elapsedLabel = Number.isFinite(oldestMs) ? formatElapsed(Date.now() - oldestMs) : '';
-    const elapsed = elapsedLabel ? ` ${elapsedLabel}` : '';
-    value = `${GREY}⚙ shell:${count}${elapsed}${R}`;
+    value = { count, elapsedLabel };
   } catch {
-    value = '';
+    value = empty;
   }
   _shellJobsSegmentCache = { ownerPid, at: now, value };
   return value;
@@ -682,29 +855,64 @@ function positiveInt(value) {
   return Number.isInteger(n) && n > 0 ? n : 0;
 }
 
+// Byte-identical replica of src/tui/time-format.mjs formatDuration() with
+// DEFAULT options (no mostSignificantOnly / hideTrailingZeros), wrapped to drop
+// sub-1s like formatElapsed there. Output shape: '' (<1s), `Xs`, `Xm Ys`,
+// `Xh Ym Zs`, `Xd Yh Zm`. statusline.mjs is a standalone UI module that should
+// not depend on the React/ink TUI tree, so the algorithm is replicated rather
+// than imported. Used for ALL L2 elapsed (Agents/Explore/Search/Shell).
 function formatElapsed(ms) {
-  const secs = Math.max(0, Math.floor(Number(ms || 0) / 1000));
-  if (secs < 1) return '';
-  if (secs < 60) return `${secs}s`;
-  const mins = Math.floor(secs / 60);
-  if (mins < 60) return `${mins}m`;
-  return `${Math.floor(mins / 60)}h`;
+  if (!Number.isFinite(Number(ms))) return '';
+  const value = Math.max(0, Number(ms) || 0);
+  if (value < 60_000) {
+    if (value < 1_000) return '';
+    return `${Math.floor(value / 1000)}s`;
+  }
+  const days = Math.floor(value / 86_400_000);
+  const hours = Math.floor((value % 86_400_000) / 3_600_000);
+  const minutes = Math.floor((value % 3_600_000) / 60_000);
+  const seconds = Math.floor((value % 60_000) / 1000);
+  if (days > 0) return `${days}d ${hours}h ${minutes}m`;
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
 }
 
 /** Minimal one-line footer used when the vendored renderer is unavailable. */
-function fallbackLine({ provider = '', model = '', effort = '', fast = false, cwd = '', stats } = {}) {
+export function fallbackStatusline({
+  provider = '', model = '', effort = '', fast = false, cwd = '', stats, contextWindow = 0,
+  displayContextWindow = 0, rawContextWindow = 0, compactBoundaryTokens = 0, autoCompactTokenLimit = 0,
+} = {}) {
+  return fallbackLine({
+    provider, model, effort, fast, cwd, stats, contextWindow, displayContextWindow,
+    rawContextWindow, compactBoundaryTokens, autoCompactTokenLimit,
+  });
+}
+
+function fallbackLine({
+  provider = '', model = '', effort = '', fast = false, cwd = '', stats, contextWindow = 0,
+  displayContextWindow = 0, rawContextWindow = 0, compactBoundaryTokens = 0, autoCompactTokenLimit = 0,
+} = {}) {
   const s = stats || createSessionStats();
-  const sep = statusSubtle(' | ');
-  const flags = [effort ? String(effort).toUpperCase() : '', fast === true ? 'FAST' : ''].filter(Boolean).join(' | ');
-  const id = statusAccent(`${provider}/${model}${flags ? ` | ${flags}` : ''}`);
-  const tokens = statusText(
-    `${fmt(s.inputTokens)} in / ${fmt(s.outputTokens)} out` +
-      (s.cachedTokens ? ` / ${fmt(s.cachedTokens)} read` : '') +
-      (s.cacheWriteTokens ? ` / ${fmt(s.cacheWriteTokens)} write` : ''),
-  );
-  const cost = s.costUsd > 0 ? green('$' + s.costUsd.toFixed(4)) : statusSubtle('$0.0000');
-  const dir = bold(basename(cwd || process.cwd()) || cwd);
-  return statusSubtle('> ') + [id, tokens, cost, dir].join(sep);
+  const cols = terminalColumns();
+  const ctxPct = resolveContextUsedPct({
+    provider,
+    model,
+    stats: s,
+    contextWindow,
+    displayContextWindow,
+    rawContextWindow,
+    compactBoundaryTokens,
+    autoCompactTokenLimit,
+    gatewayStatus: null,
+  });
+  const sep = ` ${D}│${R} `;
+  const parts = [
+    formatModelSegment({ provider, model, effort, fast, cols }),
+    formatContextSegment(ctxPct, cols),
+  ].filter(Boolean);
+  if (!parts.length) return statusSubtle('> mixdog');
+  return parts.join(sep);
 }
 
 function num(v) {