@ekkos/cli 1.3.2 → 1.3.5

package/dist/commands/dashboard.js

@@ -71,11 +71,12 @@ const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12
 // ── Pricing ──
 // Pricing per MTok from https://platform.claude.com/docs/en/about-claude/pricing
 const MODEL_PRICING = {
-    'claude-opus-4-6': { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.50 },
-    'claude-opus-4-5-20250620': { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.50 },
+    'claude-opus-4-6': { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.50 },
+    'claude-opus-4-5-20250620': { input: 5, output: 25, cacheWrite: 6.25, cacheRead: 0.50 },
+    'claude-sonnet-4-6': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
     'claude-sonnet-4-5-20250929': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
     'claude-sonnet-4-5-20250514': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
-    'claude-haiku-4-5-20251001': { input: 0.80, output: 4, cacheWrite: 1.00, cacheRead: 0.08 },
+    'claude-haiku-4-5-20251001': { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.10 },
 };
 function getModelPricing(modelId) {
     if (MODEL_PRICING[modelId])
@@ -150,6 +151,21 @@ function parseJsonlFile(jsonlPath, sessionName) {
             }
             if (entry.type === 'assistant' && entry.message?.usage) {
                 const msgId = entry.message.id;
+                const internalTurnType = typeof entry.message._ekkos_internal_turn === 'string'
+                    ? entry.message._ekkos_internal_turn
+                    : '';
+                const compactionSource = typeof entry.message._ekkos_compaction_source === 'string'
+                    ? entry.message._ekkos_compaction_source
+                    : '';
+                const isSyntheticCompactionMessage = typeof msgId === 'string' && msgId.startsWith('msg_ekkos_');
+                const isExplicitlyNonBillable = entry.message._ekkos_billable === false;
+                const isInternalCompactionTurn = internalTurnType === 'compaction' ||
+                    isSyntheticCompactionMessage ||
+                    compactionSource.length > 0 ||
+                    isExplicitlyNonBillable;
+                if (isInternalCompactionTurn) {
+                    continue;
+                }
                 const isNew = msgId && !turnsByMsgId.has(msgId);
                 const usage = entry.message.usage;
                 model = entry.message.model || model;
@@ -199,6 +215,7 @@ function parseJsonlFile(jsonlPath, sessionName) {
                 const turnData = {
                     turn: turnNum,
                     contextPct,
+                    input: inputTokens,
                     cacheRead: cacheReadTokens,
                     cacheCreate: cacheCreationTokens,
                     output: outputTokens,
@@ -225,6 +242,7 @@ function parseJsonlFile(jsonlPath, sessionName) {
     // Build ordered turns array from the Map (last-entry-wins dedup)
     const turns = msgIdOrder.map(id => turnsByMsgId.get(id));
     const totalCost = turns.reduce((s, t) => s + t.cost, 0);
+    const totalInput = turns.reduce((s, t) => s + t.input, 0);
     const totalCacheRead = turns.reduce((s, t) => s + t.cacheRead, 0);
     const totalCacheCreate = turns.reduce((s, t) => s + t.cacheCreate, 0);
     const totalOutput = turns.reduce((s, t) => s + t.output, 0);
@@ -247,7 +265,7 @@ function parseJsonlFile(jsonlPath, sessionName) {
     // Get current context tokens from the last turn's raw data
     const lastTurn = turns.length > 0 ? turns[turns.length - 1] : null;
     const currentContextTokens = lastTurn
-        ? lastTurn.cacheRead + lastTurn.cacheCreate + (lastTurn.output || 0)
+        ? lastTurn.input + lastTurn.cacheRead + lastTurn.cacheCreate
         : 0;
     const modelContextSize = getModelCtxSize(model);
     return {
@@ -255,7 +273,8 @@ function parseJsonlFile(jsonlPath, sessionName) {
         model,
         turnCount: turns.length,
         totalCost,
-        totalTokens: totalCacheRead + totalCacheCreate + totalOutput,
+        totalTokens: totalInput + totalCacheRead + totalCacheCreate + totalOutput,
+        totalInput,
         totalCacheRead,
         totalCacheCreate,
         totalOutput,
@@ -343,8 +362,9 @@ function resolveJsonlPath(sessionName, createdAfterMs) {
             return jsonlPath;
     }
     // 2) Active-session fallback.
-    // IMPORTANT: never resolve "pending" sessions to "latest file in project" because
-    // that can cross-bind concurrent sessions to the same dashboard transcript.
+    // Prefer exact sessionId lookup when available, otherwise fall through to
+    // findLatestJsonl with the createdAfterMs timestamp constraint (prevents
+    // cross-binding stale sessions from different runs).
     const activeSessionsPath = path.join(os.homedir(), '.ekkos', 'active-sessions.json');
     if (fs.existsSync(activeSessionsPath)) {
         try {
@@ -352,11 +372,14 @@ function resolveJsonlPath(sessionName, createdAfterMs) {
             const match = sessions.find((s) => s.sessionName === sessionName);
             if (match?.projectPath) {
                 if (isStableSessionId(match.sessionId)) {
-                    return findJsonlBySessionId(match.projectPath, match.sessionId);
-                }
-                if (isPendingSessionId(match.sessionId)) {
-                    return null;
+                    // Prefer exact sessionId lookup, but if that file does not exist yet
+                    // (or sessionId was pre-generated), fall back to latest project JSONL.
+                    const bySessionId = findJsonlBySessionId(match.projectPath, match.sessionId);
+                    if (bySessionId)
+                        return bySessionId;
                 }
+                // Pending or unknown sessionId — fall through to timestamp-constrained
+                // latest-file lookup. The createdAfterMs guard prevents stale cross-binds.
                 return findLatestJsonl(match.projectPath, createdAfterMs);
             }
         }
@@ -475,13 +498,11 @@ async function waitForNewSession() {
         for (const s of sessions) {
             const startedMs = new Date(s.startedAt).getTime();
             if (startedMs >= launchTs - 2000) {
-                if (!isStableSessionId(s.sessionId)) {
-                    // Wait for stable session identity; pending IDs can collide across concurrent runs.
-                    continue;
-                }
                 candidateName = s.sessionName;
-                // Try exact by sessionId first, then constrained name resolution.
-                let jsonlPath = s.projectPath ? findJsonlBySessionId(s.projectPath, s.sessionId) : null;
+                // Try exact sessionId lookup first, then fall back to name-based resolution.
+                let jsonlPath = (isStableSessionId(s.sessionId) && s.projectPath)
+                    ? findJsonlBySessionId(s.projectPath, s.sessionId)
+                    : null;
                 if (!jsonlPath)
                     jsonlPath = resolveJsonlPath(s.sessionName, launchTs);
                 // Return immediately with session name — JSONL may still be null
@@ -603,7 +624,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         mouse: false, // Disable ALL mouse capture (allows terminal text selection)
         grabKeys: false, // Don't grab keyboard input from other panes
         sendFocus: false, // Don't send focus events (breaks paste)
-        ignoreLocked: ['C-c', 'C-q'], // Capture Ctrl+C and Ctrl+Q for quit
+        ignoreLocked: ['C-c', 'C-q', 'f7'], // Capture Ctrl+C, Ctrl+Q for quit, F7 for hard refresh
         input: ttyInput, // Use /dev/tty for input (isolated from stdout pipe)
         output: ttyOutput, // Use /dev/tty for output (isolated from stdout pipe)
         forceUnicode: true, // Better text rendering
@@ -621,24 +642,34 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         // Override alternateBuffer to do nothing (tmux pane isolation)
         screen.program.alternateBuffer = () => { };
         screen.program.normalBuffer = () => { };
-        // Don't enter raw mode — let the OS handle it (tmux pane isolation)
+        // Override blessed's setRawMode so it doesn't toggle raw mode on its own
+        // schedule, but manually enable raw mode on the ttyInput so that function
+        // key escape sequences (F7, etc.) are delivered properly.
         if (screen.program.setRawMode) {
             screen.program.setRawMode = (enabled) => {
-                // Silently ignore raw mode requests
+                // Silently ignore blessed's raw mode requests — we manage it ourselves
                 return enabled;
             };
         }
+        // Manually enable raw mode on the dedicated /dev/tty stream.
+        // This is safe because ttyInput is a separate fd from stdout/stdin,
+        // so it only affects this tmux pane. Without raw mode, multi-byte
+        // escape sequences for function keys (F7 = \x1b[18~) are not delivered.
+        if (ttyInput.setRawMode) {
+            ttyInput.setRawMode(true);
+        }
     }
     // ── Zero-gap calculated layout ──
     //
     // Every widget has exact top + height computed from screen.height.
     // Fixed heights for header/context/usage/footer, remaining split
-    // between chart (40%) and table (60%). No percentages = no gaps.
+    // between chart (~25-34%) and table (~66-75%) so turns get more room.
+    // No percentages = no gaps.
     //
     //  header:   3 rows (session stats + animated logo)
     //  context:  5 rows (progress bar + cost breakdown + cache stats)
-    //  chart:    40% of remaining (token usage graph)
-    //  table:    60% of remaining (turn-by-turn breakdown)
+    //  chart:    ~25-34% of remaining (token usage graph)
+    //  table:    ~66-75% of remaining (turn-by-turn breakdown)
     //  usage:    3 rows (Anthropic rate limit window)
     //  footer:   3 rows (totals + routing + keybindings)
     const LOGO_CHARS = ['e', 'k', 'k', 'O', 'S', '_'];
@@ -684,11 +715,20 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     const FOOTER_H = 3;
     const CLAWD_W = 16; // Width reserved for Clawd mascot in context box
     const FIXED_H = HEADER_H + CONTEXT_H + USAGE_H + FOOTER_H; // 15
+    function resolveChartRatio(height) {
+        if (height >= 62)
+            return 0.25;
+        if (height >= 48)
+            return 0.28;
+        if (height >= 36)
+            return 0.30;
+        return 0.34;
+    }
     function calcLayout() {
-        const H = screen.height;
-        const remaining = Math.max(6, H - FIXED_H);
-        const chartH = Math.max(8, Math.floor(remaining * 0.40));
-        const tableH = Math.max(4, remaining - chartH);
+        const H = Math.max(24, screen.height || 24);
+        const remaining = Math.max(8, H - FIXED_H);
+        const chartH = Math.max(6, Math.floor(remaining * resolveChartRatio(H)));
+        const tableH = Math.max(5, remaining - chartH);
         return {
             header: { top: 0, height: HEADER_H },
             context: { top: HEADER_H, height: CONTEXT_H },
@@ -981,8 +1021,8 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             footerBox.setLabel(` ${sessionName} `);
             footerBox.setContent(` ${timerStr}{green-fg}Ready{/green-fg}` +
                 (inTmux
-                    ? `  {gray-fg}Ctrl+Q quit{/gray-fg}`
-                    : `  {gray-fg}? help  q quit  r refresh{/gray-fg}`));
+                    ? `  {gray-fg}Ctrl+Q quit  F7 redraw{/gray-fg}`
+                    : `  {gray-fg}? help  q quit  r refresh  F7 redraw{/gray-fg}`));
         }
         catch (err) {
             dlog(`Pre-turn render: ${err.message}`);
@@ -1068,19 +1108,24 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             const barWidth = Math.max(10, contextInnerWidth - 4 - CLAWD_W);
             const filled = Math.round((ctxPct / 100) * barWidth);
             const bar = `{${ctxColor}-fg}${'█'.repeat(filled)}{/${ctxColor}-fg}${'░'.repeat(barWidth - filled)}`;
-            // Cost breakdown (use actual model pricing, not hardcoded)
-            const p = getModelPricing(data.model);
-            const rd = (data.totalCacheRead / 1000000) * p.cacheRead;
-            const wr = (data.totalCacheCreate / 1000000) * p.cacheWrite;
-            const ou = (data.totalOutput / 1000000) * p.output;
+            // Cost breakdown by actual routed model per turn.
+            const breakdown = data.turns.reduce((acc, t) => {
+                const pricing = getModelPricing(t.routedModel || t.model);
+                acc.input += (t.input / 1000000) * pricing.input;
+                acc.read += (t.cacheRead / 1000000) * pricing.cacheRead;
+                acc.write += (t.cacheCreate / 1000000) * pricing.cacheWrite;
+                acc.output += (t.output / 1000000) * pricing.output;
+                return acc;
+            }, { input: 0, read: 0, write: 0, output: 0 });
             // Cache stats
             const hitColor = data.cacheHitRate >= 80 ? 'green' : data.cacheHitRate >= 50 ? 'yellow' : 'red';
             const cappedMax = Math.min(data.maxContextPct, 100);
             contextBox.setContent(` ${bar}\n` +
                 ` {${ctxColor}-fg}${ctxPct.toFixed(0)}%{/${ctxColor}-fg} ${tokensK}K/${maxK}K` +
-                `  {green-fg}Read{/green-fg} $${rd.toFixed(2)}` +
-                `  {yellow-fg}Write{/yellow-fg} $${wr.toFixed(2)}` +
-                `  {cyan-fg}Output{/cyan-fg} $${ou.toFixed(2)}\n` +
+                `  {white-fg}Input{/white-fg} $${breakdown.input.toFixed(2)}` +
+                `  {green-fg}Read{/green-fg} $${breakdown.read.toFixed(2)}` +
+                `  {yellow-fg}Write{/yellow-fg} $${breakdown.write.toFixed(2)}` +
+                `  {cyan-fg}Output{/cyan-fg} $${breakdown.output.toFixed(2)}\n` +
                 ` {${hitColor}-fg}${data.cacheHitRate.toFixed(0)}% cache{/${hitColor}-fg}` +
                 `  peak:${cappedMax.toFixed(0)}%` +
                 `  avg:$${data.avgCostPerTurn.toFixed(2)}/t` +
@@ -1142,7 +1187,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             // Always show all 8 columns: Turn, Time, Model, Context, Cache Rd, Cache Wr, Output, Cost
             // Shrink flex columns to fit narrow panes instead of dropping them.
             const colNum = 4;
-            const colTime = 8; // "HH:MM:SS" or "H:MM AM"
+            const colTime = 8; // "HH:MM:SS"
             const colM = 7;
             const colCtx = 7;
             const colCost = 8;
@@ -1172,16 +1217,16 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             // Format turn timestamp to short time string
             const fmtTime = (iso) => {
                 if (!iso)
-                    return '--:--';
+                    return '--:--:--';
                 try {
                     const d = new Date(iso);
-                    const h = d.getHours();
+                    const h = d.getHours().toString().padStart(2, '0');
                     const m = d.getMinutes().toString().padStart(2, '0');
                     const s = d.getSeconds().toString().padStart(2, '0');
                     return `${h}:${m}:${s}`;
                 }
                 catch {
-                    return '--:--';
+                    return '--:--:--';
                 }
             };
             header = `{bold}${pad('Turn', colNum)}${div}${pad('Time', colTime)}${div}${pad('Model', colM)}${div}${pad('Context', colCtx)}${div}${rpad('Cache Rd', rdW)}${div}${rpad('Cache Wr', wrW)}${div}${rpad('Output', outW)}${div}${rpad('Cost', colCost)}{/bold}`;
@@ -1220,7 +1265,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         if (!d)
             return;
         try {
-            const totalTokensM = ((d.totalCacheRead + d.totalCacheCreate + d.totalOutput) / 1000000).toFixed(2);
+            const totalTokensM = ((d.totalInput + d.totalCacheRead + d.totalCacheCreate + d.totalOutput) / 1000000).toFixed(2);
             const totalSavings = d.turns.reduce((s, t) => s + t.savings, 0);
             // Model routing breakdown (uses routedModel for actual model counts)
             const opusCount = d.turns.filter(t => t.routedModel.includes('opus')).length;
@@ -1245,8 +1290,8 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                 `  R[A:${d.replayAppliedCount} SZ:${d.replaySkippedSizeCount} ST:${d.replaySkipStoreCount}]` +
                 savingsStr +
                 (inTmux
-                    ? `  {gray-fg}Ctrl+Q quit{/gray-fg}`
-                    : `  {gray-fg}? help  q quit  r refresh{/gray-fg}`));
+                    ? `  {gray-fg}Ctrl+Q quit  F7 redraw{/gray-fg}`
+                    : `  {gray-fg}? help  q quit  r refresh  F7 redraw{/gray-fg}`));
         }
         catch (err) {
             dlog(`Footer: ${err.message}`);
@@ -1259,7 +1304,250 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                 dlog(`Render: ${err.message}`);
             }
     }
-    // ── Usage window update — calls Anthropic's OAuth usage API ──
+    const USAGE_CACHE_PATH = path.join(state_js_1.EKKOS_DIR, 'dashboard-usage-cache.json');
+    const USAGE_STATE_PATH = path.join(state_js_1.EKKOS_DIR, 'dashboard-usage-state.json');
+    const USAGE_LOCK_PATH = path.join(state_js_1.EKKOS_DIR, 'dashboard-usage.lock');
+    const PROFILE_CACHE_PATH = path.join(state_js_1.EKKOS_DIR, 'dashboard-profile-cache.json');
+    const USAGE_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+    const USAGE_FALLBACK_BACKOFF_MS = 3 * 60 * 1000;
+    const USAGE_MAX_BACKOFF_MS = 10 * 60 * 1000;
+    const USAGE_ERROR_BACKOFF_MS = 60 * 1000;
+    const USAGE_LOCK_STALE_MS = 30 * 1000;
+    const PROFILE_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+    const PROFILE_REFRESH_MS = 5 * 60 * 1000;
+    function resolveOauthApiBases() {
+        // Match Claude Code behavior: base URL may be customized via env/proxy.
+        const rawBase = (process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com').trim();
+        const base = rawBase.replace(/\/+$/, '');
+        const normalizedBase = base.endsWith('/v1') ? base.slice(0, -3) : base;
+        const bases = [];
+        // ekkOS proxy path doesn't expose OAuth utility endpoints.
+        if (!normalizedBase.includes('/proxy/')) {
+            bases.push(normalizedBase);
+        }
+        bases.push('https://api.anthropic.com');
+        return Array.from(new Set(bases));
+    }
+    const OAUTH_API_BASES = resolveOauthApiBases();
+    const USAGE_API_URLS = OAUTH_API_BASES.map(base => `${base}/api/oauth/usage`);
+    const PROFILE_API_URLS = OAUTH_API_BASES.map(base => `${base}/api/oauth/profile`);
+    function parseRetryAfterMs(retryAfter) {
+        if (!retryAfter)
+            return 0;
+        const retrySeconds = Number.parseInt(retryAfter, 10);
+        if (Number.isFinite(retrySeconds) && retrySeconds > 0) {
+            return retrySeconds * 1000;
+        }
+        const retryAtMs = Date.parse(retryAfter);
+        if (!Number.isNaN(retryAtMs)) {
+            return Math.max(0, retryAtMs - Date.now());
+        }
+        return 0;
+    }
+    function loadUsageCache(maxAgeMs = USAGE_CACHE_MAX_AGE_MS) {
+        try {
+            if (!fs.existsSync(USAGE_CACHE_PATH))
+                return null;
+            const snapshot = JSON.parse(fs.readFileSync(USAGE_CACHE_PATH, 'utf-8'));
+            if (!snapshot?.usage || typeof snapshot.fetchedAt !== 'number')
+                return null;
+            if ((Date.now() - snapshot.fetchedAt) > maxAgeMs)
+                return null;
+            return snapshot.usage;
+        }
+        catch {
+            return null;
+        }
+    }
+    function saveUsageCache(usage) {
+        try {
+            fs.mkdirSync(path.dirname(USAGE_CACHE_PATH), { recursive: true });
+            const snapshot = { fetchedAt: Date.now(), usage };
+            fs.writeFileSync(USAGE_CACHE_PATH, JSON.stringify(snapshot));
+        }
+        catch {
+            // Ignore cache write errors
+        }
+    }
+    function loadProfileCache(maxAgeMs = PROFILE_CACHE_MAX_AGE_MS) {
+        try {
+            if (!fs.existsSync(PROFILE_CACHE_PATH))
+                return null;
+            const snapshot = JSON.parse(fs.readFileSync(PROFILE_CACHE_PATH, 'utf-8'));
+            if (!snapshot?.profile || typeof snapshot.fetchedAt !== 'number')
+                return null;
+            if ((Date.now() - snapshot.fetchedAt) > maxAgeMs)
+                return null;
+            return snapshot;
+        }
+        catch {
+            return null;
+        }
+    }
+    function saveProfileCache(profile) {
+        try {
+            fs.mkdirSync(path.dirname(PROFILE_CACHE_PATH), { recursive: true });
+            const snapshot = { fetchedAt: Date.now(), profile };
+            fs.writeFileSync(PROFILE_CACHE_PATH, JSON.stringify(snapshot));
+        }
+        catch {
+            // Ignore cache write errors
+        }
+    }
+    function loadUsageState() {
+        try {
+            if (!fs.existsSync(USAGE_STATE_PATH)) {
+                return { updatedAt: 0, backoffUntil: 0, failureCount: 0, lastStatus: null };
+            }
+            const raw = JSON.parse(fs.readFileSync(USAGE_STATE_PATH, 'utf-8'));
+            return {
+                updatedAt: Number.isFinite(raw.updatedAt) ? Number(raw.updatedAt) : 0,
+                backoffUntil: Number.isFinite(raw.backoffUntil) ? Number(raw.backoffUntil) : 0,
+                failureCount: Number.isFinite(raw.failureCount) ? Math.max(0, Number(raw.failureCount)) : 0,
+                lastStatus: typeof raw.lastStatus === 'number' ? raw.lastStatus : null,
+            };
+        }
+        catch {
+            return { updatedAt: 0, backoffUntil: 0, failureCount: 0, lastStatus: null };
+        }
+    }
+    function saveUsageState(state) {
+        try {
+            fs.mkdirSync(path.dirname(USAGE_STATE_PATH), { recursive: true });
+            fs.writeFileSync(USAGE_STATE_PATH, JSON.stringify(state));
+        }
+        catch {
+            // Ignore state write errors
+        }
+    }
+    function tryAcquireUsageLock() {
+        const now = Date.now();
+        const createLock = () => {
+            try {
+                const fd = fs.openSync(USAGE_LOCK_PATH, 'wx');
+                fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, createdAt: now }));
+                return () => {
+                    try {
+                        fs.closeSync(fd);
+                    }
+                    catch { }
+                    try {
+                        fs.unlinkSync(USAGE_LOCK_PATH);
+                    }
+                    catch { }
+                };
+            }
+            catch (err) {
+                if (err?.code !== 'EEXIST')
+                    dlog(`Usage lock error: ${err?.message ?? err}`);
+                return null;
+            }
+        };
+        let release = createLock();
+        if (release)
+            return release;
+        // Recover from stale lock after crash.
+        try {
+            const st = fs.statSync(USAGE_LOCK_PATH);
+            if ((now - st.mtimeMs) > USAGE_LOCK_STALE_MS) {
+                fs.unlinkSync(USAGE_LOCK_PATH);
+                release = createLock();
+                if (release)
+                    return release;
+            }
+        }
+        catch { }
+        return null;
+    }
+    function extractClaudeOauthAccessToken(rawBlob) {
+        const raw = (rawBlob || '').trim();
+        if (!raw)
+            return null;
+        const candidates = new Set([raw]);
+        if (/^[0-9a-fA-F]+$/.test(raw) && raw.length % 2 === 0) {
+            const decoded = Buffer.from(raw, 'hex').toString('utf8');
+            candidates.add(decoded);
+            // Keychain blobs can include control chars around JSON fragments.
+            candidates.add(decoded.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '').trim());
+        }
+        for (const candidate of candidates) {
+            if (!candidate)
+                continue;
+            try {
+                const parsed = JSON.parse(candidate);
+                const token = parsed?.claudeAiOauth?.accessToken;
+                if (typeof token === 'string' && token.length > 0)
+                    return token;
+            }
+            catch { }
+            try {
+                const parsed = JSON.parse(`{${candidate}}`);
+                const token = parsed?.claudeAiOauth?.accessToken;
+                if (typeof token === 'string' && token.length > 0)
+                    return token;
+            }
+            catch { }
+            const oauthMatch = candidate.match(/"claudeAiOauth"\s*:\s*(\{[\s\S]*?\})/);
+            if (oauthMatch) {
+                try {
+                    const oauth = JSON.parse(oauthMatch[1]);
+                    const token = oauth?.accessToken;
+                    if (typeof token === 'string' && token.length > 0)
+                        return token;
+                }
+                catch { }
+                const tokenMatch = oauthMatch[1].match(/"accessToken"\s*:\s*"([^"]+)"/);
+                if (tokenMatch?.[1])
+                    return tokenMatch[1];
+            }
+        }
+        return null;
+    }
+    let cachedOauthToken = null;
+    let cachedOauthTokenAt = 0;
+    const OAUTH_TOKEN_CACHE_MS = 5 * 60 * 1000;
+    async function readKeychainToken() {
+        return await new Promise((resolve) => {
+            try {
+                const { execFile } = require('child_process');
+                execFile('security', ['find-generic-password', '-s', 'Claude Code-credentials', '-w'], { encoding: 'utf-8', timeout: 5000 }, (err, stdout) => {
+                    if (err)
+                        return resolve(null);
+                    resolve(extractClaudeOauthAccessToken((stdout || '').trim()));
+                });
+            }
+            catch {
+                resolve(null);
+            }
+        });
+    }
+    async function getClaudeOauthAccessToken() {
+        // Short-lived cache avoids repeated keychain/process calls on every poll.
+        if (cachedOauthToken && (Date.now() - cachedOauthTokenAt) < OAUTH_TOKEN_CACHE_MS) {
+            return cachedOauthToken;
+        }
+        let token = null;
+        // File fallback first (fast, non-blocking from process perspective).
+        try {
+            const credsPath = path.join(os.homedir(), '.claude', '.credentials.json');
+            if (fs.existsSync(credsPath)) {
+                const credsBlob = fs.readFileSync(credsPath, 'utf-8');
+                token = extractClaudeOauthAccessToken(credsBlob);
+            }
+        }
+        catch {
+            // ignore
+        }
+        // macOS keychain fallback if file lookup fails.
+        if (!token && process.platform === 'darwin') {
+            token = await readKeychainToken();
+        }
+        if (token) {
+            cachedOauthToken = token;
+            cachedOauthTokenAt = Date.now();
+        }
+        return token;
+    }
     /**
      * Fetch real usage limits from Anthropic's OAuth usage endpoint.
      * Returns { five_hour: { utilization, resets_at }, seven_day: { utilization, resets_at } }
@@ -1267,48 +1555,194 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
      */
     async function fetchAnthropicUsage() {
         try {
-            let token = null;
-            if (process.platform === 'darwin') {
-                const { execSync } = require('child_process');
-                const credsJson = execSync('security find-generic-password -s "Claude Code-credentials" -w', { encoding: 'utf-8', timeout: 5000 }).trim();
-                token = JSON.parse(credsJson)?.claudeAiOauth?.accessToken ?? null;
-            }
-            else if (process.platform === 'win32') {
-                // Windows: Claude Code stores credentials in ~/.claude/.credentials.json
-                const credsPath = path.join(os.homedir(), '.claude', '.credentials.json');
-                if (fs.existsSync(credsPath)) {
-                    const creds = JSON.parse(fs.readFileSync(credsPath, 'utf-8'));
-                    token = creds?.claudeAiOauth?.accessToken ?? null;
+            const token = await getClaudeOauthAccessToken();
+            if (!token)
+                return null;
+            const requestHeaders = {
+                'Authorization': `Bearer ${token}`,
+                'anthropic-beta': 'oauth-2025-04-20',
+                'Content-Type': 'application/json',
+                'User-Agent': 'ekkos-cli/dashboard',
+            };
+            for (let i = 0; i < USAGE_API_URLS.length; i++) {
+                const usageUrl = USAGE_API_URLS[i];
+                const resp = await fetch(usageUrl, { headers: requestHeaders });
+                if (resp.ok) {
+                    usageBackoffUntil = 0; // Reset backoff on success
+                    usageFailureCount = 0;
+                    saveUsageState({
+                        updatedAt: Date.now(),
+                        backoffUntil: 0,
+                        failureCount: 0,
+                        lastStatus: resp.status,
+                    });
+                    return await resp.json();
+                }
+                const canFallbackToNextBase = i < (USAGE_API_URLS.length - 1)
+                    && (resp.status === 404 || resp.status === 405);
+                if (canFallbackToNextBase) {
+                    dlog(`Usage API ${resp.status} via ${usageUrl} — trying direct fallback`);
+                    continue;
+                }
+                // Respect retry-after when present, but enforce a minimum backoff on 429.
+                // The endpoint can return retry-after=0 while still being throttled.
+                const retryAfterRaw = resp.headers.get('retry-after');
+                const retryAfterMs = parseRetryAfterMs(retryAfterRaw);
+                if (resp.status === 429) {
+                    usageFailureCount = Math.min(16, usageFailureCount + 1);
+                }
+                else {
+                    usageFailureCount = 0;
                 }
+                const exponentialMs = resp.status === 429
+                    ? Math.min(USAGE_MAX_BACKOFF_MS, USAGE_FALLBACK_BACKOFF_MS * Math.pow(2, Math.max(0, usageFailureCount - 1)))
+                    : 0;
+                const backoffMs = Math.max(retryAfterMs, exponentialMs);
+                if (backoffMs > 0) {
+                    usageBackoffUntil = Date.now() + backoffMs;
+                    saveUsageState({
+                        updatedAt: Date.now(),
+                        backoffUntil: usageBackoffUntil,
+                        failureCount: usageFailureCount,
+                        lastStatus: resp.status,
+                    });
+                }
+                dlog(`Usage API ${resp.status}, retry-after ${retryAfterRaw ?? 'none'}, backoff ${Math.round(backoffMs / 1000)}s`);
+                if (resp.status === 401 || resp.status === 403) {
+                    cachedOauthToken = null;
+                    cachedOauthTokenAt = 0;
+                }
+                return null;
             }
+            return null;
+        }
+        catch {
+            usageFailureCount = Math.min(16, usageFailureCount + 1);
+            const backoffMs = Math.min(USAGE_MAX_BACKOFF_MS, USAGE_ERROR_BACKOFF_MS * Math.max(1, usageFailureCount));
+            usageBackoffUntil = Date.now() + backoffMs;
+            saveUsageState({
+                updatedAt: Date.now(),
+                backoffUntil: usageBackoffUntil,
+                failureCount: usageFailureCount,
+                lastStatus: null,
+            });
+            return null;
+        }
+    }
+    async function fetchAnthropicProfile() {
+        try {
+            const token = await getClaudeOauthAccessToken();
             if (!token)
                 return null;
-            const resp = await fetch('https://api.anthropic.com/api/oauth/usage', {
-                headers: {
-                    'Authorization': `Bearer ${token}`,
-                    'anthropic-beta': 'oauth-2025-04-20',
-                    'Content-Type': 'application/json',
-                    'User-Agent': 'ekkos-cli/dashboard',
-                },
-            });
-            if (!resp.ok)
+            const requestHeaders = {
+                'Authorization': `Bearer ${token}`,
+                'anthropic-beta': 'oauth-2025-04-20',
+                'Content-Type': 'application/json',
+                'User-Agent': 'ekkos-cli/dashboard',
+            };
+            for (let i = 0; i < PROFILE_API_URLS.length; i++) {
+                const profileUrl = PROFILE_API_URLS[i];
+                const resp = await fetch(profileUrl, { headers: requestHeaders });
+                if (resp.ok) {
+                    return await resp.json();
+                }
+                const canFallbackToNextBase = i < (PROFILE_API_URLS.length - 1)
+                    && (resp.status === 404 || resp.status === 405);
+                if (canFallbackToNextBase) {
+                    dlog(`Profile API ${resp.status} via ${profileUrl} — trying direct fallback`);
+                    continue;
+                }
+                if (resp.status === 401 || resp.status === 403) {
+                    cachedOauthToken = null;
+                    cachedOauthTokenAt = 0;
+                }
                 return null;
-            return await resp.json();
+            }
+            return null;
         }
         catch {
             return null;
         }
     }
+    // Backoff timestamp — skip fetch until this time
+    let usageBackoffUntil = 0;
+    let usageFailureCount = 0;
+    let usageFetchInFlight = false;
+    let profileFetchInFlight = false;
+    const usageStateAtStartup = loadUsageState();
+    if (usageStateAtStartup.backoffUntil > Date.now()) {
+        usageBackoffUntil = usageStateAtStartup.backoffUntil;
+    }
+    usageFailureCount = Math.max(usageFailureCount, usageStateAtStartup.failureCount);
     // Cache last fetched usage data so the countdown can tick every second
-    let cachedUsage = null;
-    // Fetch fresh usage data from API (called every 15s)
+    let cachedUsage = loadUsageCache();
+    const profileSnapshotAtStartup = loadProfileCache();
+    let cachedProfile = profileSnapshotAtStartup?.profile ?? null;
+    let lastProfileFetchAt = profileSnapshotAtStartup?.fetchedAt ?? 0;
+    async function fetchAndCacheProfile(force = false) {
+        if (profileFetchInFlight)
+            return;
+        if (!force && (Date.now() - lastProfileFetchAt) < PROFILE_REFRESH_MS)
+            return;
+        profileFetchInFlight = true;
+        try {
+            const profile = await fetchAnthropicProfile();
+            if (profile) {
+                cachedProfile = profile;
+                lastProfileFetchAt = Date.now();
+                saveProfileCache(profile);
+            }
+        }
+        catch (err) {
+            dlog(`Profile fetch: ${err.message}`);
+        }
+        finally {
+            profileFetchInFlight = false;
+        }
+    }
+    // Fetch fresh usage data from API (called on interval)
     async function fetchAndCacheUsage() {
+        if (usageFetchInFlight)
+            return;
+        // Respect shared state across dashboard processes.
+        const sharedState = loadUsageState();
+        if (sharedState.backoffUntil > usageBackoffUntil) {
+            usageBackoffUntil = sharedState.backoffUntil;
+        }
+        if (sharedState.failureCount > usageFailureCount) {
+            usageFailureCount = sharedState.failureCount;
+        }
+        // Respect backoff from retry-after header
+        if (usageBackoffUntil && Date.now() < usageBackoffUntil) {
+            dlog(`Usage fetch skipped — backoff until ${new Date(usageBackoffUntil).toLocaleTimeString()}`);
+            await fetchAndCacheProfile();
+            renderWindowBox();
+            return;
+        }
+        const releaseLock = tryAcquireUsageLock();
+        if (!releaseLock) {
+            dlog('Usage fetch skipped — another dashboard is fetching');
+            await fetchAndCacheProfile();
+            renderWindowBox();
+            return;
+        }
+        usageFetchInFlight = true;
         try {
-            cachedUsage = await fetchAnthropicUsage();
+            const fresh = await fetchAnthropicUsage();
+            // Only update cache if we got data — preserve stale data on 429/errors
+            if (fresh) {
+                cachedUsage = fresh;
+                saveUsageCache(fresh);
+            }
+            await fetchAndCacheProfile(!cachedProfile);
         }
         catch (err) {
             dlog(`Window fetch: ${err.message}`);
         }
+        finally {
+            usageFetchInFlight = false;
+            releaseLock();
+        }
         renderWindowBox();
     }
     // Render countdown from cached data (called every 1s)
@@ -1317,6 +1751,26 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             const usage = cachedUsage;
             let line1 = ' {gray-fg}No usage data{/gray-fg}';
             let line2 = '';
+            if (!usage && usageBackoffUntil && Date.now() < usageBackoffUntil) {
+                const remainSec = Math.max(0, Math.round((usageBackoffUntil - Date.now()) / 1000));
+                const mins = Math.floor(remainSec / 60);
+                const secs = String(remainSec % 60).padStart(2, '0');
+                line1 = ` {yellow-fg}Usage API rate-limited{/yellow-fg}  retry in {cyan-fg}${mins}:${secs}{/cyan-fg}`;
+            }
+            if (!usage && cachedProfile) {
+                const plan = cachedProfile.organization?.organization_type
+                    ? String(cachedProfile.organization.organization_type).replace(/_/g, ' ')
+                    : (cachedProfile.account?.has_claude_max
+                        ? 'claude max'
+                        : (cachedProfile.account?.has_claude_pro ? 'claude pro' : 'oauth'));
+                const tier = cachedProfile.organization?.rate_limit_tier ?? 'unknown';
+                const status = cachedProfile.organization?.subscription_status ?? 'unknown';
+                const extraUsage = cachedProfile.organization?.has_extra_usage_enabled
+                    ? '  {green-fg}extra usage on{/green-fg}'
+                    : '';
+                line2 =
+                    ` {bold}Plan:{/bold} ${plan}  {bold}Tier:{/bold} ${tier}  {bold}Sub:{/bold} ${status}${extraUsage}`;
+            }
             // Fixed-width column helpers for aligned rendering:
             //  " 5h:   26% used  ⏱ 1h16m12s  resets Feb 27, 2026, 12:00 AM"
             //  " Week:  91% used  ⏱ 0h16m12s  resets Thu, Feb 26, 2026, 11:00 PM"
@@ -1380,10 +1834,86 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     }
     // Legacy wrapper for backward compat
     async function updateWindowBox() { await fetchAndCacheUsage(); }
+    // Full dashboard redraw used by F7 and manual refresh recovery paths.
+    let hardRedrawInFlight = false;
+    let lastHardRedrawAt = 0;
+    const HARD_REDRAW_DEBOUNCE_MS = 200;
+    async function hardRedraw(source) {
+        const now = Date.now();
+        if (hardRedrawInFlight)
+            return;
+        if (now - lastHardRedrawAt < HARD_REDRAW_DEBOUNCE_MS)
+            return;
+        hardRedrawInFlight = true;
+        lastHardRedrawAt = now;
+        try {
+            dlog(`Hard redraw (${source})`);
+            try {
+                screen.realloc?.();
+            }
+            catch { }
+            try {
+                screen.program?.clear?.();
+            }
+            catch { }
+            lastLayoutW = 0;
+            lastLayoutH = 0;
+            ensureLayoutSynced();
+            // Force fresh parse + repaint even when JSONL size has not changed.
+            lastFileSize = 0;
+            updateDashboard();
+            await updateWindowBox();
+            if (lastChartSeries) {
+                try {
+                    tokenChart.setData(lastChartSeries);
+                }
+                catch { }
+            }
+            try {
+                screen.render();
+            }
+            catch { }
+        }
+        catch (err) {
+            dlog(`Hard redraw failed (${source}): ${err.message}`);
+        }
+        finally {
+            hardRedrawInFlight = false;
+        }
+    }
+    // F7 escape-sequence fallback for terminals/tmux states where blessed key names
+    // are not emitted reliably. Supports plain and modifier variants.
+    const F7_ESCAPE_RE = /\x1b\[18(?:;\d+)?~/;
+    let detachRawF7Listener = null;
+    if (ttyInput && typeof ttyInput.on === 'function') {
+        const onRawInput = (chunk) => {
+            const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+            if (!F7_ESCAPE_RE.test(text))
+                return;
+            void hardRedraw('f7-escape');
+        };
+        ttyInput.on('data', onRawInput);
+        detachRawF7Listener = () => {
+            try {
+                if (typeof ttyInput.off === 'function')
+                    ttyInput.off('data', onRawInput);
+                else if (typeof ttyInput.removeListener === 'function')
+                    ttyInput.removeListener('data', onRawInput);
+            }
+            catch { }
+        };
+    }
     // ── Handle terminal resize ──
     // Recalculate all widget positions from new screen.height
     screen.on('resize', () => {
         try {
+            // Force blessed to pick up new terminal dimensions before layout check
+            try {
+                screen.realloc?.();
+            }
+            catch { }
+            lastLayoutW = 0;
+            lastLayoutH = 0;
             ensureLayoutSynced();
             if (lastData) {
                 updateDashboard();
@@ -1407,7 +1937,8 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     // KEYBOARD SHORTCUTS - Only capture when dashboard pane has focus
     // In tmux split mode, this prevents capturing keys from Claude Code pane
     // ══════════════════════════════════════════════════════════════════════════
-    screen.key(['C-c', 'C-q'], () => {
+    function shutdownDashboard() {
+        detachRawF7Listener?.();
         clearInterval(pollInterval);
         clearInterval(windowPollInterval);
         clearInterval(tickInterval);
@@ -1415,21 +1946,22 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         clearInterval(fortuneInterval);
         screen.destroy();
         process.exit(0);
+    }
+    screen.key(['C-c', 'C-q'], () => {
+        shutdownDashboard();
+    });
+    // F7 — Hard refresh / redraw (works in both tmux and standalone mode)
+    // Forces a full screen realloc + layout recalculation to fix corruption
+    // from rapid terminal resizing. Session data is preserved.
+    screen.key(['f7', 'F7'], () => {
+        void hardRedraw('f7-key');
     });
     if (!inTmux) {
         screen.key(['q'], () => {
-            clearInterval(pollInterval);
-            clearInterval(windowPollInterval);
-            clearInterval(tickInterval);
-            clearInterval(headerAnimInterval);
-            clearInterval(fortuneInterval);
-            screen.destroy();
-            process.exit(0);
+            shutdownDashboard();
         });
         screen.key(['r'], () => {
-            lastFileSize = 0;
-            updateDashboard();
-            updateWindowBox();
+            void hardRedraw('r-key');
         });
     }
     // ══════════════════════════════════════════════════════════════════════════
@@ -1473,7 +2005,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                 top: 'center',
                 left: 'center',
                 width: 50,
-                height: 16,
+                height: 17,
                 content: ('{bold}Navigation{/bold}\n' +
                     '  ↑/k/j/↓    Scroll line\n' +
                     '  PgUp/u     Scroll page up\n' +
@@ -1483,6 +2015,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                     '\n' +
                     '{bold}Controls{/bold}\n' +
                     '  r          Refresh now\n' +
+                    '  F7         Hard redraw (fixes corruption)\n' +
                     '  q/Ctrl+Q   Quit\n' +
                     '\n' +
                     '{gray-fg}Press any key to close{/gray-fg}'),
@@ -1528,9 +2061,10 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         fortuneText = activeFortunes[fortuneIdx];
         renderHeader();
     }, 30000);
-    const windowPollInterval = setInterval(fetchAndCacheUsage, 15000); // fetch fresh data every 15s
+    const windowPollInterval = setInterval(fetchAndCacheUsage, 60000); // fetch fresh data every 60s
     // Single 1s tick for both countdown + session timer (one screen.render instead of three)
     const tickInterval = setInterval(() => {
+        ensureLayoutSynced();
         renderWindowBox(true);
         if (sessionStartMs)
             renderFooter(null, true);