@ekkos/cli 0.2.18 → 1.0.0

package/dist/commands/swarm-dashboard.js

@@ -0,0 +1,735 @@
+"use strict";
+/**
+ * ekkos swarm dashboard
+ *
+ * Live TUI dashboard for monitoring a swarm of parallel Claude Code workers.
+ * Uses blessed-contrib for rich terminal widgets.
+ *
+ * Layout:
+ *   Header:   Swarm name + worker count + total cost + duration
+ *   Workers:  Per-worker status cards (context bar, cost, turns, model)
+ *   Chart:    Combined token usage from all workers
+ *   Table:    All turns from all workers (with worker column)
+ *   Usage:    Anthropic rate limit windows
+ *   Footer:   Aggregate totals + routing breakdown + keybindings
+ *
+ * Usage:
+ *   ekkos swarm dashboard                    Auto-detect active swarm
+ *   ekkos swarm dashboard --launch-ts 123    Use specific launch timestamp
+ */
+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.swarmDashboardCommand = 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 state_js_1 = require("../utils/state.js");
+// ── Pricing (per MTok) ──
+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) {
+    return 200000; // All current Claude models
+}
+function modelTag(model) {
+    if (model.includes('opus'))
+        return 'Opus';
+    if (model.includes('sonnet'))
+        return 'Sonnet';
+    if (model.includes('haiku'))
+        return 'Haiku';
+    return '?';
+}
+function parseWorkerJsonl(jsonlPath, workerIndex, sessionName) {
+    const content = fs.readFileSync(jsonlPath, 'utf-8');
+    const lines = content.trim().split('\n');
+    const turnsByMsgId = new Map();
+    const msgIdOrder = [];
+    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;
+                const routedModel = entry.message._ekkos_routed_model || entry.message.model || model;
+                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();
+                const usageData = {
+                    input_tokens: inputTokens,
+                    output_tokens: outputTokens,
+                    cache_read_tokens: cacheReadTokens,
+                    cache_creation_tokens: cacheCreationTokens,
+                };
+                const turnCost = calculateTurnCost(routedModel, usageData);
+                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(',')
+                    : '-';
+                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, timestamp: ts,
+                };
+                if (msgId) {
+                    if (isNew)
+                        msgIdOrder.push(msgId);
+                    turnsByMsgId.set(msgId, turnData);
+                }
+            }
+        }
+        catch { /* skip bad lines */ }
+    }
+    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 currentContextPct = turns.length > 0 ? turns[turns.length - 1].contextPct : 0;
+    const cacheHitRate = (totalCacheRead + totalCacheCreate) > 0
+        ? (totalCacheRead / (totalCacheRead + totalCacheCreate)) * 100 : 0;
+    const lastActivity = turns.length > 0 ? turns[turns.length - 1].timestamp : '';
+    return {
+        workerIndex,
+        sessionName,
+        jsonlPath,
+        model,
+        turnCount: turns.length,
+        totalCost,
+        totalTokens: totalCacheRead + totalCacheCreate + totalOutput,
+        totalCacheRead,
+        totalCacheCreate,
+        totalOutput,
+        currentContextPct,
+        cacheHitRate,
+        turns,
+        lastActivity,
+    };
+}
+// ── Worker discovery ──
+function resolveJsonlPath(sessionName, createdAfterMs) {
+    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;
+}
+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 discoverWorkers(launchTs) {
+    const sessions = (0, state_js_1.getActiveSessions)();
+    const workers = [];
+    // Find sessions started after swarm launch
+    const candidates = sessions
+        .filter(s => {
+        const startedMs = new Date(s.startedAt).getTime();
+        return startedMs >= launchTs - 5000; // 5s grace period
+    })
+        .sort((a, b) => new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime());
+    for (let i = 0; i < candidates.length; i++) {
+        const session = candidates[i];
+        const jsonlPath = resolveJsonlPath(session.sessionName, launchTs - 5000);
+        if (jsonlPath) {
+            try {
+                const data = parseWorkerJsonl(jsonlPath, i + 1, session.sessionName);
+                workers.push(data);
+            }
+            catch { /* skip broken jsonl */ }
+        }
+        else {
+            // Worker exists but no JSONL yet
+            workers.push({
+                workerIndex: i + 1,
+                sessionName: session.sessionName,
+                jsonlPath: '',
+                model: 'initializing',
+                turnCount: 0,
+                totalCost: 0,
+                totalTokens: 0,
+                totalCacheRead: 0,
+                totalCacheCreate: 0,
+                totalOutput: 0,
+                currentContextPct: 0,
+                cacheHitRate: 0,
+                turns: [],
+                lastActivity: '',
+            });
+        }
+    }
+    return workers;
+}
+function readSwarmMeta() {
+    const metaPath = path.join(process.cwd(), '.swarm', 'active-swarm.json');
+    try {
+        if (fs.existsSync(metaPath)) {
+            return JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+        }
+    }
+    catch { }
+    return null;
+}
+// ── 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 sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// ── TUI Dashboard ──
+async function launchSwarmDashboard(launchTs, refreshMs) {
+    const meta = readSwarmMeta();
+    const expectedWorkers = meta?.workers || 0;
+    const taskStr = meta?.task || 'Unknown task';
+    const blessed = require('blessed');
+    const contrib = require('blessed-contrib');
+    // Open /dev/tty for isolated terminal access (same as regular dashboard)
+    let ttyInput = process.stdin;
+    let ttyOutput = process.stdout;
+    try {
+        const ttyFd = fs.openSync('/dev/tty', 'r+');
+        ttyInput = new (require('tty').ReadStream)(ttyFd);
+        ttyOutput = new (require('tty').WriteStream)(ttyFd);
+    }
+    catch {
+        ttyInput = process.stdin;
+        ttyOutput = process.stdout;
+    }
+    const screen = blessed.screen({
+        smartCSR: true,
+        title: 'ekkOS Swarm',
+        fullUnicode: true,
+        mouse: false,
+        grabKeys: false,
+        sendFocus: false,
+        ignoreLocked: ['C-c'],
+        input: ttyInput,
+        output: ttyOutput,
+        forceUnicode: true,
+        terminal: 'xterm-256color',
+        resizeTimeout: 300,
+    });
+    // Disable terminal control sequence hijacking
+    if (screen.program) {
+        screen.program.alternateBuffer = () => { };
+        screen.program.normalBuffer = () => { };
+        if (screen.program.setRawMode) {
+            screen.program.setRawMode = (enabled) => enabled;
+        }
+    }
+    // ── Layout calculation ──
+    const W = '100%';
+    const HEADER_H = 3;
+    const WORKERS_H = 5;
+    const CHART_H_MIN = 6;
+    const USAGE_H = 4;
+    const FOOTER_H = 3;
+    const FIXED_H = HEADER_H + WORKERS_H + USAGE_H + FOOTER_H;
+    function calcLayout() {
+        const H = Math.max(30, screen.height);
+        const remaining = Math.max(10, H - FIXED_H);
+        const chartH = Math.max(CHART_H_MIN, Math.floor(remaining * 0.30));
+        const tableH = Math.max(4, remaining - chartH);
+        return {
+            header: { top: 0, height: HEADER_H },
+            workers: { top: HEADER_H, height: WORKERS_H },
+            chart: { top: HEADER_H + WORKERS_H, height: Math.max(CHART_H_MIN, chartH) },
+            table: { top: HEADER_H + WORKERS_H + chartH, height: Math.max(4, tableH) },
+            usage: { top: Math.max(HEADER_H + WORKERS_H + chartH + tableH, H - USAGE_H - FOOTER_H), height: USAGE_H },
+            footer: { top: Math.max(HEADER_H + WORKERS_H + chartH + tableH + USAGE_H, H - FOOTER_H), height: FOOTER_H },
+        };
+    }
+    let layout = calcLayout();
+    // ── Logo animation ──
+    const LOGO_CHARS = ['e', 'k', 'k', 'O', 'S', '_'];
+    const WAVE_COLORS = ['cyan', 'blue', 'magenta', 'yellow', 'green', 'white'];
+    let waveOffset = 0;
+    // ── Widgets ──
+    const headerBox = blessed.box({
+        top: layout.header.top, left: 0, width: W, height: layout.header.height,
+        content: ' {gray-fg}Starting swarm...{/gray-fg}',
+        tags: true,
+        style: { fg: 'white', border: { fg: 'yellow' } },
+        border: { type: 'line' },
+        label: ' ekkOS_ Swarm ',
+    });
+    const workersBox = blessed.box({
+        top: layout.workers.top, left: 0, width: W, height: layout.workers.height,
+        content: ' {gray-fg}Discovering workers...{/gray-fg}',
+        tags: true,
+        style: { fg: 'white', border: { fg: 'yellow' } },
+        border: { type: 'line' },
+        label: ' Workers ',
+    });
+    const tokenChart = contrib.line({
+        top: layout.chart.top, left: 0, width: W, height: layout.chart.height,
+        label: ' Tokens/Turn (K) ',
+        showLegend: true,
+        legend: { width: 12 },
+        style: { line: 'green', text: 'white', baseline: 'white', border: { fg: 'yellow' } },
+        border: { type: 'line', fg: 'yellow' },
+        xLabelPadding: 0, xPadding: 1, wholeNumbersOnly: false,
+    });
+    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: 'yellow' } },
+        keys: true, vi: true, mouse: false,
+        input: true, interactive: true,
+        label: ' All Turns ',
+        border: { type: 'line', fg: 'yellow' },
+        style: { fg: 'white', border: { fg: 'yellow' } },
+    });
+    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 ',
+    });
+    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: 'yellow' } },
+        border: { type: 'line' },
+        label: ' Swarm Totals ',
+    });
+    screen.append(headerBox);
+    screen.append(workersBox);
+    screen.append(tokenChart);
+    screen.append(turnBox);
+    screen.append(windowBox);
+    screen.append(footerBox);
+    function applyLayout() {
+        layout = calcLayout();
+        headerBox.top = layout.header.top;
+        headerBox.height = layout.header.height;
+        workersBox.top = layout.workers.top;
+        workersBox.height = layout.workers.height;
+        tokenChart.top = layout.chart.top;
+        tokenChart.height = layout.chart.height;
+        turnBox.top = layout.table.top;
+        turnBox.height = layout.table.height;
+        windowBox.top = layout.usage.top;
+        windowBox.height = layout.usage.height;
+        footerBox.top = layout.footer.top;
+        footerBox.height = layout.footer.height;
+    }
+    // ── State ──
+    let lastWorkers = [];
+    let sparkleTimer;
+    // ── Logo animation ──
+    function renderLogoWave() {
+        try {
+            const coloredChars = LOGO_CHARS.map((ch, i) => {
+                const colorIdx = (i + waveOffset) % WAVE_COLORS.length;
+                return `{${WAVE_COLORS[colorIdx]}-fg}${ch}{/${WAVE_COLORS[colorIdx]}-fg}`;
+            });
+            const logoStr = ` ${coloredChars.join('')} Swarm `;
+            // Duration
+            const elapsedMs = Date.now() - launchTs;
+            const mins = Math.round(elapsedMs / 60000);
+            const durStr = mins >= 60 ? `${Math.floor(mins / 60)}h${mins % 60}m` : `${mins}m`;
+            const totalCost = lastWorkers.reduce((s, w) => s + w.totalCost, 0);
+            const totalTurns = lastWorkers.reduce((s, w) => s + w.turnCount, 0);
+            const rawLogoLen = 14; // " ekkOS_ Swarm " roughly
+            const infoStr = ` ${lastWorkers.length}W ${totalTurns}t $${totalCost.toFixed(2)} ${durStr} `;
+            const rawInfoLen = infoStr.length + 1;
+            const boxW = screen.width - 2;
+            const pad = Math.max(1, boxW - rawLogoLen - rawInfoLen);
+            headerBox.setLabel(logoStr + '\u2500'.repeat(pad) + infoStr);
+            // Header content: task description
+            const maxW = screen.width - 6;
+            const truncTask = taskStr.length > maxW ? taskStr.slice(0, maxW - 3) + '...' : taskStr;
+            headerBox.setContent(` {gray-fg}Task:{/gray-fg} ${truncTask}`);
+            waveOffset = (waveOffset + 1) % WAVE_COLORS.length;
+            screen.render();
+        }
+        catch { }
+    }
+    function scheduleWave() {
+        sparkleTimer = setTimeout(() => {
+            renderLogoWave();
+            scheduleWave();
+        }, 200);
+    }
+    scheduleWave();
+    // ── Worker status cards ──
+    function renderWorkerCards(workers) {
+        if (workers.length === 0) {
+            workersBox.setContent(' {gray-fg}No workers detected yet...{/gray-fg}');
+            return;
+        }
+        const boxW = Math.max(20, screen.width - 4);
+        const WORKER_COLORS = ['magenta', 'blue', 'green', 'yellow', 'cyan', 'red', 'white', 'gray'];
+        const lines = [];
+        // Row 1: Worker names + context bars
+        // Row 2: Stats (turns, cost, model)
+        // Row 3: Status indicators
+        const cardWidth = Math.floor(boxW / Math.max(workers.length, 1));
+        const barWidth = Math.max(4, cardWidth - 14); // space for "W1: " and " 62%"
+        let row1 = '';
+        let row2 = '';
+        let row3 = '';
+        for (let i = 0; i < workers.length; i++) {
+            const w = workers[i];
+            const color = WORKER_COLORS[i % WORKER_COLORS.length];
+            const ctxPct = Math.min(w.currentContextPct, 100);
+            const ctxColor = ctxPct < 50 ? 'green' : ctxPct < 80 ? 'yellow' : 'red';
+            // Context bar
+            const filled = Math.round((ctxPct / 100) * barWidth);
+            const bar = `{${ctxColor}-fg}${'#'.repeat(filled)}{/${ctxColor}-fg}${'.'.repeat(barWidth - filled)}`;
+            // Model tag
+            const mTag = modelTag(w.model);
+            const mColor = w.model.includes('haiku') ? 'green' : w.model.includes('sonnet') ? 'blue' : 'magenta';
+            // Status
+            const status = w.turnCount === 0
+                ? '{gray-fg}INIT{/gray-fg}'
+                : (w.turns.length > 0 && (Date.now() - new Date(w.lastActivity).getTime()) < 30000)
+                    ? `{green-fg}ACTIVE{/green-fg}`
+                    : '{yellow-fg}IDLE{/yellow-fg}';
+            const label = `{${color}-fg}W${w.workerIndex}{/${color}-fg}`;
+            const sep = i < workers.length - 1 ? ' {gray-fg}|{/gray-fg} ' : '';
+            row1 += ` ${label}: ${bar} ${ctxPct.toFixed(0)}%${sep}`;
+            row2 += ` {gray-fg}T${w.turnCount}{/gray-fg} {green-fg}$${w.totalCost.toFixed(2)}{/green-fg} {${mColor}-fg}${mTag}{/${mColor}-fg}${sep.replace('|', ' ')}`;
+            row3 += ` ${status} {gray-fg}${w.sessionName.slice(0, 11)}{/gray-fg}${sep}`;
+        }
+        workersBox.setContent(`${row1}\n${row2}\n${row3}`);
+    }
+    // ── Combined turn table ──
+    function renderTurnTable(workers) {
+        const WORKER_COLORS = ['magenta', 'blue', 'green', 'yellow', 'cyan', 'red', 'white', 'gray'];
+        const w = Math.max(20, screen.width - 4);
+        const div = '{gray-fg}|{/gray-fg}';
+        // Columns: W(2) Turn(4) Model(7) Context(7) CacheRd(flex) CacheWr(flex) Out(flex) Cost(7)
+        const colW = 2;
+        const colNum = 4;
+        const colM = 7;
+        const colCtx = 7;
+        const colCost = 7;
+        const fixedW = colW + colNum + colM + colCtx + colCost;
+        const nDividers = 7;
+        const flexTotal = Math.max(9, w - fixedW - nDividers);
+        const rdW = Math.floor(flexTotal * 0.35);
+        const wrW = Math.floor(flexTotal * 0.30);
+        const outW = flexTotal - rdW - wrW;
+        function pad(s, width) {
+            return s.length >= width ? s.slice(0, width) : s + ' '.repeat(width - s.length);
+        }
+        function rpad(s, width) {
+            return s.length >= width ? s.slice(0, width) : ' '.repeat(width - s.length) + s;
+        }
+        const header = `{bold}${pad('W', colW)}${div}${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}`;
+        const separator = `{gray-fg}${'~'.repeat(colW)}+${'~'.repeat(colNum)}+${'~'.repeat(colM)}+${'~'.repeat(colCtx)}+${'~'.repeat(rdW)}+${'~'.repeat(wrW)}+${'~'.repeat(outW)}+${'~'.repeat(colCost)}{/gray-fg}`;
+        const allTurns = [];
+        for (const worker of workers) {
+            for (const turn of worker.turns) {
+                allTurns.push({ ...turn, workerIndex: worker.workerIndex });
+            }
+        }
+        // Sort by timestamp descending (newest first)
+        allTurns.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        const visibleRows = Math.max(1, layout.table.height - 4);
+        const rows = allTurns.slice(0, visibleRows).map(t => {
+            const wColor = WORKER_COLORS[(t.workerIndex - 1) % WORKER_COLORS.length];
+            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 (`{${wColor}-fg}${pad(String(t.workerIndex), colW)}{/${wColor}-fg}` + div +
+                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);
+        });
+        turnBox.setContent([header, separator, ...rows].join('\n'));
+    }
+    // ── Combined chart ──
+    function renderChart(workers) {
+        const WORKER_COLORS_RAW = ['magenta', 'blue', 'green', 'yellow', 'cyan', 'red'];
+        const series = [];
+        for (const w of workers) {
+            if (w.turns.length < 2)
+                continue;
+            const recent = w.turns.slice(-20);
+            const x = recent.map(t => String(t.turn));
+            const color = WORKER_COLORS_RAW[(w.workerIndex - 1) % WORKER_COLORS_RAW.length];
+            series.push({
+                title: `W${w.workerIndex}`,
+                x,
+                y: recent.map(t => Math.round((t.cacheRead + t.output) / 1000)),
+                style: { line: color },
+            });
+        }
+        if (series.length > 0) {
+            tokenChart.setData(series);
+        }
+    }
+    // ── Usage window (Anthropic OAuth) ──
+    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/swarm-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 = '';
+            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}`;
+            }
+            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 {
+            windowBox.setContent(` {gray-fg}Usage data unavailable{/gray-fg}`);
+        }
+        try {
+            screen.render();
+        }
+        catch { }
+    }
+    // ── Footer ──
+    function renderFooter(workers) {
+        const totalCost = workers.reduce((s, w) => s + w.totalCost, 0);
+        const totalTurns = workers.reduce((s, w) => s + w.turnCount, 0);
+        const totalSavings = workers.reduce((s, w) => s + w.turns.reduce((ts, t) => ts + t.savings, 0), 0);
+        const allTurns = workers.flatMap(w => w.turns);
+        const totalTokensM = ((workers.reduce((s, w) => s + w.totalTokens, 0)) / 1000000).toFixed(2);
+        const opusCount = allTurns.filter(t => t.routedModel.includes('opus')).length;
+        const sonnetCount = allTurns.filter(t => t.routedModel.includes('sonnet')).length;
+        const haikuCount = allTurns.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 savingsStr = totalSavings > 0 ? `  {green-fg}saved $${totalSavings.toFixed(2)}{/green-fg}` : '';
+        footerBox.setContent(` {green-fg}$${totalCost.toFixed(2)}{/green-fg}` +
+            `  ${totalTurns}t` +
+            `  ${totalTokensM}M` +
+            `  ${routingParts.join(' ')}` +
+            savingsStr +
+            `  {gray-fg}q r 0-${workers.length}{/gray-fg}`);
+    }
+    // ── Main update loop ──
+    function updateDashboard() {
+        try {
+            const workers = discoverWorkers(launchTs);
+            lastWorkers = workers;
+            renderWorkerCards(workers);
+            renderChart(workers);
+            renderTurnTable(workers);
+            renderFooter(workers);
+            screen.render();
+        }
+        catch { }
+    }
+    // ── Keyboard ──
+    screen.key(['q', 'C-c'], () => {
+        clearInterval(pollInterval);
+        clearInterval(windowPollInterval);
+        clearTimeout(sparkleTimer);
+        screen.destroy();
+        process.exit(0);
+    });
+    screen.key(['r'], () => updateDashboard());
+    // Scroll controls
+    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.on('resize', () => {
+        try {
+            screen.realloc?.();
+            applyLayout();
+            updateDashboard();
+        }
+        catch { }
+    });
+    // Don't auto-focus in tmux
+    const inTmux = process.env.TMUX !== undefined;
+    if (!inTmux)
+        turnBox.focus();
+    screen.program.clear();
+    updateDashboard();
+    screen.render();
+    setTimeout(() => updateWindowBox(), 2000);
+    const pollInterval = setInterval(updateDashboard, refreshMs);
+    const windowPollInterval = setInterval(updateWindowBox, 15000);
+}
+// ── Commander command ──
+exports.swarmDashboardCommand = new commander_1.Command('dashboard')
+    .description('Live TUI dashboard for monitoring swarm workers')
+    .option('--launch-ts <ts>', 'Swarm launch timestamp (auto-set by swarm launch)')
+    .option('--refresh <ms>', 'Polling interval in ms', '2000')
+    .action(async (options) => {
+    const refreshMs = parseInt(options.refresh) || 2000;
+    let launchTs;
+    if (options.launchTs) {
+        launchTs = parseInt(options.launchTs);
+    }
+    else {
+        // Try to read from active-swarm.json
+        const meta = readSwarmMeta();
+        if (meta?.launchTs) {
+            launchTs = meta.launchTs;
+            console.log(chalk_1.default.gray(`  Auto-detected swarm from ${new Date(launchTs).toLocaleTimeString()}`));
+        }
+        else {
+            console.log(chalk_1.default.red('No active swarm found.'));
+            console.log(chalk_1.default.gray('  Run "ekkos swarm launch" first.'));
+            process.exit(1);
+        }
+    }
+    await launchSwarmDashboard(launchTs, refreshMs);
+});