@ekkos/cli 1.3.1 → 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,
@@ -322,6 +341,17 @@ function displaySessionName(rawName) {
         return rawName;
     return resolveSessionAlias(rawName) || (0, state_js_1.uuidToWords)(rawName);
 }
+function isStableSessionId(sessionId) {
+    return typeof sessionId === 'string' && UUID_REGEX.test(sessionId);
+}
+function isPendingSessionId(sessionId) {
+    if (typeof sessionId !== 'string')
+        return true;
+    const normalized = sessionId.trim().toLowerCase();
+    if (!normalized)
+        return true;
+    return normalized === 'pending' || normalized === '_pending' || normalized.startsWith('_pending-');
+}
 // ── Resolve session to JSONL path ──
 function resolveJsonlPath(sessionName, createdAfterMs) {
     // 1) Try standard resolution (works when sessionId is a real UUID)
@@ -331,13 +361,25 @@ function resolveJsonlPath(sessionName, createdAfterMs) {
         if (fs.existsSync(jsonlPath))
             return jsonlPath;
     }
-    // 2) Fallback: active session has "pending" UUID
+    // 2) Active-session fallback.
+    // 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 {
             const sessions = JSON.parse(fs.readFileSync(activeSessionsPath, 'utf-8'));
             const match = sessions.find((s) => s.sessionName === sessionName);
             if (match?.projectPath) {
+                if (isStableSessionId(match.sessionId)) {
+                    // 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);
             }
         }
@@ -353,12 +395,15 @@ function resolveJsonlPath(sessionName, createdAfterMs) {
 function findLatestJsonl(projectPath, createdAfterMs) {
     // Claude encodes project paths by replacing separators with '-'.
     // On Windows, ':' is also illegal in directory names so it gets replaced too.
+    // Claude also replaces underscores and other non-alphanumeric chars with '-'.
     // Try all plausible encodings since Claude's exact scheme varies by platform.
     const candidateEncodings = new Set([
         projectPath.replace(/[\\/]/g, '-'), // C:-Users-name  (backslash only)
         projectPath.replace(/[:\\/]/g, '-'), // C--Users-name  (colon + backslash)
         '-' + projectPath.replace(/[:\\/]/g, '-'), // -C--Users-name (leading separator)
         projectPath.replace(/\//g, '-'), // macOS: /Users/name → -Users-name
+        projectPath.replace(/[^a-zA-Z0-9]/g, '-'), // Replace ALL non-alphanumeric (handles _)
+        `-${projectPath.replace(/^[\\/]+/, '').replace(/[^a-zA-Z0-9]/g, '-')}`, // Leading - variant
     ]);
     const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
     for (const encoded of Array.from(candidateEncodings)) {
@@ -390,6 +435,8 @@ function findJsonlBySessionId(projectPath, sessionId) {
         projectPath.replace(/[:\\/]/g, '-'),
         '-' + projectPath.replace(/[:\\/]/g, '-'),
         projectPath.replace(/\//g, '-'),
+        projectPath.replace(/[^a-zA-Z0-9]/g, '-'),
+        `-${projectPath.replace(/^[\\/]+/, '').replace(/[^a-zA-Z0-9]/g, '-')}`,
     ]);
     const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
     for (const encoded of Array.from(candidateEncodings)) {
@@ -436,8 +483,8 @@ async function waitForNewSession() {
                 const hint = JSON.parse(fs.readFileSync(hintPath, 'utf-8'));
                 if (hint.ts >= launchTs - 5000 && hint.sessionName && hint.projectPath) {
                     candidateName = hint.sessionName;
-                    const jsonlPath = findJsonlBySessionId(hint.projectPath, hint.sessionId || '')
-                        || findLatestJsonl(hint.projectPath, launchTs)
+                    const hintSessionId = typeof hint.sessionId === 'string' ? hint.sessionId : '';
+                    const jsonlPath = (isStableSessionId(hintSessionId) ? findJsonlBySessionId(hint.projectPath, hintSessionId) : null)
                         || resolveJsonlPath(hint.sessionName, launchTs);
                     // Return immediately — JSONL may be null; dashboard will lazy-resolve
                     console.log(chalk_1.default.green(`  Found session (hook hint): ${hint.sessionName}`));
@@ -452,25 +499,21 @@ async function waitForNewSession() {
             const startedMs = new Date(s.startedAt).getTime();
             if (startedMs >= launchTs - 2000) {
                 candidateName = s.sessionName;
-                // Try to resolve JSONL immediately (may succeed if Claude already created it)
-                let jsonlPath = resolveJsonlPath(s.sessionName, launchTs);
-                if (!jsonlPath) {
-                    const allPaths = new Set(sessions.filter(x => x.sessionName === s.sessionName && x.projectPath)
-                        .map(x => x.projectPath));
-                    for (const pp of Array.from(allPaths)) {
-                        jsonlPath = findLatestJsonl(pp, launchTs);
-                        if (jsonlPath)
-                            break;
-                    }
-                }
+                // 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
                 // (Claude Code hasn't created it yet). Dashboard will lazy-resolve.
-                console.log(chalk_1.default.green(`  Found session: ${s.sessionName}`));
+                console.log(chalk_1.default.green(`  Found session: ${s.sessionName}${jsonlPath ? '' : ' (awaiting transcript)'}`));
                 return { sessionName: s.sessionName, jsonlPath, launchCwd: s.projectPath || launchCwd, launchTs };
             }
         }
-        // Fallback: use launch CWD to find any new JSONL
-        if (launchCwd) {
+        // Fallback: use launch CWD to find any new JSONL only if we don't even
+        // have a candidate session name yet.
+        if (launchCwd && !candidateName) {
             const latestJsonl = findLatestJsonl(launchCwd, launchTs);
             if (latestJsonl) {
                 const name = candidateName || path.basename(latestJsonl, '.jsonl');
@@ -478,8 +521,9 @@ async function waitForNewSession() {
                 return { sessionName: name, jsonlPath: latestJsonl, launchCwd, launchTs };
             }
         }
-        // Broad fallback: scan ALL project directories for any new JSONL
-        {
+        // Broad fallback: scan ALL project directories for any new JSONL only
+        // when no candidate name is known.
+        if (!candidateName) {
             const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
             try {
                 if (fs.existsSync(projectsRoot)) {
@@ -580,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'], // Only capture Ctrl+C 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
@@ -598,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', '_'];
@@ -661,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 },
@@ -678,6 +741,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     let layout = calcLayout();
     let lastFileSize = 0;
     let lastData = null;
+    let sessionStartMs = launchTs || null; // epoch ms of session start, for live timer
     let lastChartSeries = null;
     let lastScrollPerc = 0; // Preserve scroll position across updates
     let fortuneIdx = Math.floor(Math.random() * activeFortunes.length);
@@ -945,14 +1009,36 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         }
         catch { }
     }
+    function renderPreTurnState() {
+        try {
+            contextBox.setContent(` {green-fg}Session active{/green-fg}  {gray-fg}${sessionName}{/gray-fg}\n` +
+                ` Token and cost metrics appear after the first assistant response.`);
+            turnBox.setContent(`{bold}Turns{/bold}\n` +
+                `{gray-fg}—{/gray-fg}`);
+            const timerStr = sessionStartMs
+                ? `{cyan-fg}${formatElapsed(sessionStartMs)}{/cyan-fg}  `
+                : '';
+            footerBox.setLabel(` ${sessionName} `);
+            footerBox.setContent(` ${timerStr}{green-fg}Ready{/green-fg}` +
+                (inTmux
+                    ? `  {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}`);
+        }
+    }
     function updateDashboard() {
         ensureLayoutSynced();
         // ── Lazy JSONL resolution ──────────────────────────────────────────────
         // Dashboard may launch before Claude Code creates the JSONL file.
         // Keep trying to find it on each poll tick.
         if (!jsonlPath || !fs.existsSync(jsonlPath)) {
+            const shouldUseCwdFallback = initialSessionName === 'initializing'
+                || initialSessionName === 'session'
+                || UUID_REGEX.test(initialSessionName);
             const resolved = resolveJsonlPath(initialSessionName, launchTs)
-                || (launchCwd ? findLatestJsonl(launchCwd, launchTs) : null);
+                || (shouldUseCwdFallback && launchCwd ? findLatestJsonl(launchCwd, launchTs) : null);
             if (resolved) {
                 jsonlPath = resolved;
                 dlog(`Lazy-resolved JSONL: ${jsonlPath}`);
@@ -960,6 +1046,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             else {
                 // Still no JSONL — render the header/footer so the dashboard isn't blank
                 renderHeader();
+                renderPreTurnState();
                 try {
                     screen.render();
                 }
@@ -994,6 +1081,9 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             lastFileSize = stat.size;
             data = parseJsonlFile(jsonlPath, sessionName);
             lastData = data;
+            if (!sessionStartMs && data.startedAt) {
+                sessionStartMs = new Date(data.startedAt).getTime();
+            }
         }
         catch (err) {
             dlog(`Parse error: ${err.message}`);
@@ -1018,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` +
@@ -1092,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;
@@ -1122,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}`;
@@ -1162,13 +1257,20 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             dlog(`Table: ${err.message}`);
         }
         // ── Session Totals (footer) ──
+        renderFooter(data);
+    }
+    /** Render footer bar — called from updateDashboard and the 1s timer tick */
+    function renderFooter(data, skipRender = false) {
+        const d = data || lastData;
+        if (!d)
+            return;
         try {
-            const totalTokensM = ((data.totalCacheRead + data.totalCacheCreate + data.totalOutput) / 1000000).toFixed(2);
-            const totalSavings = data.turns.reduce((s, t) => s + t.savings, 0);
+            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 = data.turns.filter(t => t.routedModel.includes('opus')).length;
-            const sonnetCount = data.turns.filter(t => t.routedModel.includes('sonnet')).length;
-            const haikuCount = data.turns.filter(t => t.routedModel.includes('haiku')).length;
+            const opusCount = d.turns.filter(t => t.routedModel.includes('opus')).length;
+            const sonnetCount = d.turns.filter(t => t.routedModel.includes('sonnet')).length;
+            const haikuCount = d.turns.filter(t => t.routedModel.includes('haiku')).length;
             const routingParts = [`{magenta-fg}O{/magenta-fg}:${opusCount}`];
             if (sonnetCount > 0)
                 routingParts.push(`{blue-fg}S{/blue-fg}:${sonnetCount}`);
@@ -1177,27 +1279,275 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             const savingsStr = totalSavings > 0
                 ? `  {green-fg}saved $${totalSavings.toFixed(2)}{/green-fg}`
                 : '';
+            const timerStr = sessionStartMs
+                ? `{cyan-fg}${formatElapsed(sessionStartMs)}{/cyan-fg}  `
+                : '';
             footerBox.setLabel(` ${sessionName} `);
-            footerBox.setContent(` {green-fg}$${data.totalCost.toFixed(2)}{/green-fg}` +
+            footerBox.setContent(` ${timerStr}` +
+                `{green-fg}$${d.totalCost.toFixed(2)}{/green-fg}` +
                 `  ${totalTokensM}M` +
                 `  ${routingStr}` +
-                `  R[A:${data.replayAppliedCount} SZ:${data.replaySkippedSizeCount} ST:${data.replaySkipStoreCount}]` +
+                `  R[A:${d.replayAppliedCount} SZ:${d.replaySkippedSizeCount} ST:${d.replaySkipStoreCount}]` +
                 savingsStr +
                 (inTmux
-                    ? `  {gray-fg}Ctrl+C 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}`);
         }
+        if (!skipRender)
+            try {
+                screen.render();
+            }
+            catch (err) {
+                dlog(`Render: ${err.message}`);
+            }
+    }
+    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 {
-            screen.render();
+            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 (err) {
-            dlog(`Render: ${err.message}`);
+        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;
     }
-    // ── Usage window update — calls Anthropic's OAuth usage API ──
     /**
      * Fetch real usage limits from Anthropic's OAuth usage endpoint.
      * Returns { five_hour: { utilization, resets_at }, seven_day: { utilization, resets_at } }
@@ -1205,56 +1555,231 @@ 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)
-    function renderWindowBox() {
+    function renderWindowBox(skipRender = false) {
         try {
             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"
+            //  ^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+            //  label  pct col    countdown    reset time
+            const COL_LABEL = 6; // "5h:   " or "Week: " — padded to same width
+            const COL_PCT = 9; // "100% used" max
+            const COL_CD = 11; // "10h00m00s " max
+            const rpad = (s, w) => s.length >= w ? s : s + ' '.repeat(w - s.length);
             // ── 5h Window (from Anthropic OAuth API) ──
             if (usage?.five_hour) {
                 const pct = usage.five_hour.utilization;
@@ -1266,12 +1791,13 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                 const rS = remainSec % 60;
                 const pctColor = pct < 50 ? 'green' : pct < 80 ? 'yellow' : 'red';
                 const countdown = `${rH}h${rM.toString().padStart(2, '0')}m${rS.toString().padStart(2, '0')}s`;
+                const pctStr = `${pct.toFixed(0)}% used`;
                 const resetDate = new Date(resetAt);
                 const resetTime = resetDate.toLocaleString('en-US', { month: 'short', day: 'numeric', year: 'numeric', hour: 'numeric', minute: '2-digit' });
-                line1 = ` {bold}5h:{/bold}` +
-                    ` {${pctColor}-fg}${pct.toFixed(0)}% used{/${pctColor}-fg}` +
-                    `  {${pctColor}-fg}⏱ ${countdown}{/${pctColor}-fg}` +
-                    `  resets ${resetTime}`;
+                line1 = ` {bold}${rpad('5h:', COL_LABEL)}{/bold}` +
+                    `{${pctColor}-fg}${rpad(pctStr, COL_PCT)}{/${pctColor}-fg}` +
+                    `  {${pctColor}-fg}⏱ ${rpad(countdown, COL_CD)}{/${pctColor}-fg}` +
+                    `resets ${resetTime}`;
             }
             // ── Weekly (from Anthropic OAuth API) ──
             if (usage?.seven_day) {
@@ -1287,11 +1813,12 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                 const countdown = rD > 0
                     ? `${rD}d${rH}h${rM.toString().padStart(2, '0')}m`
                     : `${rH}h${rM.toString().padStart(2, '0')}m${rS.toString().padStart(2, '0')}s`;
+                const pctStr = `${pct.toFixed(0)}% used`;
                 const resetTime = resetAt.toLocaleString('en-US', { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric', hour: 'numeric', minute: '2-digit' });
-                line2 = ` {bold}Week:{/bold}` +
-                    ` {${pctColor}-fg}${pct.toFixed(0)}% used{/${pctColor}-fg}` +
-                    `  {${pctColor}-fg}⏱ ${countdown}{/${pctColor}-fg}` +
-                    `  resets ${resetTime}`;
+                line2 = ` {bold}${rpad('Week:', COL_LABEL)}{/bold}` +
+                    `{${pctColor}-fg}${rpad(pctStr, COL_PCT)}{/${pctColor}-fg}` +
+                    `  {${pctColor}-fg}⏱ ${rpad(countdown, COL_CD)}{/${pctColor}-fg}` +
+                    `resets ${resetTime}`;
             }
             windowBox.setContent(line1 + (line2 ? '\n' + line2 : ''));
         }
@@ -1299,17 +1826,94 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             dlog(`Window: ${err.message}`);
             windowBox.setContent(` {gray-fg}Usage data unavailable{/gray-fg}`);
         }
-        try {
-            screen.render();
-        }
-        catch { }
+        if (!skipRender)
+            try {
+                screen.render();
+            }
+            catch { }
     }
     // 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();
@@ -1333,29 +1937,31 @@ 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'], () => {
+    function shutdownDashboard() {
+        detachRawF7Listener?.();
         clearInterval(pollInterval);
         clearInterval(windowPollInterval);
-        clearInterval(countdownInterval);
+        clearInterval(tickInterval);
         clearInterval(headerAnimInterval);
         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(countdownInterval);
-            clearInterval(headerAnimInterval);
-            clearInterval(fortuneInterval);
-            screen.destroy();
-            process.exit(0);
+            shutdownDashboard();
         });
         screen.key(['r'], () => {
-            lastFileSize = 0;
-            updateDashboard();
-            updateWindowBox();
+            void hardRedraw('r-key');
         });
     }
     // ══════════════════════════════════════════════════════════════════════════
@@ -1399,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' +
@@ -1409,7 +2015,8 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                     '\n' +
                     '{bold}Controls{/bold}\n' +
                     '  r          Refresh now\n' +
-                    '  q/Ctrl+C   Quit\n' +
+                    '  F7         Hard redraw (fixes corruption)\n' +
+                    '  q/Ctrl+Q   Quit\n' +
                     '\n' +
                     '{gray-fg}Press any key to close{/gray-fg}'),
                 tags: true,
@@ -1454,8 +2061,18 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         fortuneText = activeFortunes[fortuneIdx];
         renderHeader();
     }, 30000);
-    const windowPollInterval = setInterval(fetchAndCacheUsage, 15000); // fetch fresh data every 15s
-    const countdownInterval = setInterval(renderWindowBox, 1000); // tick countdown every 1s
+    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);
+        try {
+            screen.render();
+        }
+        catch { }
+    }, 1000);
 }
 // ── Helpers ──
 function fmtK(n) {
@@ -1466,6 +2083,14 @@ function fmtK(n) {
     return String(n);
 }
 function formatK(n) { return fmtK(n); }
+function formatElapsed(startMs) {
+    const diff = Math.max(0, Math.floor((Date.now() - startMs) / 1000));
+    const h = Math.floor(diff / 3600);
+    const m = Math.floor((diff % 3600) / 60);
+    const s = diff % 60;
+    const pad = (n) => String(n).padStart(2, '0');
+    return h > 0 ? `${h}:${pad(m)}:${pad(s)}` : `${m}:${pad(s)}`;
+}
 // ── Session picker ──
 async function pickSession() {
     const sessions = await (0, usage_parser_js_1.listEkkosSessions)(20);
@@ -1523,9 +2148,8 @@ exports.dashboardCommand = new commander_1.Command('dashboard')
     }
     const jsonlPath = resolveJsonlPath(sessionName);
     if (!jsonlPath) {
-        console.log(chalk_1.default.red(`No JSONL found for "${sessionName}"`));
-        console.log(chalk_1.default.gray('Run "ekkos sessions" to see active sessions'));
-        process.exit(1);
+        // JSONL may not exist yet (session just started) — launch with lazy resolution
+        console.log(chalk_1.default.gray(`Waiting for JSONL for "${sessionName}"...`));
     }
-    await launchDashboard(sessionName, jsonlPath, refreshMs);
+    await launchDashboard(sessionName, jsonlPath || null, refreshMs, null, Date.now());
 });