@ekkos/cli 0.3.3 → 1.0.1

package/dist/commands/dashboard.js

@@ -0,0 +1,1175 @@
+"use strict";
+/**
+ * ekkos dashboard [session-name]
+ *
+ * Live TUI dashboard for monitoring Claude Code session usage in real-time.
+ * Uses blessed-contrib for rich terminal widgets (gauges, charts, tables).
+ *
+ * Usage:
+ *   ekkos dashboard <session-name>   Watch specific session
+ *   ekkos dashboard --latest         Auto-detect latest active session
+ *   ekkos dashboard --wait-for-new   Wait for a brand-new session to appear
+ *   ekkos dashboard                  Interactive session picker
+ *
+ * Text Selection:
+ *   To select text separately from Claude Code, run the dashboard in a different
+ *   terminal window/pane. This prevents the blessed screen from interfering with
+ *   Claude Code's text selection. Use iTerm2 split panes or tmux windows.
+ *
+ * Scrolling:
+ *   Up/Down arrows or j/k    Scroll one line
+ *   PageUp/PageDown or u/d   Scroll one page
+ *   Home/End or g/G          Jump to top/bottom
+ *   Mouse wheel              Scroll with mouse
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardCommand = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+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");
+// ── 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-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 },
+};
+function getModelPricing(modelId) {
+    if (MODEL_PRICING[modelId])
+        return MODEL_PRICING[modelId];
+    if (modelId.includes('opus'))
+        return MODEL_PRICING['claude-opus-4-6'];
+    if (modelId.includes('sonnet'))
+        return MODEL_PRICING['claude-sonnet-4-5-20250929'];
+    if (modelId.includes('haiku'))
+        return MODEL_PRICING['claude-haiku-4-5-20251001'];
+    return MODEL_PRICING['claude-sonnet-4-5-20250929'];
+}
+function calculateTurnCost(model, usage) {
+    const p = getModelPricing(model);
+    return ((usage.input_tokens / 1000000) * p.input +
+        (usage.output_tokens / 1000000) * p.output +
+        (usage.cache_creation_tokens / 1000000) * p.cacheWrite +
+        (usage.cache_read_tokens / 1000000) * p.cacheRead);
+}
+function getModelCtxSize(model) {
+    if (model.includes('opus'))
+        return 200000;
+    if (model.includes('haiku'))
+        return 200000;
+    if (model.includes('sonnet'))
+        return 200000;
+    return 200000; // Default Anthropic context
+}
+/** Model tag for dashboard display */
+function modelTag(model) {
+    if (model.includes('opus'))
+        return 'Opus';
+    if (model.includes('sonnet'))
+        return 'Sonnet';
+    if (model.includes('haiku'))
+        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');
+    const turnsByMsgId = new Map();
+    const msgIdOrder = [];
+    let startedAt = '';
+    let model = 'unknown';
+    const toolsByMessage = new Map();
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.type === 'assistant' && entry.message?.content) {
+                const msgId = entry.message.id;
+                for (const block of entry.message.content) {
+                    if (block.type === 'tool_use' && block.name) {
+                        if (!toolsByMessage.has(msgId))
+                            toolsByMessage.set(msgId, new Set());
+                        toolsByMessage.get(msgId).add(block.name);
+                    }
+                }
+            }
+            if (entry.type === 'assistant' && entry.message?.usage) {
+                const msgId = entry.message.id;
+                const isNew = msgId && !turnsByMsgId.has(msgId);
+                const usage = entry.message.usage;
+                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;
+                const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+                const contextTokens = inputTokens + cacheReadTokens + cacheCreationTokens;
+                const modelCtxSize = getModelCtxSize(model);
+                const contextPct = (contextTokens / modelCtxSize) * 100;
+                const ts = entry.timestamp || new Date().toISOString();
+                if (!startedAt)
+                    startedAt = ts;
+                const usageData = {
+                    input_tokens: inputTokens,
+                    output_tokens: outputTokens,
+                    cache_read_tokens: cacheReadTokens,
+                    cache_creation_tokens: cacheCreationTokens,
+                };
+                // Cost at actual model pricing (Haiku if routed)
+                const turnCost = calculateTurnCost(routedModel, usageData);
+                // Cost if it had been Opus (for savings calculation)
+                const opusCost = routedModel !== model
+                    ? calculateTurnCost(model, usageData)
+                    : turnCost;
+                const savings = opusCost - turnCost;
+                const msgTools = toolsByMessage.get(msgId);
+                const toolStr = msgTools && msgTools.size > 0
+                    ? Array.from(msgTools).map(t => t.replace(/^mcp__ekkos-memory__/, '').replace(/^ekkOS_/, '')).join(',')
+                    : '-';
+                // Last entry wins — final JSONL entry for a message has the real output_tokens
+                const turnNum = isNew ? msgIdOrder.length + 1 : (turnsByMsgId.get(msgId).turn);
+                const turnData = {
+                    turn: turnNum,
+                    contextPct,
+                    cacheRead: cacheReadTokens,
+                    cacheCreate: cacheCreationTokens,
+                    output: outputTokens,
+                    cost: turnCost,
+                    opusCost,
+                    savings,
+                    tools: toolStr,
+                    model,
+                    routedModel,
+                    replayState,
+                    replayStore,
+                    evictionState,
+                    timestamp: ts,
+                };
+                if (msgId) {
+                    if (isNew)
+                        msgIdOrder.push(msgId);
+                    turnsByMsgId.set(msgId, turnData);
+                }
+            }
+        }
+        catch { /* skip bad lines */ }
+    }
+    // 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 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);
+    const maxContextPct = turns.length > 0 ? Math.max(...turns.map(t => t.contextPct)) : 0;
+    const currentContextPct = turns.length > 0 ? turns[turns.length - 1].contextPct : 0;
+    const avgCostPerTurn = turns.length > 0 ? totalCost / turns.length : 0;
+    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();
+        const end = new Date(turns[turns.length - 1].timestamp).getTime();
+        const mins = Math.round((end - start) / 60000);
+        duration = mins >= 60 ? `${Math.floor(mins / 60)}h${mins % 60}m` : `${mins}m`;
+    }
+    // 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)
+        : 0;
+    const modelContextSize = getModelCtxSize(model);
+    return {
+        sessionName,
+        model,
+        turnCount: turns.length,
+        totalCost,
+        totalTokens: totalCacheRead + totalCacheCreate + totalOutput,
+        totalCacheRead,
+        totalCacheCreate,
+        totalOutput,
+        avgCostPerTurn,
+        maxContextPct,
+        currentContextPct,
+        currentContextTokens,
+        modelContextSize,
+        cacheHitRate,
+        replayAppliedCount,
+        replaySkippedSizeCount,
+        replaySkipStoreCount,
+        startedAt,
+        duration,
+        turns,
+    };
+}
+// ── Resolve session to JSONL path ──
+function resolveJsonlPath(sessionName, createdAfterMs) {
+    // 1) Try standard resolution (works when sessionId is a real UUID)
+    const resolved = (0, usage_parser_js_1.resolveSessionName)(sessionName);
+    if (resolved) {
+        const jsonlPath = path.join(os.homedir(), '.claude', 'projects', resolved.encodedProjectPath, `${resolved.uuid}.jsonl`);
+        if (fs.existsSync(jsonlPath))
+            return jsonlPath;
+    }
+    // 2) Fallback: active session has "pending" UUID
+    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) {
+                return findLatestJsonl(match.projectPath, createdAfterMs);
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
+/**
+ * Find a JSONL file in a project directory.
+ * @param createdAfterMs - If set, only return files CREATED (birthtime) after this timestamp.
+ *                         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))
+        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;
+}
+function getLatestSession() {
+    const sessions = (0, state_js_1.getActiveSessions)();
+    if (sessions.length === 0)
+        return null;
+    sessions.sort((a, b) => (b.lastHeartbeat || '').localeCompare(a.lastHeartbeat || ''));
+    return sessions[0].sessionName;
+}
+/**
+ * Wait for a new session to appear (used with --wait-for-new from ekkos run --dashboard).
+ * Polls active-sessions.json until a session started AFTER the launch marker timestamp.
+ * Returns the JSONL path for the new session.
+ */
+async function waitForNewSession() {
+    // Read launch timestamp + CWD marker
+    const markerPath = path.join(state_js_1.EKKOS_DIR, '.dashboard-launch-ts');
+    let launchTs = Date.now() - 5000; // default: 5s ago
+    let launchCwd = null;
+    try {
+        const lines = fs.readFileSync(markerPath, 'utf-8').trim().split('\n');
+        launchTs = parseInt(lines[0]) || launchTs;
+        if (lines[1])
+            launchCwd = lines[1];
+    }
+    catch { }
+    console.log(chalk_1.default.gray('  Waiting for new session to start...'));
+    const maxWaitMs = 120000; // 2 minutes max
+    const pollMs = 3000;
+    const startWait = Date.now();
+    let candidateName = null;
+    while (Date.now() - startWait < maxWaitMs) {
+        const sessions = (0, state_js_1.getActiveSessions)();
+        // Find sessions that started after our launch
+        for (const s of sessions) {
+            const startedMs = new Date(s.startedAt).getTime();
+            if (startedMs >= launchTs - 2000) {
+                candidateName = s.sessionName;
+                // Try standard resolution (works when session bind has happened with real UUID)
+                const jsonlPath = resolveJsonlPath(s.sessionName, launchTs);
+                if (jsonlPath) {
+                    console.log(chalk_1.default.green(`  Found session: ${s.sessionName}`));
+                    return { sessionName: s.sessionName, jsonlPath };
+                }
+                // Try all unique projectPaths for this session name (bind may create second entry)
+                const allPaths = new Set(sessions.filter(x => x.sessionName === s.sessionName && x.projectPath)
+                    .map(x => x.projectPath));
+                for (const pp of allPaths) {
+                    const latestJsonl = findLatestJsonl(pp, launchTs);
+                    if (latestJsonl) {
+                        console.log(chalk_1.default.green(`  Found session: ${s.sessionName}`));
+                        return { sessionName: s.sessionName, jsonlPath: latestJsonl };
+                    }
+                }
+            }
+        }
+        // Fallback: use launch CWD to find any new JSONL
+        if (launchCwd) {
+            const latestJsonl = findLatestJsonl(launchCwd, launchTs);
+            if (latestJsonl) {
+                const name = candidateName || 'session';
+                console.log(chalk_1.default.green(`  Found session via CWD: ${name}`));
+                return { sessionName: name, jsonlPath: latestJsonl };
+            }
+        }
+        await sleep(pollMs);
+        process.stdout.write(chalk_1.default.gray('.'));
+    }
+    // Timeout — try one more time with the candidate name (still use birthtime filter)
+    if (candidateName) {
+        console.log(chalk_1.default.yellow(`\n  Timeout. Trying ${candidateName} anyway...`));
+        const jsonlPath = resolveJsonlPath(candidateName, launchTs);
+        if (jsonlPath)
+            return { sessionName: candidateName, jsonlPath };
+    }
+    // Last resort: latest session overall
+    const latestName = getLatestSession();
+    if (latestName) {
+        console.log(chalk_1.default.yellow(`\n  Falling back to latest: ${latestName}`));
+        const jsonlPath = resolveJsonlPath(latestName);
+        if (jsonlPath)
+            return { sessionName: latestName, jsonlPath };
+    }
+    console.log(chalk_1.default.red('  No session found.'));
+    process.exit(1);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// ── TUI Dashboard ──
+async function launchDashboard(initialSessionName, jsonlPath, refreshMs) {
+    let sessionName = initialSessionName;
+    const blessed = require('blessed');
+    const contrib = require('blessed-contrib');
+    // ══════════════════════════════════════════════════════════════════════════
+    // TMUX SPLIT PANE ISOLATION
+    // When dashboard runs in a separate tmux pane from `ekkos run`, blessed must
+    // NOT consume stdin/stdout control, which would break both panes.
+    //
+    // KEY FIX: We use /dev/tty to give blessed DIRECT terminal access instead of
+    // inheriting stdin/stdout. This ensures:
+    // 1. Dashboard draws only to its own tmux pane (not to stdout pipe)
+    // 2. Terminal control (raw mode, alternate buffer) is local to that pane
+    // 3. Claude Code pane remains fully independent
+    // 4. Text selection works across panes without interference
+    // ══════════════════════════════════════════════════════════════════════════
+    // Open /dev/tty for blessed to use (gives it direct terminal access)
+    const fs = require('fs');
+    let ttyInput = process.stdin;
+    let ttyOutput = process.stdout;
+    try {
+        // Create readable/writable streams from /dev/tty file descriptors
+        const ttyFd = fs.openSync('/dev/tty', 'r+');
+        ttyInput = new (require('tty').ReadStream)(ttyFd);
+        ttyOutput = new (require('tty').WriteStream)(ttyFd);
+    }
+    catch (e) {
+        // Fallback: if /dev/tty unavailable (some CI/remote environments),
+        // use stdin/stdout but disable all event handling
+        ttyInput = process.stdin;
+        ttyOutput = process.stdout;
+    }
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: `ekkOS - ${sessionName}`,
+        fullUnicode: true,
+        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
+        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
+        terminal: 'xterm-256color',
+        resizeTimeout: 300, // Debounce resize events
+    });
+    // ══════════════════════════════════════════════════════════════════════════
+    // DISABLE TERMINAL CONTROL SEQUENCE HIJACKING
+    // Prevent blessed from sending control sequences that might interfere with
+    // other panes in tmux. The /dev/tty approach already isolates this, but we
+    // also disable the raw mode entirely to be extra safe.
+    // ══════════════════════════════════════════════════════════════════════════
+    if (screen.program) {
+        // Override alternateBuffer to do nothing
+        screen.program.alternateBuffer = () => { };
+        screen.program.normalBuffer = () => { };
+        // Don't enter raw mode — let the OS handle it
+        if (screen.program.setRawMode) {
+            screen.program.setRawMode = (enabled) => {
+                // Silently ignore raw mode requests
+                return enabled;
+            };
+        }
+    }
+    // ── 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.
+    //
+    //  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)
+    //  usage:    3 rows (Anthropic rate limit window)
+    //  footer:   3 rows (totals + routing + keybindings)
+    const LOGO_CHARS = ['e', 'k', 'k', 'O', 'S', '_'];
+    const WAVE_COLORS = ['cyan', 'blue', 'magenta', 'yellow', 'green', 'white'];
+    const W = '100%';
+    const HEADER_H = 3;
+    const CONTEXT_H = 5;
+    const USAGE_H = 4;
+    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 calcLayout() {
+        const H = screen.height;
+        const remaining = Math.max(6, H - FIXED_H);
+        const chartH = Math.max(4, Math.floor(remaining * 0.30));
+        const tableH = Math.max(4, remaining - chartH);
+        return {
+            header: { top: 0, height: HEADER_H },
+            context: { top: HEADER_H, height: CONTEXT_H },
+            chart: { top: HEADER_H + CONTEXT_H, height: chartH },
+            table: { top: HEADER_H + CONTEXT_H + chartH, height: tableH },
+            usage: { top: H - USAGE_H - FOOTER_H, height: USAGE_H },
+            footer: { top: H - FOOTER_H, height: FOOTER_H },
+        };
+    }
+    let layout = calcLayout();
+    // Header: session stats (3 lines)
+    const headerBox = blessed.box({
+        top: layout.header.top, left: 0, width: W, height: layout.header.height,
+        content: ' {gray-fg}Loading...{/gray-fg}',
+        tags: true,
+        style: { fg: 'white', border: { fg: 'cyan' } },
+        border: { type: 'line' },
+        label: ' ekkOS_ ',
+    });
+    // Context: progress bar + costs + cache (5 lines)
+    const contextBox = blessed.box({
+        top: layout.context.top, left: 0, width: W, height: layout.context.height,
+        content: '',
+        tags: true,
+        style: { fg: 'white', border: { fg: 'cyan' } },
+        border: { type: 'line' },
+        label: ' Context ',
+    });
+    // Clawd mascot — official Claude Code mascot (redBright / rgb(215,119,87))
+    const clawdBox = blessed.box({
+        parent: contextBox,
+        top: 0,
+        right: 2, // Keep a small visual gap from the context border
+        width: 10,
+        height: 3,
+        content: '  ▐▛███▜▌\n ▝▜█████▛▘\n   ▘▘ ▝▝',
+        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,
+    });
+    // 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,
+        content: '',
+        tags: true,
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: { ch: '│', style: { fg: 'cyan' } },
+        keys: true, // Enable keyboard scrolling
+        vi: true, // Enable vi-style keys (j/k for scroll)
+        mouse: false, // Mouse disabled (use keyboard for scrolling, allows text selection)
+        input: true,
+        interactive: true, // Make box interactive for scrolling
+        label: ' Turns (scroll: ↑↓/k/j, page: PgUp/u, home/end: g/G) ',
+        border: { type: 'line', fg: 'cyan' },
+        style: { fg: 'white', border: { fg: 'cyan' } },
+    });
+    // Usage window (rate limits)
+    const windowBox = blessed.box({
+        top: layout.usage.top, left: 0, width: W, height: layout.usage.height,
+        content: ' {gray-fg}Loading usage...{/gray-fg}',
+        tags: true,
+        style: { fg: 'white', border: { fg: 'magenta' } },
+        border: { type: 'line' },
+        label: ' Rate Limit ',
+    });
+    // Footer (totals + routing + keys)
+    const footerBox = blessed.box({
+        top: layout.footer.top, left: 0, width: W, height: layout.footer.height,
+        content: ' {gray-fg}Loading...{/gray-fg}',
+        tags: true,
+        style: { fg: 'white', border: { fg: 'cyan' } },
+        border: { type: 'line' },
+        label: ' Session ',
+    });
+    // Add all widgets to screen
+    screen.append(headerBox);
+    screen.append(contextBox);
+    screen.append(tokenChart);
+    screen.append(turnBox);
+    screen.append(windowBox);
+    screen.append(footerBox);
+    // Apply layout positions to all widgets
+    function applyLayout() {
+        layout = calcLayout();
+        const fullWidth = Math.max(20, screen.width || 80);
+        const H_PAD = 1; // Keep dashboard widgets off the pane edges
+        const contentWidth = Math.max(18, fullWidth - (H_PAD * 2));
+        headerBox.top = layout.header.top;
+        headerBox.left = H_PAD;
+        headerBox.width = contentWidth;
+        headerBox.height = layout.header.height;
+        contextBox.top = layout.context.top;
+        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;
+        turnBox.top = layout.table.top;
+        turnBox.left = H_PAD;
+        turnBox.width = contentWidth;
+        turnBox.height = layout.table.height;
+        windowBox.top = layout.usage.top;
+        windowBox.left = H_PAD;
+        windowBox.width = contentWidth;
+        windowBox.height = layout.usage.height;
+        footerBox.top = layout.footer.top;
+        footerBox.left = H_PAD;
+        footerBox.width = contentWidth;
+        footerBox.height = layout.footer.height;
+    }
+    // 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;
+    function ensureLayoutSynced() {
+        const w = screen.width || 0;
+        const h = screen.height || 0;
+        if (w === lastLayoutW && h === lastLayoutH)
+            return;
+        lastLayoutW = w;
+        lastLayoutH = h;
+        try {
+            screen.realloc?.();
+        }
+        catch { }
+        applyLayout();
+    }
+    // ── Logo color wave animation ──
+    let waveOffset = 0;
+    let sparkleTimer;
+    function renderLogoWave() {
+        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}`);
+            }
+            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 {
+            fs.appendFileSync(debugLog, `[${new Date().toISOString()}] ${msg}\n`);
+        }
+        catch { }
+    }
+    function updateDashboard() {
+        ensureLayoutSynced();
+        // Resolve "initializing" → real session name from JSONL UUID filename
+        if (sessionName === 'initializing' || sessionName === 'session') {
+            try {
+                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);
+                    screen.title = `ekkOS - ${sessionName}`;
+                }
+            }
+            catch { }
+        }
+        let data;
+        try {
+            const stat = fs.statSync(jsonlPath);
+            if (stat.size === lastFileSize && lastData)
+                return;
+            lastFileSize = stat.size;
+            data = parseJsonlFile(jsonlPath, sessionName);
+            lastData = data;
+        }
+        catch (err) {
+            dlog(`Parse error: ${err.message}`);
+            return;
+        }
+        // ── Header — wave animation handles rendering, just trigger a frame ──
+        try {
+            renderLogoWave();
+        }
+        catch (err) {
+            dlog(`Header: ${err.message}`);
+        }
+        // ── Context + Cost (progress bar + stats, 3 content lines) ──
+        try {
+            const ctxPct = Math.min(data.currentContextPct, 100);
+            const ctxColor = ctxPct < 50 ? 'green' : ctxPct < 80 ? 'yellow' : 'red';
+            const tokensK = Math.round(data.currentContextTokens / 1000);
+            const maxK = Math.round(data.modelContextSize / 1000);
+            // Visual progress bar (fills available width)
+            const contextInnerWidth = Math.max(10, contextBox.width - 2);
+            // Extend bar slightly closer to mascot while keeping a small visual gap.
+            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;
+            // 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` +
+                ` {${hitColor}-fg}${data.cacheHitRate.toFixed(0)}% cache{/${hitColor}-fg}` +
+                `  peak:${cappedMax.toFixed(0)}%` +
+                `  avg:$${data.avgCostPerTurn.toFixed(2)}/t` +
+                `  replay A:${data.replayAppliedCount}` +
+                ` SZ:${data.replaySkippedSizeCount}` +
+                ` ST:${data.replaySkipStoreCount}`);
+        }
+        catch (err) {
+            dlog(`Context: ${err.message}`);
+        }
+        // ── Token Line Chart (all 3 series: Rd, Wr, Out) ──
+        try {
+            const recent = data.turns.slice(-30);
+            if (recent.length >= 2) {
+                const x = recent.map(t => String(t.turn));
+                tokenChart.setData([
+                    { 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' } },
+                ]);
+            }
+        }
+        catch (err) {
+            dlog(`Chart: ${err.message}`);
+        }
+        // ── Turn Table (manual rendering — dynamic widths + dim dividers) ──
+        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}';
+            function pad(s, width) {
+                if (s.length >= width)
+                    return s.slice(0, width);
+                return s + ' '.repeat(width - s.length);
+            }
+            function rpad(s, width) {
+                if (s.length >= width)
+                    return s.slice(0, width);
+                return ' '.repeat(width - s.length) + s;
+            }
+            // 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();
+            let header = '';
+            let separator = '';
+            let rows = [];
+            // Responsive table layouts keep headers visible even in very narrow panes.
+            if (w >= 44) {
+                // Full mode: Turn, Model, Context, Cache Rd, Cache Wr, Output, Cost
+                const colNum = 4;
+                const colM = 6;
+                const colCtx = 6;
+                const colCost = 6;
+                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}`;
+                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 +
+                        `{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 +
+                        costFlag + rpad(`$${t.cost.toFixed(2)}`, colCost) + costEnd);
+                });
+            }
+            else if (w >= 30) {
+                // Compact mode: drop cache split columns to preserve readable headers.
+                const colNum = 4;
+                const colM = 6;
+                const colCtx = 6;
+                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}`;
+                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 +
+                        `{cyan-fg}${rpad(fmtK(t.output), outW)}{/cyan-fg}` + div +
+                        costFlag + rpad(`$${t.cost.toFixed(2)}`, colCost) + costEnd);
+                });
+            }
+            else {
+                // Minimal mode: guaranteed no-wrap fallback.
+                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}`;
+                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 +
+                        costFlag + rpad(`$${t.cost.toFixed(2)}`, colCost) + costEnd);
+                });
+            }
+            const lines = [header, separator, ...rows];
+            turnBox.setContent(lines.join('\n'));
+            // Restore scroll position AFTER content update
+            // Only restore if user has scrolled away from top (0%)
+            if (lastScrollPerc > 0) {
+                turnBox.setScrollPerc(lastScrollPerc);
+            }
+        }
+        catch (err) {
+            dlog(`Table: ${err.message}`);
+        }
+        // ── Session Totals (footer) ──
+        try {
+            const totalTokensM = ((data.totalCacheRead + data.totalCacheCreate + data.totalOutput) / 1000000).toFixed(2);
+            const totalSavings = data.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 routingParts = [`{magenta-fg}O{/magenta-fg}:${opusCount}`];
+            if (sonnetCount > 0)
+                routingParts.push(`{blue-fg}S{/blue-fg}:${sonnetCount}`);
+            routingParts.push(`{green-fg}H{/green-fg}:${haikuCount}`);
+            const routingStr = routingParts.join(' ');
+            const savingsStr = totalSavings > 0
+                ? `  {green-fg}saved $${totalSavings.toFixed(2)}{/green-fg}`
+                : '';
+            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}`);
+        }
+        catch (err) {
+            dlog(`Footer: ${err.message}`);
+        }
+        try {
+            screen.render();
+        }
+        catch (err) {
+            dlog(`Render: ${err.message}`);
+        }
+    }
+    // ── 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 } }
+     * Requires Claude Code OAuth token from macOS Keychain.
+     */
+    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;
+            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)
+                return null;
+            return await resp.json();
+        }
+        catch {
+            return null;
+        }
+    }
+    async function updateWindowBox() {
+        try {
+            const usage = await fetchAnthropicUsage();
+            let line1 = ' {gray-fg}No usage data{/gray-fg}';
+            let line2 = '';
+            // ── 5h Window (from Anthropic OAuth API) ──
+            if (usage?.five_hour) {
+                const pct = usage.five_hour.utilization;
+                const resetAt = new Date(usage.five_hour.resets_at).getTime();
+                const remainMs = Math.max(0, resetAt - Date.now());
+                const remainMin = Math.round(remainMs / 60000);
+                const rH = Math.floor(remainMin / 60);
+                const rM = remainMin % 60;
+                const pctColor = pct < 50 ? 'green' : pct < 80 ? 'yellow' : 'red';
+                const timeColor = remainMin > 120 ? 'green' : remainMin > 60 ? 'yellow' : 'red';
+                line1 = ` {bold}5h:{/bold}` +
+                    ` {${pctColor}-fg}${pct.toFixed(0)}% used{/${pctColor}-fg}` +
+                    `  {${timeColor}-fg}${rH}h${rM}m left{/${timeColor}-fg}`;
+            }
+            // ── Weekly (from Anthropic OAuth API) ──
+            if (usage?.seven_day) {
+                const pct = usage.seven_day.utilization;
+                const resetAt = new Date(usage.seven_day.resets_at);
+                const dayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+                const resetDay = dayNames[resetAt.getDay()];
+                const resetHour = resetAt.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' });
+                const pctColor = pct < 50 ? 'green' : pct < 80 ? 'yellow' : 'red';
+                line2 = ` {bold}Week:{/bold}` +
+                    ` {${pctColor}-fg}${pct.toFixed(0)}% used{/${pctColor}-fg}` +
+                    `  resets ${resetDay} ${resetHour}`;
+            }
+            windowBox.setContent(line1 + (line2 ? '\n' + line2 : ''));
+        }
+        catch (err) {
+            dlog(`Window: ${err.message}`);
+            windowBox.setContent(` {gray-fg}Usage data unavailable{/gray-fg}`);
+        }
+        try {
+            screen.render();
+        }
+        catch { }
+    }
+    // ── Handle terminal resize ──
+    // Recalculate all widget positions from new screen.height
+    screen.on('resize', () => {
+        try {
+            ensureLayoutSynced();
+            if (lastData)
+                updateDashboard();
+            else
+                screen.render();
+        }
+        catch (err) {
+            dlog(`Resize: ${err.message}`);
+        }
+    });
+    // ══════════════════════════════════════════════════════════════════════════
+    // 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'], () => {
+        clearInterval(pollInterval);
+        clearInterval(windowPollInterval);
+        clearTimeout(sparkleTimer);
+        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,
+        });
+        screen.append(help);
+        screen.render();
+        // Close on any key press
+        const closeHelp = () => {
+            help.destroy();
+            screen.render();
+            screen.removeListener('key', closeHelp);
+        };
+        screen.on('key', closeHelp);
+    });
+    // Clear terminal buffer — prevents garbage text from previous commands
+    screen.program.clear();
+    // Dashboard is fully passive — no widget captures keyboard input
+    updateDashboard();
+    screen.render();
+    // Delay first ccusage call — let blessed render first, then load heavy data
+    setTimeout(() => updateWindowBox(), 2000);
+    const pollInterval = setInterval(updateDashboard, refreshMs);
+    const windowPollInterval = setInterval(updateWindowBox, 15000); // every 15s
+}
+// ── Helpers ──
+function fmtK(n) {
+    if (n >= 1000000)
+        return `${(n / 1000000).toFixed(1)}M`;
+    if (n >= 1000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return String(n);
+}
+function formatK(n) { return fmtK(n); }
+// ── Session picker ──
+async function pickSession() {
+    const sessions = await (0, usage_parser_js_1.listEkkosSessions)(20);
+    if (sessions.length === 0) {
+        console.log(chalk_1.default.yellow('No sessions found with usage data.'));
+        console.log(chalk_1.default.gray('Start a session with "ekkos run" first.'));
+        return null;
+    }
+    const { default: inquirer } = await Promise.resolve().then(() => __importStar(require('inquirer')));
+    const answer = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'session',
+            message: 'Choose session:',
+            choices: sessions.map(s => ({
+                name: `${s.name}  ($${s.cost.toFixed(2)}, ${s.turnCount}t)`,
+                value: s.name,
+            })),
+        },
+    ]);
+    return answer.session;
+}
+// ── Commander command ──
+exports.dashboardCommand = new commander_1.Command('dashboard')
+    .description('Live TUI dashboard for monitoring Claude Code session usage')
+    .argument('[session-name]', 'ekkOS session name (e.g., dew-pod-hum)')
+    .option('--latest', 'Auto-detect latest active session')
+    .option('--wait-for-new', 'Wait for a new session to start (used by ekkos run --dashboard)')
+    .option('--refresh <ms>', 'Polling interval in ms', '2000')
+    .option('--compact', 'Minimal layout for small terminals')
+    .action(async (sessionNameArg, options) => {
+    const refreshMs = parseInt(options.refresh) || 2000;
+    // --wait-for-new: poll until a brand new session appears
+    if (options.waitForNew) {
+        const { sessionName, jsonlPath } = await waitForNewSession();
+        await launchDashboard(sessionName, jsonlPath, refreshMs);
+        return;
+    }
+    let sessionName = null;
+    if (sessionNameArg) {
+        sessionName = sessionNameArg;
+    }
+    else if (options.latest) {
+        sessionName = getLatestSession();
+        if (!sessionName) {
+            console.log(chalk_1.default.yellow('No active sessions found.'));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.gray(`Auto-detected: ${sessionName}`));
+    }
+    else {
+        sessionName = await pickSession();
+        if (!sessionName)
+            process.exit(0);
+    }
+    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);
+    }
+    await launchDashboard(sessionName, jsonlPath, refreshMs);
+});