@ekkos/cli 1.4.2 → 1.5.0

package/dist/commands/dashboard.js

@@ -68,6 +68,8 @@ 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;
+const MAX_OUTPUT_1M_MODELS = 64000;
+const MAX_OUTPUT_200K_OPUS_SONNET = 16384;
 // ── Pricing ──
 // Pricing per MTok from https://docs.anthropic.com/en/docs/about-claude/pricing
 // Includes prompt caching rates (5m cache write=1.25x input, cache read=0.1x input).
@@ -147,6 +149,55 @@ function calculateTurnCost(model, usage, options) {
         (usage.cache_creation_tokens / 1000000) * p.cacheWrite +
         (usage.cache_read_tokens / 1000000) * p.cacheRead);
 }
+function countTools(toolStr) {
+    if (!toolStr || toolStr === '-')
+        return 0;
+    return toolStr.split(',').map(tool => tool.trim()).filter(Boolean).length;
+}
+function mergeToolStrings(...toolStrings) {
+    const merged = new Set();
+    for (const toolStr of toolStrings) {
+        if (!toolStr || toolStr === '-')
+            continue;
+        for (const tool of toolStr.split(',').map(value => value.trim()).filter(Boolean)) {
+            merged.add(tool);
+        }
+    }
+    return merged.size > 0 ? Array.from(merged).join(',') : '-';
+}
+function compareTurnCompleteness(left, right) {
+    const leftContext = left.input + left.cacheRead + left.cacheCreate;
+    const rightContext = right.input + right.cacheRead + right.cacheCreate;
+    if (left.output !== right.output)
+        return left.output - right.output;
+    if (leftContext !== rightContext)
+        return leftContext - rightContext;
+    const leftTools = countTools(left.tools);
+    const rightTools = countTools(right.tools);
+    if (leftTools !== rightTools)
+        return leftTools - rightTools;
+    const leftTs = Date.parse(left.timestamp || '');
+    const rightTs = Date.parse(right.timestamp || '');
+    const safeLeftTs = Number.isFinite(leftTs) ? leftTs : 0;
+    const safeRightTs = Number.isFinite(rightTs) ? rightTs : 0;
+    return safeLeftTs - safeRightTs;
+}
+function pickMoreCompleteTurn(left, right) {
+    const preferred = compareTurnCompleteness(left, right) >= 0 ? left : right;
+    const secondary = preferred === left ? right : left;
+    return {
+        ...preferred,
+        msgId: preferred.msgId || secondary.msgId,
+        tools: mergeToolStrings(left.tools, right.tools),
+    };
+}
+function turnsMatch(left, right) {
+    if (!left || !right)
+        return false;
+    if (left.msgId && right.msgId)
+        return left.msgId === right.msgId;
+    return left.turn === right.turn;
+}
 function getModelCtxSize(model, contextTierHint) {
     const normalized = (model || '').toLowerCase();
     if (contextTierHint === '1m')
@@ -247,7 +298,7 @@ function formatContextLaneCompact(contextSize, metadata) {
     const launchSize = typeof metadata?.claudeContextSize === 'number' ? metadata.claudeContextSize : undefined;
     const resolvedSize = explicitSize || launchSize;
     const maxOutput = metadata?.claudeMaxOutputTokens
-        || (resolvedSize && resolvedSize >= 1000000 ? 128000 : 32768);
+        || (resolvedSize && resolvedSize >= 1000000 ? MAX_OUTPUT_1M_MODELS : MAX_OUTPUT_200K_OPUS_SONNET);
     if (resolvedSize && resolvedSize >= 1000000) {
         return `1M / out ${fmtK(maxOutput)}`;
     }
@@ -264,6 +315,13 @@ function formatContextLaneCompact(contextSize, metadata) {
 function buildRuntimeSignal(label, color, value) {
     return `{${color}-fg}[${label}]{/${color}-fg} ${value}`;
 }
+function buildPreTurnRuntimeLeadSignal(metadata) {
+    const compactSelected = formatCompactLaunchModel(metadata);
+    if (compactSelected) {
+        return buildRuntimeSignal('SEL', 'cyan', compactSelected);
+    }
+    return buildRuntimeSignal('CACHE', 'green', '0%');
+}
 /** Model tag for dashboard display */
 function modelTag(model) {
     if (model.includes('opus'))
@@ -386,10 +444,10 @@ function parseJsonlFile(jsonlPath, sessionName, launchMetadata) {
                 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,
+                    msgId,
                     contextPct,
                     modelContextSize: modelCtxSize,
                     input: inputTokens,
@@ -410,66 +468,29 @@ function parseJsonlFile(jsonlPath, sessionName, launchMetadata) {
                 if (msgId) {
                     if (isNew)
                         msgIdOrder.push(msgId);
-                    turnsByMsgId.set(msgId, turnData);
+                    const existingTurn = turnsByMsgId.get(msgId);
+                    turnsByMsgId.set(msgId, existingTurn ? pickMoreCompleteTurn(existingTurn, turnData) : turnData);
                 }
             }
         }
         catch { /* skip bad lines */ }
     }
-    // Build ordered turns array from the Map (last-entry-wins dedup)
+    // Build ordered turns array from the Map using the richest snapshot seen per message id.
     const turns = msgIdOrder.map(id => turnsByMsgId.get(id));
-    const totalCost = turns.reduce((s, t) => s + t.cost, 0);
-    const totalInput = turns.reduce((s, t) => s + t.input, 0);
-    const totalCacheRead = turns.reduce((s, t) => s + t.cacheRead, 0);
-    const totalCacheCreate = turns.reduce((s, t) => s + t.cacheCreate, 0);
-    const totalOutput = turns.reduce((s, t) => s + t.output, 0);
-    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.input + lastTurn.cacheRead + lastTurn.cacheCreate
-        : 0;
-    const modelContextSize = lastTurn
-        ? lastTurn.modelContextSize
-        : resolveDashboardContextSize(model, fallbackContextWindow, launchMetadata);
-    return {
+    return buildDashboardData({
         sessionName,
         model,
-        turnCount: turns.length,
-        totalCost,
-        totalTokens: totalInput + totalCacheRead + totalCacheCreate + totalOutput,
-        totalInput,
-        totalCacheRead,
-        totalCacheCreate,
-        totalOutput,
-        avgCostPerTurn,
-        maxContextPct,
-        currentContextPct,
-        currentContextTokens,
-        modelContextSize,
-        cacheHitRate,
+        startedAt,
+        turns,
         replayAppliedCount,
         replaySkippedSizeCount,
         replaySkipStoreCount,
-        startedAt,
-        duration,
-        turns,
-    };
+        fallbackModelContextSize: resolveDashboardContextSize(model, fallbackContextWindow, launchMetadata),
+        cacheHitMode: 'read-vs-write',
+    });
 }
 function parseGeminiSessionFile(sessionPath, sessionName, launchMetadata) {
     const raw = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
@@ -505,6 +526,7 @@ function parseGeminiSessionFile(sessionPath, sessionName, launchMetadata) {
         };
         turns.push({
             turn: turns.length + 1,
+            msgId: typeof message.id === 'string' ? message.id : undefined,
             contextPct,
             modelContextSize: modelCtxSize,
             input: uncachedInput,
@@ -523,6 +545,38 @@ function parseGeminiSessionFile(sessionPath, sessionName, launchMetadata) {
             timestamp: message.timestamp || raw.lastUpdated || raw.startTime || new Date().toISOString(),
         });
     }
+    return buildDashboardData({
+        sessionName,
+        model,
+        startedAt,
+        turns,
+        replayAppliedCount: 0,
+        replaySkippedSizeCount: 0,
+        replaySkipStoreCount: 0,
+        fallbackModelContextSize: resolveDashboardContextSize(model, fallbackWindow, launchMetadata, launchMetadata?.claudeContextSize),
+        cacheHitMode: 'read-vs-total-input',
+    });
+}
+function tokenSafePercent(numerator, denominator) {
+    if (!Number.isFinite(denominator) || denominator <= 0)
+        return 0;
+    return (numerator / denominator) * 100;
+}
+function resolveCacheHitRate(turns, mode) {
+    const totalInput = turns.reduce((sum, turn) => sum + turn.input, 0);
+    const totalCacheRead = turns.reduce((sum, turn) => sum + turn.cacheRead, 0);
+    const totalCacheCreate = turns.reduce((sum, turn) => sum + turn.cacheCreate, 0);
+    if (mode === 'read-vs-write') {
+        return (totalCacheRead + totalCacheCreate) > 0
+            ? (totalCacheRead / (totalCacheRead + totalCacheCreate)) * 100
+            : 0;
+    }
+    return tokenSafePercent(totalCacheRead, totalInput + totalCacheRead);
+}
+function buildDashboardData(params) {
+    const turns = params.turns.map((turn, index) => (turn.turn === index + 1
+        ? turn
+        : { ...turn, turn: index + 1 }));
     const totalCost = turns.reduce((sum, turn) => sum + turn.cost, 0);
     const totalInput = turns.reduce((sum, turn) => sum + turn.input, 0);
     const totalCacheRead = turns.reduce((sum, turn) => sum + turn.cacheRead, 0);
@@ -531,18 +585,18 @@ function parseGeminiSessionFile(sessionPath, sessionName, launchMetadata) {
     const maxContextPct = turns.length > 0 ? Math.max(...turns.map(turn => turn.contextPct)) : 0;
     const currentContextPct = turns.length > 0 ? turns[turns.length - 1].contextPct : 0;
     const avgCostPerTurn = turns.length > 0 ? totalCost / turns.length : 0;
-    const cacheHitRate = tokenSafePercent(totalCacheRead, totalInput + totalCacheRead);
+    const cacheHitRate = resolveCacheHitRate(turns, params.cacheHitMode);
     let duration = '0m';
-    if (startedAt && turns.length > 0) {
-        const start = new Date(startedAt).getTime();
+    if (params.startedAt && turns.length > 0) {
+        const start = new Date(params.startedAt).getTime();
         const end = new Date(turns[turns.length - 1].timestamp).getTime();
         const mins = Math.max(0, Math.round((end - start) / 60000));
         duration = mins >= 60 ? `${Math.floor(mins / 60)}h${mins % 60}m` : `${mins}m`;
     }
     const lastTurn = turns.length > 0 ? turns[turns.length - 1] : null;
     return {
-        sessionName,
-        model,
+        sessionName: params.sessionName,
+        model: params.model,
         turnCount: turns.length,
         totalCost,
         totalTokens: totalInput + totalCacheRead + totalCacheCreate + totalOutput,
@@ -554,22 +608,62 @@ function parseGeminiSessionFile(sessionPath, sessionName, launchMetadata) {
         maxContextPct,
         currentContextPct,
         currentContextTokens: lastTurn ? lastTurn.input + lastTurn.cacheRead + lastTurn.cacheCreate : 0,
-        modelContextSize: lastTurn
-            ? lastTurn.modelContextSize
-            : resolveDashboardContextSize(model, fallbackWindow, launchMetadata, launchMetadata?.claudeContextSize),
+        modelContextSize: lastTurn ? lastTurn.modelContextSize : params.fallbackModelContextSize,
         cacheHitRate,
-        replayAppliedCount: 0,
-        replaySkippedSizeCount: 0,
-        replaySkipStoreCount: 0,
-        startedAt,
+        replayAppliedCount: params.replayAppliedCount || 0,
+        replaySkippedSizeCount: params.replaySkippedSizeCount || 0,
+        replaySkipStoreCount: params.replaySkipStoreCount || 0,
+        startedAt: params.startedAt,
         duration,
         turns,
     };
 }
-function tokenSafePercent(numerator, denominator) {
-    if (!Number.isFinite(denominator) || denominator <= 0)
-        return 0;
-    return (numerator / denominator) * 100;
+function reconcileDashboardData(previous, next) {
+    if (!previous || previous.sessionName !== next.sessionName || previous.turns.length === 0) {
+        return next;
+    }
+    const mergedTurns = next.turns.map(turn => ({ ...turn }));
+    const previousTurns = previous.turns;
+    if (mergedTurns.length === 0) {
+        return previous;
+    }
+    const previousLast = previousTurns[previousTurns.length - 1];
+    const nextLast = mergedTurns[mergedTurns.length - 1];
+    const keepLastMutable = turnsMatch(previousLast, nextLast);
+    const freezeCount = Math.min(previousTurns.length - (keepLastMutable ? 1 : 0), mergedTurns.length);
+    for (let index = 0; index < freezeCount; index++) {
+        if (!turnsMatch(previousTurns[index], mergedTurns[index]))
+            continue;
+        mergedTurns[index] = pickMoreCompleteTurn(previousTurns[index], mergedTurns[index]);
+    }
+    if (keepLastMutable) {
+        const tailIndex = previousTurns.length - 1;
+        if (tailIndex < mergedTurns.length && turnsMatch(previousTurns[tailIndex], mergedTurns[tailIndex])) {
+            mergedTurns[tailIndex] = pickMoreCompleteTurn(previousTurns[tailIndex], mergedTurns[tailIndex]);
+        }
+    }
+    if (previousTurns.length > mergedTurns.length) {
+        const prefixMatches = mergedTurns.every((turn, index) => turnsMatch(previousTurns[index], turn));
+        if (prefixMatches) {
+            for (let index = mergedTurns.length; index < previousTurns.length; index++) {
+                mergedTurns.push({ ...previousTurns[index] });
+            }
+        }
+    }
+    const cacheHitMode = mergedTurns.some(turn => Boolean(turn.msgId))
+        ? 'read-vs-write'
+        : 'read-vs-total-input';
+    return buildDashboardData({
+        sessionName: next.sessionName,
+        model: next.model,
+        startedAt: next.startedAt || previous.startedAt,
+        turns: mergedTurns,
+        replayAppliedCount: Math.max(previous.replayAppliedCount, next.replayAppliedCount),
+        replaySkippedSizeCount: Math.max(previous.replaySkippedSizeCount, next.replaySkippedSizeCount),
+        replaySkipStoreCount: Math.max(previous.replaySkipStoreCount, next.replaySkipStoreCount),
+        fallbackModelContextSize: next.modelContextSize || previous.modelContextSize,
+        cacheHitMode,
+    });
 }
 function readJsonFile(filePath) {
     try {
@@ -661,9 +755,9 @@ function formatLaunchWindowLabel(metadata) {
         ? metadata.claudeContextSize
         : undefined;
     if (window === '200k')
-        return `Window ${fmtK(exactSize || 200000)} · out ${fmtK(metadata?.claudeMaxOutputTokens || 32768)}`;
+        return `Window ${fmtK(exactSize || 200000)} · out ${fmtK(metadata?.claudeMaxOutputTokens || MAX_OUTPUT_200K_OPUS_SONNET)}`;
     if (window === '1m')
-        return `Window ${fmtK(exactSize || 1000000)} · out ${fmtK(metadata?.claudeMaxOutputTokens || 128000)}`;
+        return `Window ${fmtK(exactSize || 1000000)} · out ${fmtK(metadata?.claudeMaxOutputTokens || MAX_OUTPUT_1M_MODELS)}`;
     if (typeof metadata?.claudeContextSize === 'number' && metadata.claudeContextSize > 0) {
         return `Window ${fmtK(metadata.claudeContextSize)}`;
     }
@@ -1034,6 +1128,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     const blessed = require('blessed');
     const contrib = require('blessed-contrib');
     const inTmux = process.env.TMUX !== undefined;
+    const needsTmuxResizeRecovery = inTmux && process.platform === 'darwin';
     // ══════════════════════════════════════════════════════════════════════════
     // TMUX SPLIT PANE ISOLATION
     // When dashboard runs in a separate tmux pane from `ekkos run`, blessed must
@@ -1072,13 +1167,52 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         mouse: false, // Disable ALL mouse capture (allows terminal text selection)
         grabKeys: false, // Don't grab keyboard input from other panes
         sendFocus: false, // Don't send focus events (breaks paste)
-        ignoreLocked: ['C-c', 'C-q', 'f7'], // Capture Ctrl+C, Ctrl+Q for quit, F7 for hard refresh
+        ignoreLocked: ['C-c', 'C-q', 'f7', 'C-f7'], // Capture quit + redraw keys even when widgets are passive
         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
     });
+    function readTerminalSize() {
+        const candidates = [ttyOutput, screen.program?.output, process.stdout];
+        for (const candidate of candidates) {
+            if (!candidate)
+                continue;
+            try {
+                if (typeof candidate.getWindowSize === 'function') {
+                    const size = candidate.getWindowSize();
+                    if (Array.isArray(size) && size.length >= 2) {
+                        const [cols, rows] = size;
+                        if (cols > 0 && rows > 0)
+                            return { cols, rows };
+                    }
+                }
+            }
+            catch { }
+            const cols = Number(candidate.columns);
+            const rows = Number(candidate.rows);
+            if (cols > 0 && rows > 0)
+                return { cols, rows };
+        }
+        return null;
+    }
+    function syncProgramSizeFromTTY(source) {
+        const program = screen.program;
+        if (!program)
+            return false;
+        const size = readTerminalSize();
+        if (!size)
+            return false;
+        const cols = Math.max(20, size.cols);
+        const rows = Math.max(10, size.rows);
+        if (program.cols === cols && program.rows === rows)
+            return false;
+        dlog(`TTY geometry sync (${source}): ${program.cols}x${program.rows} -> ${cols}x${rows}`);
+        program.cols = cols;
+        program.rows = rows;
+        return true;
+    }
     // ══════════════════════════════════════════════════════════════════════════
     // DISABLE TERMINAL CONTROL SEQUENCE HIJACKING (TMUX ONLY)
     // When running in a tmux split pane alongside Claude Code, prevent blessed
@@ -1115,7 +1249,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     // No percentages = no gaps.
     //
     //  header:   3 rows (session stats + animated logo)
-    //  context:  5 rows (progress bar + cost breakdown + cache stats)
+    //  context:  5-6 rows (progress bar + runtime stats + cache/cost summary)
     //  chart:    ~25-34% of remaining (token usage graph)
     //  table:    ~66-75% of remaining (turn-by-turn breakdown)
     //  usage:    3 rows (Anthropic rate limit window)
@@ -1158,11 +1292,19 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     }
     const W = '100%';
     const HEADER_H = 3;
-    const CONTEXT_H = 5;
     const USAGE_H = 4;
     const FOOTER_H = 3;
     const MASCOT_W = 16; // Width reserved for runtime mascot in context box
-    const FIXED_H = HEADER_H + CONTEXT_H + USAGE_H + FOOTER_H; // 15
+    function resolveContextHeight(height) {
+        return height >= 36 ? 6 : 5;
+    }
+    function resolveChartMinHeight(height) {
+        if (height >= 28)
+            return 6;
+        if (height >= 26)
+            return 5;
+        return 4;
+    }
     function resolveChartRatio(height) {
         if (height >= 62)
             return 0.25;
@@ -1174,9 +1316,14 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     }
     function calcLayout() {
         const H = Math.max(24, screen.height || 24);
+        const CONTEXT_H = resolveContextHeight(H);
+        const FIXED_H = HEADER_H + CONTEXT_H + USAGE_H + FOOTER_H;
         const remaining = Math.max(8, H - FIXED_H);
-        const chartH = Math.max(6, Math.floor(remaining * resolveChartRatio(H)));
-        const tableH = Math.max(5, remaining - chartH);
+        const tableMin = 5;
+        const chartMin = resolveChartMinHeight(H);
+        const chartTarget = Math.floor(remaining * resolveChartRatio(H));
+        const chartH = Math.max(chartMin, Math.min(chartTarget, remaining - tableMin));
+        const tableH = Math.max(tableMin, remaining - chartH);
         return {
             header: { top: 0, height: HEADER_H },
             context: { top: HEADER_H, height: CONTEXT_H },
@@ -1378,13 +1525,17 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     // 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() {
+    function ensureLayoutSynced(source = 'layout') {
+        const geometryChanged = syncProgramSizeFromTTY(source);
         const w = screen.width || 0;
         const h = screen.height || 0;
         if (w === lastLayoutW && h === lastLayoutH)
             return;
         lastLayoutW = w;
         lastLayoutH = h;
+        if (geometryChanged && needsTmuxResizeRecovery) {
+            scheduleResizeRecovery(source);
+        }
         try {
             screen.realloc?.();
         }
@@ -1478,11 +1629,14 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         try {
             const launchModelLabel = formatLaunchModelLabel(launchMetadata);
             const launchWindowLabel = formatLaunchWindowLabel(launchMetadata);
-            const compactSelected = formatCompactLaunchModel(launchMetadata) || 'Awaiting profile';
             const compactLane = formatContextLaneCompact(launchMetadata?.claudeContextSize, launchMetadata) || 'Awaiting lane';
+            const extendedContext = (layout.context.height || 0) >= 6;
             contextBox.setContent(` {green-fg}Session active{/green-fg}  {gray-fg}${sessionName}{/gray-fg}\n` +
-                ` ${buildRuntimeSignal('SEL', 'cyan', compactSelected)} {gray-fg}│{/gray-fg} ${buildRuntimeSignal('ACT', 'magenta', 'standby')} {gray-fg}│{/gray-fg} ${buildRuntimeSignal('LANE', 'yellow', compactLane)}\n` +
-                ` ${[launchModelLabel, launchWindowLabel].filter(Boolean).join('  ') || 'Token and cost metrics appear after the first assistant response.'}`);
+                ` ${buildPreTurnRuntimeLeadSignal(launchMetadata)} {gray-fg}│{/gray-fg} ${buildRuntimeSignal('ACT', 'magenta', 'standby')} {gray-fg}│{/gray-fg} ${buildRuntimeSignal('LANE', 'yellow', compactLane)}\n` +
+                ` ${[launchModelLabel, launchWindowLabel].filter(Boolean).join('  ') || 'Token and cost metrics appear after the first assistant response.'}` +
+                (extendedContext
+                    ? `\n {gray-fg}Cache, peak context, and routed cost appear after the first assistant response.{/gray-fg}`
+                    : ''));
             turnBox.setContent(`{bold}Turns{/bold}\n` +
                 `{gray-fg}—{/gray-fg}`);
             const timerStr = sessionStartMs
@@ -1491,8 +1645,8 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             footerBox.setLabel(` ${sessionName} `);
             footerBox.setContent(` ${timerStr}{green-fg}Ready{/green-fg}` +
                 (inTmux
-                    ? `  {gray-fg}Ctrl+Q quit  F7 redraw{/gray-fg}`
-                    : `  {gray-fg}? help  q quit  r refresh  F7 redraw{/gray-fg}`));
+                    ? `  {gray-fg}Ctrl+Q quit  Ctrl+F7/F7 redraw{/gray-fg}`
+                    : `  {gray-fg}? help  q quit  r refresh  Ctrl+F7/F7 redraw{/gray-fg}`));
         }
         catch (err) {
             dlog(`Pre-turn render: ${err.message}`);
@@ -1562,7 +1716,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             launchMetadata = readSessionLaunchMetadata(sessionName) || launchMetadata;
             provider = inferDashboardProvider(initialProvider, launchMetadata, jsonlPath);
             renderRuntimeMascot();
-            data = parseTranscriptFile(jsonlPath, provider, sessionName, launchMetadata);
+            data = reconcileDashboardData(lastData && lastData.sessionName === sessionName ? lastData : null, parseTranscriptFile(jsonlPath, provider, sessionName, launchMetadata));
             lastData = data;
             if (!sessionStartMs && data.startedAt) {
                 sessionStartMs = new Date(data.startedAt).getTime();
@@ -1610,19 +1764,24 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             // Cache stats
             const hitColor = data.cacheHitRate >= 80 ? 'green' : data.cacheHitRate >= 50 ? 'yellow' : 'red';
             const cappedMax = Math.min(data.maxContextPct, 100);
+            const extendedContext = (layout.context.height || 0) >= 6;
             contextBox.setContent(` ${bar}\n` +
                 ` ${buildRuntimeSignal('SEL', 'cyan', selectedProfile)} {gray-fg}│{/gray-fg} ${buildRuntimeSignal('ACT', 'magenta', activeModel)} {gray-fg}│{/gray-fg} ${buildRuntimeSignal('LANE', 'yellow', laneLabel)}\n` +
                 ` {${ctxColor}-fg}${ctxPct.toFixed(0)}%{/${ctxColor}-fg} ${tokensLabel}/${maxLabel}` +
-                `  {white-fg}In{/white-fg} $${breakdown.input.toFixed(2)}` +
-                `  {green-fg}Read{/green-fg} $${breakdown.read.toFixed(2)}` +
-                `  {yellow-fg}Write{/yellow-fg} $${breakdown.write.toFixed(2)}` +
-                `  {cyan-fg}Out{/cyan-fg} $${breakdown.output.toFixed(2)}` +
                 `  {${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}`);
+                (extendedContext
+                    ? `\n  {white-fg}In{/white-fg} $${breakdown.input.toFixed(2)}` +
+                        `  {green-fg}Read{/green-fg} $${breakdown.read.toFixed(2)}` +
+                        `  {yellow-fg}Write{/yellow-fg} $${breakdown.write.toFixed(2)}` +
+                        `  {cyan-fg}Out{/cyan-fg} $${breakdown.output.toFixed(2)}` +
+                        `  replay A:${data.replayAppliedCount}` +
+                        ` SZ:${data.replaySkippedSizeCount}` +
+                        ` ST:${data.replaySkipStoreCount}`
+                    : `  {white-fg}In{/white-fg} $${breakdown.input.toFixed(2)}` +
+                        `  {cyan-fg}Out{/cyan-fg} $${breakdown.output.toFixed(2)}` +
+                        `  R:${data.replayAppliedCount}/${data.replaySkippedSizeCount}/${data.replaySkipStoreCount}`));
         }
         catch (err) {
             dlog(`Context: ${err.message}`);
@@ -1781,8 +1940,8 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                 `  R[A:${d.replayAppliedCount} SZ:${d.replaySkippedSizeCount} ST:${d.replaySkipStoreCount}]` +
                 savingsStr +
                 (inTmux
-                    ? `  {gray-fg}Ctrl+Q quit  F7 redraw{/gray-fg}`
-                    : `  {gray-fg}? help  q quit  r refresh  F7 redraw{/gray-fg}`));
+                    ? `  {gray-fg}Ctrl+Q quit  Ctrl+F7/F7 redraw{/gray-fg}`
+                    : `  {gray-fg}? help  q quit  r refresh  Ctrl+F7/F7 redraw{/gray-fg}`));
         }
         catch (err) {
             dlog(`Footer: ${err.message}`);
@@ -2361,7 +2520,18 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     // Full dashboard redraw used by F7 and manual refresh recovery paths.
     let hardRedrawInFlight = false;
     let lastHardRedrawAt = 0;
+    let resizeRecoveryTimer = null;
     const HARD_REDRAW_DEBOUNCE_MS = 200;
+    function scheduleResizeRecovery(source) {
+        if (!needsTmuxResizeRecovery)
+            return;
+        if (resizeRecoveryTimer)
+            clearTimeout(resizeRecoveryTimer);
+        resizeRecoveryTimer = setTimeout(() => {
+            resizeRecoveryTimer = null;
+            void hardRedraw(`${source}-resize-recovery`);
+        }, 120);
+    }
     async function hardRedraw(source) {
         const now = Date.now();
         if (hardRedrawInFlight)
@@ -2408,13 +2578,18 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     // F7 escape-sequence fallback for terminals/tmux states where blessed key names
     // are not emitted reliably. Supports plain and modifier variants.
     const F7_ESCAPE_RE = /\x1b\[18(?:;\d+)?~/;
+    const CTRL_F7_ESCAPE_RE = /\x1b\[18;5~/;
     let detachRawF7Listener = null;
+    let rawKeyBuffer = '';
     if (ttyInput && typeof ttyInput.on === 'function') {
         const onRawInput = (chunk) => {
             const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-            if (!F7_ESCAPE_RE.test(text))
+            rawKeyBuffer = `${rawKeyBuffer}${text}`.slice(-64);
+            const match = rawKeyBuffer.match(F7_ESCAPE_RE);
+            if (!match)
                 return;
-            void hardRedraw('f7-escape');
+            rawKeyBuffer = '';
+            void hardRedraw(CTRL_F7_ESCAPE_RE.test(match[0]) ? 'ctrl-f7-escape' : 'f7-escape');
         };
         ttyInput.on('data', onRawInput);
         detachRawF7Listener = () => {
@@ -2427,6 +2602,43 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             catch { }
         };
     }
+    let detachSigwinchListener = null;
+    if (process.platform !== 'win32') {
+        const onSigwinch = () => {
+            try {
+                if (!syncProgramSizeFromTTY('sigwinch'))
+                    return;
+                lastLayoutW = 0;
+                lastLayoutH = 0;
+                ensureLayoutSynced('sigwinch');
+                if (lastData) {
+                    updateDashboard();
+                }
+                else {
+                    if (lastChartSeries) {
+                        try {
+                            tokenChart.setData(lastChartSeries);
+                        }
+                        catch { }
+                    }
+                    try {
+                        screen.render();
+                    }
+                    catch { }
+                }
+            }
+            catch (err) {
+                dlog(`SIGWINCH: ${err.message}`);
+            }
+        };
+        process.on('SIGWINCH', onSigwinch);
+        detachSigwinchListener = () => {
+            try {
+                process.off('SIGWINCH', onSigwinch);
+            }
+            catch { }
+        };
+    }
     // ── Handle terminal resize ──
     // Recalculate all widget positions from new screen.height
     screen.on('resize', () => {
@@ -2438,7 +2650,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             catch { }
             lastLayoutW = 0;
             lastLayoutH = 0;
-            ensureLayoutSynced();
+            ensureLayoutSynced('screen-resize');
             if (lastData) {
                 updateDashboard();
             }
@@ -2463,6 +2675,9 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     // ══════════════════════════════════════════════════════════════════════════
     function shutdownDashboard() {
         detachRawF7Listener?.();
+        detachSigwinchListener?.();
+        if (resizeRecoveryTimer)
+            clearTimeout(resizeRecoveryTimer);
         clearInterval(pollInterval);
         clearInterval(windowPollInterval);
         clearInterval(tickInterval);
@@ -2477,8 +2692,8 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     // F7 — Hard refresh / redraw (works in both tmux and standalone mode)
     // Forces a full screen realloc + layout recalculation to fix corruption
     // from rapid terminal resizing. Session data is preserved.
-    screen.key(['f7', 'F7'], () => {
-        void hardRedraw('f7-key');
+    screen.key(['f7', 'F7', 'C-f7'], (_ch, key) => {
+        void hardRedraw(key?.ctrl ? 'ctrl-f7-key' : 'f7-key');
     });
     if (!inTmux) {
         screen.key(['q'], () => {
@@ -2539,6 +2754,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                     '\n' +
                     '{bold}Controls{/bold}\n' +
                     '  r          Refresh now\n' +
+                    '  Ctrl+F7    Hard redraw (mac fallback)\n' +
                     '  F7         Hard redraw (fixes corruption)\n' +
                     '  q/Ctrl+Q   Quit\n' +
                     '\n' +