@ekkos/cli 1.0.36 → 1.1.1

package/dist/commands/dashboard.js

@@ -67,6 +67,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
 const usage_parser_js_1 = require("../lib/usage-parser.js");
 const state_js_1 = require("../utils/state.js");
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 // ── Pricing ──
 // Pricing per MTok from https://platform.claude.com/docs/en/about-claude/pricing
 const MODEL_PRICING = {
@@ -113,6 +114,19 @@ function modelTag(model) {
         return 'Haiku';
     return '?';
 }
+function parseCacheHintValue(cacheHint, key) {
+    if (!cacheHint || typeof cacheHint !== 'string')
+        return null;
+    const parts = cacheHint.split(';');
+    for (const part of parts) {
+        const [k, ...rest] = part.split('=');
+        if (k?.trim() === key) {
+            const value = rest.join('=').trim();
+            return value || null;
+        }
+    }
+    return null;
+}
 function parseJsonlFile(jsonlPath, sessionName) {
     const content = fs.readFileSync(jsonlPath, 'utf-8');
     const lines = content.trim().split('\n');
@@ -141,6 +155,18 @@ function parseJsonlFile(jsonlPath, sessionName) {
                 model = entry.message.model || model;
                 // Smart routing: _ekkos_routed_model contains the actual model used
                 const routedModel = entry.message._ekkos_routed_model || entry.message.model || model;
+                const cacheHint = typeof entry.message._ekkos_cache_hint === 'string'
+                    ? entry.message._ekkos_cache_hint
+                    : undefined;
+                const replayState = typeof entry.message._ekkos_replay_state === 'string'
+                    ? entry.message._ekkos_replay_state
+                    : (parseCacheHintValue(cacheHint, 'replay') || 'unknown');
+                const replayStore = typeof entry.message._ekkos_replay_store === 'string'
+                    ? entry.message._ekkos_replay_store
+                    : 'none';
+                const evictionState = typeof entry.message._ekkos_eviction_state === 'string'
+                    ? entry.message._ekkos_eviction_state
+                    : (parseCacheHintValue(cacheHint, 'eviction') || 'unknown');
                 const inputTokens = usage.input_tokens || 0;
                 const outputTokens = usage.output_tokens || 0;
                 const cacheReadTokens = usage.cache_read_input_tokens || 0;
@@ -182,6 +208,9 @@ function parseJsonlFile(jsonlPath, sessionName) {
                     tools: toolStr,
                     model,
                     routedModel,
+                    replayState,
+                    replayStore,
+                    evictionState,
                     timestamp: ts,
                 };
                 if (msgId) {
@@ -205,6 +234,9 @@ function parseJsonlFile(jsonlPath, sessionName) {
     const cacheHitRate = (totalCacheRead + totalCacheCreate) > 0
         ? (totalCacheRead / (totalCacheRead + totalCacheCreate)) * 100
         : 0;
+    const replayAppliedCount = turns.reduce((sum, t) => sum + (t.replayState === 'applied' ? 1 : 0), 0);
+    const replaySkippedSizeCount = turns.reduce((sum, t) => sum + (t.replayState === 'skipped-size' ? 1 : 0), 0);
+    const replaySkipStoreCount = turns.reduce((sum, t) => sum + (t.replayStore === 'skip-size' ? 1 : 0), 0);
     let duration = '0m';
     if (startedAt && turns.length > 0) {
         const start = new Date(startedAt).getTime();
@@ -233,11 +265,63 @@ function parseJsonlFile(jsonlPath, sessionName) {
         currentContextTokens,
         modelContextSize,
         cacheHitRate,
+        replayAppliedCount,
+        replaySkippedSizeCount,
+        replaySkipStoreCount,
         startedAt,
         duration,
         turns,
     };
 }
+function readJsonFile(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function resolveSessionAlias(sessionId) {
+    const normalized = sessionId.toLowerCase();
+    // Project-local hook state (most reliable for the active session)
+    const projectState = readJsonFile(path.join(process.cwd(), '.claude', 'state', 'current-session.json'));
+    if (projectState?.session_id?.toLowerCase() === normalized &&
+        projectState.session_name &&
+        !UUID_REGEX.test(projectState.session_name)) {
+        return projectState.session_name;
+    }
+    // Global Claude hook state
+    const claudeState = readJsonFile(path.join(os.homedir(), '.claude', 'state', 'current-session.json'));
+    if (claudeState?.session_id?.toLowerCase() === normalized &&
+        claudeState.session_name &&
+        !UUID_REGEX.test(claudeState.session_name)) {
+        return claudeState.session_name;
+    }
+    // ekkOS global state
+    const ekkosState = readJsonFile(path.join(os.homedir(), '.ekkos', 'current-session.json'));
+    if (ekkosState?.session_id?.toLowerCase() === normalized &&
+        ekkosState.session_name &&
+        !UUID_REGEX.test(ekkosState.session_name)) {
+        return ekkosState.session_name;
+    }
+    // Multi-session index fallback
+    const activeSessions = readJsonFile(path.join(os.homedir(), '.ekkos', 'active-sessions.json')) || [];
+    const bySessionId = activeSessions
+        .filter(s => s.sessionId?.toLowerCase() === normalized && s.sessionName && !UUID_REGEX.test(s.sessionName))
+        .sort((a, b) => (b.lastHeartbeat || '').localeCompare(a.lastHeartbeat || ''));
+    if (bySessionId.length > 0)
+        return bySessionId[0].sessionName || null;
+    return null;
+}
+function displaySessionName(rawName) {
+    if (!rawName)
+        return 'session';
+    if (!UUID_REGEX.test(rawName))
+        return rawName;
+    return resolveSessionAlias(rawName) || (0, state_js_1.uuidToWords)(rawName);
+}
 // ── Resolve session to JSONL path ──
 function resolveJsonlPath(sessionName, createdAfterMs) {
     // 1) Try standard resolution (works when sessionId is a real UUID)
@@ -267,23 +351,53 @@ function resolveJsonlPath(sessionName, createdAfterMs) {
  *                         This prevents picking up old sessions that are still being modified.
  */
 function findLatestJsonl(projectPath, createdAfterMs) {
-    const encoded = projectPath.replace(/\//g, '-');
-    const projectDir = path.join(os.homedir(), '.claude', 'projects', encoded);
-    if (!fs.existsSync(projectDir))
+    // Claude encodes project paths by replacing separators with '-'.
+    // On Windows, ':' is also illegal in directory names so it gets replaced too.
+    // 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
+    ]);
+    const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
+    for (const encoded of candidateEncodings) {
+        const projectDir = path.join(projectsRoot, encoded);
+        if (!fs.existsSync(projectDir))
+            continue;
+        const jsonlFiles = fs.readdirSync(projectDir)
+            .filter(f => f.endsWith('.jsonl'))
+            .map(f => {
+            const stat = fs.statSync(path.join(projectDir, f));
+            return {
+                path: path.join(projectDir, f),
+                mtime: stat.mtimeMs,
+                birthtime: stat.birthtimeMs,
+            };
+        })
+            .filter(f => !createdAfterMs || f.birthtime > createdAfterMs)
+            .sort((a, b) => b.mtime - a.mtime);
+        if (jsonlFiles.length > 0)
+            return jsonlFiles[0].path;
+    }
+    return null;
+}
+function findJsonlBySessionId(projectPath, sessionId) {
+    if (!sessionId)
         return null;
-    const jsonlFiles = fs.readdirSync(projectDir)
-        .filter(f => f.endsWith('.jsonl'))
-        .map(f => {
-        const stat = fs.statSync(path.join(projectDir, f));
-        return {
-            path: path.join(projectDir, f),
-            mtime: stat.mtimeMs,
-            birthtime: stat.birthtimeMs,
-        };
-    })
-        .filter(f => !createdAfterMs || f.birthtime > createdAfterMs)
-        .sort((a, b) => b.mtime - a.mtime);
-    return jsonlFiles.length > 0 ? jsonlFiles[0].path : null;
+    const candidateEncodings = new Set([
+        projectPath.replace(/[\\/]/g, '-'),
+        projectPath.replace(/[:\\/]/g, '-'),
+        '-' + projectPath.replace(/[:\\/]/g, '-'),
+        projectPath.replace(/\//g, '-'),
+    ]);
+    const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
+    for (const encoded of candidateEncodings) {
+        const exactPath = path.join(projectsRoot, encoded, `${sessionId}.jsonl`);
+        if (fs.existsSync(exactPath))
+            return exactPath;
+    }
+    return null;
 }
 function getLatestSession() {
     const sessions = (0, state_js_1.getActiveSessions)();
@@ -315,6 +429,29 @@ async function waitForNewSession() {
     const startWait = Date.now();
     let candidateName = null;
     while (Date.now() - startWait < maxWaitMs) {
+        // ── Windows hook hint file ──────────────────────────────────────────────
+        // On Windows, active-sessions.json is never populated because hook processes
+        // are short-lived and their PIDs are dead by the time we poll. Instead, the
+        // user-prompt-submit.ps1 hook writes ~/.ekkos/hook-session-hint.json with
+        // { sessionName, sessionId, projectPath, ts } on every turn. Read it here.
+        const hintPath = path.join(state_js_1.EKKOS_DIR, 'hook-session-hint.json');
+        try {
+            if (fs.existsSync(hintPath)) {
+                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)
+                        || resolveJsonlPath(hint.sessionName, launchTs);
+                    if (jsonlPath) {
+                        console.log(chalk_1.default.green(`  Found session (hook hint): ${hint.sessionName}`));
+                        return { sessionName: hint.sessionName, jsonlPath };
+                    }
+                }
+            }
+        }
+        catch { /* ignore */ }
+        // ── Standard: active-sessions.json (works on Mac/Linux) ────────────────
         const sessions = (0, state_js_1.getActiveSessions)();
         // Find sessions that started after our launch
         for (const s of sessions) {
@@ -343,11 +480,49 @@ async function waitForNewSession() {
         if (launchCwd) {
             const latestJsonl = findLatestJsonl(launchCwd, launchTs);
             if (latestJsonl) {
-                const name = candidateName || 'session';
+                const name = candidateName || path.basename(latestJsonl, '.jsonl');
                 console.log(chalk_1.default.green(`  Found session via CWD: ${name}`));
                 return { sessionName: name, jsonlPath: latestJsonl };
             }
         }
+        // Broad fallback: scan ALL project directories for any new JSONL (Windows safety net).
+        // Claude creates the JSONL immediately when a session starts, before the first message.
+        // This catches cases where path encoding doesn't match.
+        {
+            const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
+            try {
+                if (fs.existsSync(projectsRoot)) {
+                    const allNewJsonl = fs.readdirSync(projectsRoot)
+                        .flatMap(dir => {
+                        const dirPath = path.join(projectsRoot, dir);
+                        try {
+                            return fs.readdirSync(dirPath)
+                                .filter(f => f.endsWith('.jsonl'))
+                                .map(f => {
+                                const fp = path.join(dirPath, f);
+                                const stat = fs.statSync(fp);
+                                return { path: fp, birthtime: stat.birthtimeMs, mtime: stat.mtimeMs };
+                            })
+                                .filter(f => f.birthtime > launchTs);
+                        }
+                        catch {
+                            return [];
+                        }
+                    })
+                        .sort((a, b) => b.birthtime - a.birthtime);
+                    if (allNewJsonl.length > 0) {
+                        const jsonlPath = allNewJsonl[0].path;
+                        // Derive name from filename (e.g. abc123.jsonl → use candidateName if set, else basename)
+                        const baseName = path.basename(jsonlPath, '.jsonl');
+                        const derivedName = /^[0-9a-f]{8}-/.test(baseName) ? (0, state_js_1.uuidToWords)(baseName) : baseName;
+                        const name = candidateName || derivedName;
+                        console.log(chalk_1.default.green(`  Found session via scan: ${name}`));
+                        return { sessionName: name, jsonlPath };
+                    }
+                }
+            }
+            catch { /* ignore */ }
+        }
         await sleep(pollMs);
         process.stdout.write(chalk_1.default.gray('.'));
     }
@@ -374,9 +549,10 @@ function sleep(ms) {
 }
 // ── TUI Dashboard ──
 async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
-    let sessionName = initialSessionName;
+    let sessionName = displaySessionName(initialSessionName);
     const blessed = require('blessed');
     const contrib = require('blessed-contrib');
+    const inTmux = process.env.TMUX !== undefined;
     // ══════════════════════════════════════════════════════════════════════════
     // TMUX SPLIT PANE ISOLATION
     // When dashboard runs in a separate tmux pane from `ekkos run`, blessed must
@@ -451,6 +627,62 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
     //  footer:   3 rows (totals + routing + keybindings)
     const LOGO_CHARS = ['e', 'k', 'k', 'O', 'S', '_'];
     const WAVE_COLORS = ['cyan', 'blue', 'magenta', 'yellow', 'green', 'white'];
+    const GOOD_LUCK_FORTUNES = [
+        // AI / LLM era humor
+        'The AI was confident. It was also wrong.',
+        'Vibe coded it. Ship it. Pray.',
+        'Your model hallucinated. Your memory did not.',
+        'Claude said "I cannot assist with that." ekkOS remembered anyway.',
+        'The context window closed. The lesson did not.',
+        'Cursor wrote it. You own it. Good luck.',
+        'It works. Nobody knows why. Memory saved the why.',
+        'LLM said "as of my knowledge cutoff." ekkOS said hold my cache.',
+        'Your agent forgot. Classic agent behavior.',
+        'GPT-5 dropped. Your memory still works.',
+        'Trained on the internet. Trusted by no one.',
+        'Fine-tuned on vibes. Running in production.',
+        'Prompt engineering is just yelling more politely.',
+        'The AI is confident 97% of the time. The other 3% is your bug.',
+        // Friday deploys / prod pain
+        'Pushed to prod on a Friday. Memory captured the regret.',
+        'It was working this morning. The morning remembers.',
+        'The bug was in prod for 3 months. The fix took 4 minutes.',
+        'Hotfix on a hotfix. Classic.',
+        'Rollback complete. Dignity: partial.',
+        '"It works on my machine." Ship the machine.',
+        'The incident was resolved. The root cause was vibes.',
+        'Post-mortem written. Lessons immediately forgotten. Not anymore.',
+        // Context / memory specific
+        'Cold start problem? Never met her.',
+        '94% cache hit rate. The other 6% are trust issues.',
+        '107 turns. Zero compaction. One very tired server.',
+        'Flat cost curve. Exponential confidence.',
+        'Your session ended. Your mistakes did not.',
+        'The context limit hit. The memory did not care.',
+        'Compaction is a skill issue.',
+        // General dev pain
+        'The ticket said "small change." It was not small.',
+        'Story points are astrology for engineers.',
+        'The meeting could have been a memory.',
+        '"Just a quick question." — 45 minutes ago.',
+        'Senior dev. 8 years experience. Still googles how to center a div.',
+        'Code review: where confidence goes to die.',
+        'The PR sat for 11 days. You merged it anyway.',
+        'Works fine until it\'s demoed. Classic.',
+        'Two spaces or four? Choose your enemies carefully.',
+        'Tech debt is just regular debt with better excuses.',
+        'The documentation was last updated in 2019. Press F.',
+        'Legacy code: someone\'s proudest moment, your worst nightmare.',
+        'Tabs vs spaces is still unresolved. The war continues.',
+        'LGTM. (I did not look at this.)',
+        'The standup is 15 minutes. It is never 15 minutes.',
+        'Agile: deadline anxiety, but make it a ceremony.',
+        '"No breaking changes." — Famous last words.',
+        'Your regex is beautiful. Your regex is unmaintainable.',
+        'undefined is just the universe saying try again.',
+        'It\'s not a bug. It\'s a negotiated feature.',
+        'Closed one ticket. Jira opened three.',
+    ];
     const W = '100%';
     const HEADER_H = 3;
     const CONTEXT_H = 5;
@@ -461,7 +693,7 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
     function calcLayout() {
         const H = screen.height;
         const remaining = Math.max(6, H - FIXED_H);
-        const chartH = Math.max(4, Math.floor(remaining * 0.30));
+        const chartH = Math.max(8, Math.floor(remaining * 0.40));
         const tableH = Math.max(4, remaining - chartH);
         return {
             header: { top: 0, height: HEADER_H },
@@ -473,6 +705,12 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         };
     }
     let layout = calcLayout();
+    let lastFileSize = 0;
+    let lastData = null;
+    let lastChartSeries = null;
+    let lastScrollPerc = 0; // Preserve scroll position across updates
+    let fortuneIdx = Math.floor(Math.random() * GOOD_LUCK_FORTUNES.length);
+    let fortuneText = GOOD_LUCK_FORTUNES[fortuneIdx];
     // Header: session stats (3 lines)
     const headerBox = blessed.box({
         top: layout.header.top, left: 0, width: W, height: layout.header.height,
@@ -482,6 +720,18 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         border: { type: 'line' },
         label: ' ekkOS_ ',
     });
+    // Explicit header message row: with HEADER_H=3 and a border, this is the
+    // single inner content row (visual line 2 of the widget).
+    const headerMessageRow = blessed.box({
+        parent: headerBox,
+        top: 0,
+        left: 0,
+        width: '100%-2',
+        height: 1,
+        tags: false,
+        style: { fg: 'green', bold: true },
+        content: '',
+    });
     // Context: progress bar + costs + cache (5 lines)
     const contextBox = blessed.box({
         top: layout.context.top, left: 0, width: W, height: layout.context.height,
@@ -502,23 +752,28 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         tags: false,
         style: { fg: 'red', bold: true }, // ansi redBright = official Clawd orange
     });
-    // Token chart (fills 30% of remaining)
-    const tokenChart = contrib.line({
-        top: layout.chart.top, left: 0, width: W, height: layout.chart.height,
-        label: ' Tokens/Turn (K) ',
-        showLegend: true,
-        legend: { width: 8 },
-        style: {
-            line: 'green',
-            text: 'white',
-            baseline: 'white',
-            border: { fg: 'cyan' },
-        },
-        border: { type: 'line', fg: 'cyan' },
-        xLabelPadding: 0,
-        xPadding: 1,
-        wholeNumbersOnly: false,
-    });
+    // Token chart (fills 40% of remaining)
+    function createTokenChart(top, left, width, height) {
+        return contrib.line({
+            top, left, width, height,
+            label: ' Tokens/Turn (K) ',
+            showLegend: true,
+            legend: { width: 8 },
+            style: {
+                line: 'green',
+                text: 'white',
+                baseline: 'white',
+                border: { fg: 'cyan' },
+            },
+            border: { type: 'line', fg: 'cyan' },
+            xLabelPadding: 0,
+            xPadding: 1,
+            wholeNumbersOnly: false,
+        });
+    }
+    let tokenChart = createTokenChart(layout.chart.top, 0, W, layout.chart.height);
+    let chartLayoutW = 0;
+    let chartLayoutH = 0;
     // Turn table — manual rendering for full-width columns + dim dividers
     const turnBox = blessed.box({
         top: layout.table.top, left: 0, width: W, height: layout.table.height,
@@ -527,11 +782,11 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         scrollable: true,
         alwaysScroll: true,
         scrollbar: { ch: '│', style: { fg: 'cyan' } },
-        keys: true, // Enable keyboard scrolling
-        vi: true, // Enable vi-style keys (j/k for scroll)
+        keys: !inTmux, // In tmux split mode keep dashboard passive
+        vi: !inTmux, // Avoid single-key handlers interfering with paste
         mouse: false, // Mouse disabled (use keyboard for scrolling, allows text selection)
-        input: true,
-        interactive: true, // Make box interactive for scrolling
+        input: !inTmux,
+        interactive: !inTmux, // Standalone only; passive in tmux split
         label: ' Turns (scroll: ↑↓/k/j, page: PgUp/u, home/end: g/G) ',
         border: { type: 'line', fg: 'cyan' },
         style: { fg: 'white', border: { fg: 'cyan' } },
@@ -575,10 +830,29 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         contextBox.left = H_PAD;
         contextBox.width = contentWidth;
         contextBox.height = layout.context.height;
-        tokenChart.top = layout.chart.top;
-        tokenChart.left = H_PAD;
-        tokenChart.width = contentWidth;
-        tokenChart.height = layout.chart.height;
+        // blessed-contrib line can keep a stale tiny canvas when terminals report
+        // initial dimensions incorrectly (observed in Windows Terminal). Rebuild
+        // the chart widget whenever dimensions change so the plot fills the panel.
+        if (chartLayoutW !== contentWidth || chartLayoutH !== layout.chart.height) {
+            try {
+                screen.remove(tokenChart);
+            }
+            catch { }
+            try {
+                tokenChart.destroy?.();
+            }
+            catch { }
+            tokenChart = createTokenChart(layout.chart.top, H_PAD, contentWidth, layout.chart.height);
+            chartLayoutW = contentWidth;
+            chartLayoutH = layout.chart.height;
+            screen.append(tokenChart);
+        }
+        else {
+            tokenChart.top = layout.chart.top;
+            tokenChart.left = H_PAD;
+            tokenChart.width = contentWidth;
+            tokenChart.height = layout.chart.height;
+        }
         turnBox.top = layout.table.top;
         turnBox.left = H_PAD;
         turnBox.width = contentWidth;
@@ -591,7 +865,16 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         footerBox.left = H_PAD;
         footerBox.width = contentWidth;
         footerBox.height = layout.footer.height;
+        // Force blessed-contrib to re-render the chart canvas at the new dimensions
+        if (lastChartSeries) {
+            try {
+                tokenChart.setData(lastChartSeries);
+            }
+            catch { }
+        }
     }
+    // Apply once at startup so chart/table geometry is correct even before any resize event.
+    applyLayout();
     // Track geometry so we can re-anchor widgets even if tmux resize events are flaky
     let lastLayoutW = screen.width || 0;
     let lastLayoutH = screen.height || 0;
@@ -608,59 +891,82 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         catch { }
         applyLayout();
     }
-    // ── Logo color wave animation ──
+    // ── Header render (animated logo in border label + compact stats content) ──
     let waveOffset = 0;
-    let sparkleTimer;
-    function renderLogoWave() {
+    function buildAnimatedLogo() {
+        const raw = LOGO_CHARS.join('');
+        const tagged = LOGO_CHARS.map((ch, i) => {
+            const colorIdx = Math.abs(i + waveOffset) % WAVE_COLORS.length;
+            const color = WAVE_COLORS[colorIdx];
+            return `{${color}-fg}${ch}{/${color}-fg}`;
+        }).join('');
+        return { raw, tagged };
+    }
+    function buildShinySessionName(name) {
+        if (!name)
+            return '';
+        const chars = name.split('');
+        const shineIdx = Math.abs(waveOffset) % chars.length;
+        return chars.map((ch, i) => {
+            if (i === shineIdx)
+                return `{white-fg}{bold}${ch}{/bold}{/white-fg}`;
+            if (i === (shineIdx + chars.length - 1) % chars.length || i === (shineIdx + 1) % chars.length) {
+                return `{cyan-fg}${ch}{/cyan-fg}`;
+            }
+            return `{magenta-fg}${ch}{/magenta-fg}`;
+        }).join('');
+    }
+    function renderHeader() {
         try {
             ensureLayoutSynced();
-            // Color wave in the border label
-            const coloredChars = LOGO_CHARS.map((ch, i) => {
-                const colorIdx = (i + waveOffset) % WAVE_COLORS.length;
-                return `{${WAVE_COLORS[colorIdx]}-fg}${ch}{/${WAVE_COLORS[colorIdx]}-fg}`;
-            });
-            // Logo left + session name right in border label
-            const logoStr = ` ${coloredChars.join('')} `;
-            // Session name with traveling shimmer across ALL characters
-            const SESSION_GLOW = ['white', 'cyan', 'magenta'];
-            const glowPos = (waveOffset * 2) % sessionName.length; // 2x speed for snappier travel
-            const nameChars = sessionName.split('').map((ch, i) => {
-                const dist = Math.min(Math.abs(i - glowPos), sessionName.length - Math.abs(i - glowPos)); // wrapping distance
-                if (dist === 0)
-                    return `{${SESSION_GLOW[0]}-fg}${ch}{/${SESSION_GLOW[0]}-fg}`;
-                if (dist <= 2)
-                    return `{${SESSION_GLOW[1]}-fg}${ch}{/${SESSION_GLOW[1]}-fg}`;
-                return `{${SESSION_GLOW[2]}-fg}${ch}{/${SESSION_GLOW[2]}-fg}`;
-            });
-            const sessionStr = ` ${nameChars.join('')} `;
-            const rawLogoLen = LOGO_CHARS.length + 2; // " ekkOS_ " = 8
-            const rawSessionLen = sessionName.length + 3; // " name " + 1 extra space before ┐
             const boxW = Math.max(10, headerBox.width - 2); // minus border chars
-            const pad = Math.max(1, boxW - rawLogoLen - rawSessionLen);
-            headerBox.setLabel(logoStr + '─'.repeat(pad) + sessionStr);
-            waveOffset = (waveOffset + 1) % WAVE_COLORS.length;
-            // Stats go inside the box
-            const data = lastData;
-            if (data) {
-                const m = data.model.replace('claude-', '').replace(/-\d{8}$/, '');
-                headerBox.setContent(` {green-fg}$${data.totalCost.toFixed(2)}{/green-fg} T${data.turnCount} ${data.duration} $${data.avgCostPerTurn.toFixed(2)}/t {cyan-fg}${m}{/cyan-fg}`);
+            const logoPlain = ` ${LOGO_CHARS.join('')} `;
+            const animatedLogo = buildAnimatedLogo();
+            const logoTagged = ` ${animatedLogo.tagged} `;
+            const maxSessionLen = Math.max(6, boxW - logoPlain.length - 4);
+            const sessionLabel = sessionName.length > maxSessionLen
+                ? `${sessionName.slice(0, Math.max(0, maxSessionLen - 1))}…`
+                : sessionName;
+            const sessionPlain = ` ${sessionLabel} `;
+            const sessionTagged = ` ${buildShinySessionName(sessionLabel)} `;
+            const rightGap = ' ';
+            const pad = Math.max(1, boxW - logoPlain.length - sessionPlain.length - rightGap.length);
+            const divider = '─'.repeat(pad);
+            // Keep a raw fallback for extremely narrow panes, but prefer animated label.
+            const fallbackLabel = (logoPlain + divider + sessionPlain + rightGap).slice(0, boxW);
+            if (fallbackLabel.length < logoPlain.length + 2) {
+                headerBox.setLabel(fallbackLabel);
+            }
+            else {
+                headerBox.setLabel(logoTagged + divider + sessionTagged + rightGap);
             }
+            // Message line inside the box (centered)
+            const fortuneRaw = (fortuneText && fortuneText.trim().length > 0)
+                ? fortuneText.trim()
+                : 'Good luck.';
+            const truncateForWidth = (text, maxWidth) => {
+                if (maxWidth <= 0)
+                    return '';
+                if (text.length <= maxWidth)
+                    return text;
+                if (maxWidth <= 3)
+                    return '.'.repeat(maxWidth);
+                return `${text.slice(0, maxWidth - 3)}...`;
+            };
+            const centerForWidth = (text, maxWidth) => {
+                const clipped = truncateForWidth(text, maxWidth);
+                const leftPad = Math.max(0, Math.floor((maxWidth - clipped.length) / 2));
+                return `${' '.repeat(leftPad)}${clipped}`;
+            };
+            const maxInner = Math.max(8, boxW - 1);
+            // Render through dedicated line-2 row, not generic box content flow.
+            headerBox.setContent('');
+            headerMessageRow.setContent(centerForWidth(fortuneRaw, maxInner));
             screen.render();
         }
         catch { }
     }
-    // Wave cycles every 200ms for smooth color sweep
-    function scheduleWave() {
-        sparkleTimer = setTimeout(() => {
-            renderLogoWave();
-            scheduleWave();
-        }, 200);
-    }
-    scheduleWave();
     // ── Update function ──
-    let lastFileSize = 0;
-    let lastData = null;
-    let lastScrollPerc = 0; // Preserve scroll position across updates
     const debugLog = path.join(os.homedir(), '.ekkos', 'dashboard.log');
     function dlog(msg) {
         try {
@@ -676,12 +982,20 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
                 const basename = path.basename(jsonlPath, '.jsonl');
                 // JSONL filename is the session UUID (e.g., 607bd8e4-0a04-4db2-acf5-3f794be0f956.jsonl)
                 if (/^[0-9a-f]{8}-/.test(basename)) {
-                    sessionName = (0, state_js_1.uuidToWords)(basename);
+                    sessionName = displaySessionName(basename);
                     screen.title = `ekkOS - ${sessionName}`;
                 }
             }
             catch { }
         }
+        // If we started with a UUID fallback, keep trying to resolve to the bound word session.
+        if (UUID_REGEX.test(sessionName)) {
+            const resolvedName = displaySessionName(sessionName);
+            if (resolvedName !== sessionName) {
+                sessionName = resolvedName;
+                screen.title = `ekkOS - ${sessionName}`;
+            }
+        }
         let data;
         try {
             const stat = fs.statSync(jsonlPath);
@@ -695,9 +1009,9 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
             dlog(`Parse error: ${err.message}`);
             return;
         }
-        // ── Header — wave animation handles rendering, just trigger a frame ──
+        // ── Header ──
         try {
-            renderLogoWave();
+            renderHeader();
         }
         catch (err) {
             dlog(`Header: ${err.message}`);
@@ -729,7 +1043,10 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
                 `  {cyan-fg}Output{/cyan-fg} $${ou.toFixed(2)}\n` +
                 ` {${hitColor}-fg}${data.cacheHitRate.toFixed(0)}% cache{/${hitColor}-fg}` +
                 `  peak:${cappedMax.toFixed(0)}%` +
-                `  avg:$${data.avgCostPerTurn.toFixed(2)}/t`);
+                `  avg:$${data.avgCostPerTurn.toFixed(2)}/t` +
+                `  replay A:${data.replayAppliedCount}` +
+                ` SZ:${data.replaySkippedSizeCount}` +
+                ` ST:${data.replaySkipStoreCount}`);
         }
         catch (err) {
             dlog(`Context: ${err.message}`);
@@ -739,11 +1056,12 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
             const recent = data.turns.slice(-30);
             if (recent.length >= 2) {
                 const x = recent.map(t => String(t.turn));
-                tokenChart.setData([
+                lastChartSeries = [
                     { title: 'Rd', x, y: recent.map(t => Math.round(t.cacheRead / 1000)), style: { line: 'green' } },
                     { title: 'Wr', x, y: recent.map(t => Math.round(t.cacheCreate / 1000)), style: { line: 'yellow' } },
                     { title: 'Out', x, y: recent.map(t => Math.round(t.output / 1000)), style: { line: 'cyan' } },
-                ]);
+                ];
+                tokenChart.setData(lastChartSeries);
             }
         }
         catch (err) {
@@ -753,9 +1071,10 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
         try {
             // Preserve scroll position BEFORE updating content
             lastScrollPerc = turnBox.getScrollPerc();
-            // Account for borders + scrollbar gutter + padding so last column never wraps
-            const w = Math.max(18, turnBox.width - 5); // usable content width
-            const div = '{gray-fg}│{/gray-fg}';
+            // Account for borders + scrollbar gutter. Windows terminal rendering can
+            // wrap by one char if this is too tight, which pushes Cost to next line.
+            const w = Math.max(18, turnBox.width - 4); // usable content width
+            const div = '│';
             function pad(s, width) {
                 if (s.length >= width)
                     return s.slice(0, width);
@@ -766,6 +1085,14 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
                     return s.slice(0, width);
                 return ' '.repeat(width - s.length) + s;
             }
+            function cpad(s, width) {
+                if (s.length >= width)
+                    return s.slice(0, width);
+                const total = width - s.length;
+                const left = Math.floor(total / 2);
+                const right = total - left;
+                return ' '.repeat(left) + s + ' '.repeat(right);
+            }
             // Data rows — RENDER ALL TURNS for full scrollback history
             // Don't slice to visibleRows only — let user scroll through entire session
             const turns = data.turns.slice().reverse();
@@ -773,28 +1100,28 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
             let separator = '';
             let rows = [];
             // Responsive table layouts keep headers visible even in very narrow panes.
-            if (w >= 44) {
+            if (w >= 60) {
                 // Full mode: Turn, Model, Context, Cache Rd, Cache Wr, Output, Cost
                 const colNum = 4;
-                const colM = 6;
-                const colCtx = 6;
-                const colCost = 6;
+                const colM = 7;
+                const colCtx = 7;
+                const colCost = 8;
                 const nDividers = 6;
                 const fixedW = colNum + colM + colCtx + colCost;
                 const flexTotal = w - fixedW - nDividers;
-                const rdW = Math.max(4, Math.floor(flexTotal * 0.35));
-                const wrW = Math.max(4, Math.floor(flexTotal * 0.30));
-                const outW = Math.max(4, flexTotal - rdW - wrW);
-                header = `{bold}${pad('Turn', colNum)}${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}`;
-                separator = `{gray-fg}${'─'.repeat(colNum)}┼${'─'.repeat(colM)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(rdW)}┼${'─'.repeat(wrW)}┼${'─'.repeat(outW)}┼${'─'.repeat(colCost)}{/gray-fg}`;
+                const rdW = Math.max(10, Math.floor(flexTotal * 0.35));
+                const wrW = Math.max(11, Math.floor(flexTotal * 0.30));
+                const outW = Math.max(6, flexTotal - rdW - wrW);
+                header = `${pad('Turn', colNum)}${div}${rpad('Model', colM)}${div}${rpad('Contex', colCtx)}${div}${rpad('Cache Read', rdW)}${div}${rpad('Cache Write', wrW)}${div}${rpad('Output', outW)}${div}${rpad('Cost', colCost)}`;
+                separator = `${'─'.repeat(colNum)}┼${'─'.repeat(colM)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(rdW)}┼${'─'.repeat(wrW)}┼${'─'.repeat(outW)}┼${'─'.repeat(colCost)}`;
                 rows = turns.map(t => {
                     const mTag = modelTag(t.routedModel);
                     const mColor = t.routedModel.includes('haiku') ? 'green' : t.routedModel.includes('sonnet') ? 'blue' : 'magenta';
                     const costFlag = t.cost > 1.0 ? '{red-fg}' : t.cost > 0.5 ? '{yellow-fg}' : '{white-fg}';
                     const costEnd = t.cost > 1.0 ? '{/red-fg}' : t.cost > 0.5 ? '{/yellow-fg}' : '{/white-fg}';
                     return (pad(String(t.turn), colNum) + div +
-                        `{${mColor}-fg}${pad(mTag, colM)}{/${mColor}-fg}` + div +
-                        pad(`${t.contextPct.toFixed(0)}%`, colCtx) + div +
+                        `{${mColor}-fg}${cpad(mTag, colM)}{/${mColor}-fg}` + div +
+                        rpad(`${t.contextPct.toFixed(0)}%`, colCtx) + div +
                         `{green-fg}${rpad(fmtK(t.cacheRead), rdW)}{/green-fg}` + div +
                         `{yellow-fg}${rpad(fmtK(t.cacheCreate), wrW)}{/yellow-fg}` + div +
                         `{cyan-fg}${rpad(fmtK(t.output), outW)}{/cyan-fg}` + div +
@@ -809,16 +1136,16 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
                 const colCost = 6;
                 const nDividers = 4;
                 const outW = Math.max(4, w - (colNum + colM + colCtx + colCost + nDividers));
-                header = `{bold}${pad('Turn', colNum)}${div}${pad('Model', colM)}${div}${pad('Context', colCtx)}${div}${rpad('Output', outW)}${div}${rpad('Cost', colCost)}{/bold}`;
-                separator = `{gray-fg}${'─'.repeat(colNum)}┼${'─'.repeat(colM)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(outW)}┼${'─'.repeat(colCost)}{/gray-fg}`;
+                header = `${pad('Turn', colNum)}${div}${rpad('Model', colM)}${div}${rpad('Context', colCtx)}${div}${rpad('Output', outW)}${div}${rpad('Cost', colCost)}`;
+                separator = `${'─'.repeat(colNum)}┼${'─'.repeat(colM)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(outW)}┼${'─'.repeat(colCost)}`;
                 rows = turns.map(t => {
                     const mTag = modelTag(t.routedModel);
                     const mColor = t.routedModel.includes('haiku') ? 'green' : t.routedModel.includes('sonnet') ? 'blue' : 'magenta';
                     const costFlag = t.cost > 1.0 ? '{red-fg}' : t.cost > 0.5 ? '{yellow-fg}' : '{white-fg}';
                     const costEnd = t.cost > 1.0 ? '{/red-fg}' : t.cost > 0.5 ? '{/yellow-fg}' : '{/white-fg}';
                     return (pad(String(t.turn), colNum) + div +
-                        `{${mColor}-fg}${pad(mTag, colM)}{/${mColor}-fg}` + div +
-                        pad(`${t.contextPct.toFixed(0)}%`, colCtx) + div +
+                        `{${mColor}-fg}${cpad(mTag, colM)}{/${mColor}-fg}` + div +
+                        rpad(`${t.contextPct.toFixed(0)}%`, colCtx) + div +
                         `{cyan-fg}${rpad(fmtK(t.output), outW)}{/cyan-fg}` + div +
                         costFlag + rpad(`$${t.cost.toFixed(2)}`, colCost) + costEnd);
                 });
@@ -828,13 +1155,13 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
                 const colNum = 4;
                 const colCtx = 6;
                 const colCost = 6;
-                header = `{bold}${pad('Turn', colNum)}${div}${pad('Context', colCtx)}${div}${rpad('Cost', colCost)}{/bold}`;
-                separator = `{gray-fg}${'─'.repeat(colNum)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(colCost)}{/gray-fg}`;
+                header = `${pad('Turn', colNum)}${div}${rpad('Context', colCtx)}${div}${rpad('Cost', colCost)}`;
+                separator = `${'─'.repeat(colNum)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(colCost)}`;
                 rows = turns.map(t => {
                     const costFlag = t.cost > 1.0 ? '{red-fg}' : t.cost > 0.5 ? '{yellow-fg}' : '{white-fg}';
                     const costEnd = t.cost > 1.0 ? '{/red-fg}' : t.cost > 0.5 ? '{/yellow-fg}' : '{/white-fg}';
                     return (pad(String(t.turn), colNum) + div +
-                        pad(`${t.contextPct.toFixed(0)}%`, colCtx) + div +
+                        rpad(`${t.contextPct.toFixed(0)}%`, colCtx) + div +
                         costFlag + rpad(`$${t.cost.toFixed(2)}`, colCost) + costEnd);
                 });
             }
@@ -865,11 +1192,15 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
             const savingsStr = totalSavings > 0
                 ? `  {green-fg}saved $${totalSavings.toFixed(2)}{/green-fg}`
                 : '';
+            footerBox.setLabel(` ${sessionName} `);
             footerBox.setContent(` {green-fg}$${data.totalCost.toFixed(2)}{/green-fg}` +
                 `  ${totalTokensM}M` +
                 `  ${routingStr}` +
+                `  R[A:${data.replayAppliedCount} SZ:${data.replaySkippedSizeCount} ST:${data.replaySkipStoreCount}]` +
                 savingsStr +
-                `  {gray-fg}? help  q quit  r refresh{/gray-fg}`);
+                (inTmux
+                    ? `  {gray-fg}Ctrl+C quit{/gray-fg}`
+                    : `  {gray-fg}? help  q quit  r refresh{/gray-fg}`));
         }
         catch (err) {
             dlog(`Footer: ${err.message}`);
@@ -889,10 +1220,20 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
      */
     async function fetchAnthropicUsage() {
         try {
-            const { execSync } = require('child_process');
-            const credsJson = execSync('security find-generic-password -s "Claude Code-credentials" -w', { encoding: 'utf-8', timeout: 5000 }).trim();
-            const creds = JSON.parse(credsJson);
-            const token = creds?.claudeAiOauth?.accessToken;
+            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;
+                }
+            }
             if (!token)
                 return null;
             const resp = await fetch('https://api.anthropic.com/api/oauth/usage', {
@@ -958,10 +1299,19 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
     screen.on('resize', () => {
         try {
             ensureLayoutSynced();
-            if (lastData)
+            if (lastData) {
                 updateDashboard();
-            else
+            }
+            else {
+                // Even without data, re-apply chart series so the canvas redraws at new size
+                if (lastChartSeries) {
+                    try {
+                        tokenChart.setData(lastChartSeries);
+                    }
+                    catch { }
+                }
                 screen.render();
+            }
         }
         catch (err) {
             dlog(`Resize: ${err.message}`);
@@ -971,88 +1321,101 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
     // KEYBOARD SHORTCUTS - Only capture when dashboard pane has focus
     // In tmux split mode, this prevents capturing keys from Claude Code pane
     // ══════════════════════════════════════════════════════════════════════════
-    screen.key(['q', 'C-c'], () => {
+    screen.key(['C-c'], () => {
         clearInterval(pollInterval);
         clearInterval(windowPollInterval);
-        clearTimeout(sparkleTimer);
+        clearInterval(headerAnimInterval);
+        clearInterval(fortuneInterval);
         screen.destroy();
         process.exit(0);
     });
-    screen.key(['r'], () => {
-        lastFileSize = 0;
-        updateDashboard();
-        updateWindowBox();
-    });
+    if (!inTmux) {
+        screen.key(['q'], () => {
+            clearInterval(pollInterval);
+            clearInterval(windowPollInterval);
+            clearInterval(headerAnimInterval);
+            clearInterval(fortuneInterval);
+            screen.destroy();
+            process.exit(0);
+        });
+        screen.key(['r'], () => {
+            lastFileSize = 0;
+            updateDashboard();
+            updateWindowBox();
+        });
+    }
     // ══════════════════════════════════════════════════════════════════════════
     // FOCUS MANAGEMENT: In tmux split mode, DON'T auto-focus the turnBox
     // This prevents the dashboard from stealing focus from Claude Code on startup
     // User can manually focus by clicking into the dashboard pane
     // ══════════════════════════════════════════════════════════════════════════
-    // Check if we're in a tmux session
-    const inTmux = process.env.TMUX !== undefined;
     if (!inTmux) {
         // Only auto-focus when running standalone (not in tmux split)
         turnBox.focus();
     }
     // Scroll controls for turn table
-    screen.key(['up', 'k'], () => {
-        turnBox.scroll(-1);
-        screen.render();
-    });
-    screen.key(['down', 'j'], () => {
-        turnBox.scroll(1);
-        screen.render();
-    });
-    screen.key(['pageup', 'u'], () => {
-        turnBox.scroll(-(turnBox.height - 2));
-        screen.render();
-    });
-    screen.key(['pagedown', 'd'], () => {
-        turnBox.scroll((turnBox.height - 2));
-        screen.render();
-    });
-    screen.key(['home', 'g'], () => {
-        turnBox.setScrollPerc(0);
-        screen.render();
-    });
-    screen.key(['end', 'G'], () => {
-        turnBox.setScrollPerc(100);
-        screen.render();
-    });
-    screen.key(['?', 'h'], () => {
-        // Quick help overlay
-        const help = blessed.box({
-            top: 'center',
-            left: 'center',
-            width: 50,
-            height: 16,
-            content: ('{bold}Navigation{/bold}\n' +
-                '  ↑/k/j/↓    Scroll line\n' +
-                '  PgUp/u     Scroll page up\n' +
-                '  PgDn/d     Scroll page down\n' +
-                '  g/Home     Scroll to top\n' +
-                '  G/End      Scroll to bottom\n' +
-                '\n' +
-                '{bold}Controls{/bold}\n' +
-                '  r          Refresh now\n' +
-                '  q/Ctrl+C   Quit\n' +
-                '\n' +
-                '{gray-fg}Press any key to close{/gray-fg}'),
-            tags: true,
-            border: 'line',
-            style: { border: { fg: 'cyan' } },
-            padding: 1,
+    if (!inTmux) {
+        screen.key(['up', 'k'], () => {
+            turnBox.scroll(-1);
+            screen.render();
         });
-        screen.append(help);
-        screen.render();
-        // Close on any key press
-        const closeHelp = () => {
-            help.destroy();
+        screen.key(['down', 'j'], () => {
+            turnBox.scroll(1);
             screen.render();
-            screen.removeListener('key', closeHelp);
-        };
-        screen.on('key', closeHelp);
-    });
+        });
+        screen.key(['pageup', 'u'], () => {
+            turnBox.scroll(-(turnBox.height - 2));
+            screen.render();
+        });
+        screen.key(['pagedown', 'd'], () => {
+            turnBox.scroll((turnBox.height - 2));
+            screen.render();
+        });
+        screen.key(['home', 'g'], () => {
+            turnBox.setScrollPerc(0);
+            screen.render();
+        });
+        screen.key(['end', 'G'], () => {
+            turnBox.setScrollPerc(100);
+            screen.render();
+        });
+        screen.key(['?', 'h'], () => {
+            // Quick help overlay
+            const help = blessed.box({
+                top: 'center',
+                left: 'center',
+                width: 50,
+                height: 16,
+                content: ('{bold}Navigation{/bold}\n' +
+                    '  ↑/k/j/↓    Scroll line\n' +
+                    '  PgUp/u     Scroll page up\n' +
+                    '  PgDn/d     Scroll page down\n' +
+                    '  g/Home     Scroll to top\n' +
+                    '  G/End      Scroll to bottom\n' +
+                    '\n' +
+                    '{bold}Controls{/bold}\n' +
+                    '  r          Refresh now\n' +
+                    '  q/Ctrl+C   Quit\n' +
+                    '\n' +
+                    '{gray-fg}Press any key to close{/gray-fg}'),
+                tags: true,
+                border: 'line',
+                style: { border: { fg: 'cyan' } },
+                padding: 1,
+            });
+            screen.append(help);
+            screen.render();
+            // Defer listener so the '?' keypress that opened help doesn't immediately close it
+            setImmediate(() => {
+                const closeHelp = () => {
+                    help.destroy();
+                    screen.render();
+                    screen.removeListener('key', closeHelp);
+                };
+                screen.once('key', closeHelp);
+            });
+        });
+    }
     // Clear terminal buffer — prevents garbage text from previous commands
     screen.program.clear();
     // Dashboard is fully passive — no widget captures keyboard input
@@ -1061,6 +1424,18 @@ async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
     // Delay first ccusage call — let blessed render first, then load heavy data
     setTimeout(() => updateWindowBox(), 2000);
     const pollInterval = setInterval(updateDashboard, refreshMs);
+    const headerAnimInterval = setInterval(() => {
+        // Keep advancing across the full session label; wrap at a large value.
+        waveOffset = (waveOffset + 1) % 1000000;
+        renderHeader();
+    }, 500);
+    const fortuneInterval = setInterval(() => {
+        if (GOOD_LUCK_FORTUNES.length === 0)
+            return;
+        fortuneIdx = (fortuneIdx + 1) % GOOD_LUCK_FORTUNES.length;
+        fortuneText = GOOD_LUCK_FORTUNES[fortuneIdx];
+        renderHeader();
+    }, 30000);
     const windowPollInterval = setInterval(updateWindowBox, 15000); // every 15s
 }
 // ── Helpers ──