@ekkos/cli 1.3.9 → 1.4.1

package/dist/commands/dashboard.js

@@ -87,10 +87,31 @@ const MODEL_PRICING = {
     'claude-sonnet-4': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
     'claude-haiku-4-5-20251001': { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.10 },
     'claude-haiku-4-5': { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.10 },
+    'gemini-3.1-flash-lite-preview': { input: 0.05, output: 0.20, cacheWrite: 0, cacheRead: 0.05 },
+    'gemini-3.1-pro-preview': { input: 1.25, output: 5.00, cacheWrite: 0, cacheRead: 1.25 },
+    'gemini-3-pro-preview': { input: 1.25, output: 5.00, cacheWrite: 0, cacheRead: 1.25 },
+    'gemini-3-flash-preview': { input: 0.075, output: 0.30, cacheWrite: 0, cacheRead: 0.075 },
+    'gemini-2.5-flash-lite': { input: 0.05, output: 0.20, cacheWrite: 0, cacheRead: 0.05 },
+    'gemini-2.5-pro': { input: 1.25, output: 5.00, cacheWrite: 0, cacheRead: 1.25 },
+    'gemini-2.5-flash': { input: 0.075, output: 0.30, cacheWrite: 0, cacheRead: 0.075 },
 };
 function getModelPricing(modelId) {
     if (MODEL_PRICING[modelId])
         return MODEL_PRICING[modelId];
+    if (modelId.includes('gemini-3.1-pro'))
+        return MODEL_PRICING['gemini-3.1-pro-preview'];
+    if (modelId.includes('gemini-3-pro'))
+        return MODEL_PRICING['gemini-3-pro-preview'];
+    if (modelId.includes('gemini-3.1-flash-lite'))
+        return MODEL_PRICING['gemini-3.1-flash-lite-preview'];
+    if (modelId.includes('gemini-3-flash'))
+        return MODEL_PRICING['gemini-3-flash-preview'];
+    if (modelId.includes('gemini-2.5-pro'))
+        return MODEL_PRICING['gemini-2.5-pro'];
+    if (modelId.includes('gemini-2.5-flash-lite'))
+        return MODEL_PRICING['gemini-2.5-flash-lite'];
+    if (modelId.includes('gemini-2.5-flash'))
+        return MODEL_PRICING['gemini-2.5-flash'];
     if (modelId.includes('opus'))
         return MODEL_PRICING['claude-opus-4-6'];
     if (modelId.includes('sonnet'))
@@ -130,12 +151,15 @@ function getModelCtxSize(model, contextTierHint) {
     const normalized = (model || '').toLowerCase();
     if (contextTierHint === '1m')
         return 1000000;
+    if (contextTierHint === '200k')
+        return 200000;
     // Claude 4.6 has GA 1M context in Claude Code/API.
     if (/^claude-(?:opus|sonnet)-4-6(?:$|-)/.test(normalized))
         return 1000000;
-    // Keep Gemini on the 1M class in dashboard context math.
+    if (normalized.startsWith('gemini-3.1-pro') || normalized.startsWith('gemini-3-pro'))
+        return 2097152;
     if (normalized.startsWith('gemini-'))
-        return 1000000;
+        return 1048576;
     if (normalized.includes('1m'))
         return 1000000;
     if (normalized.includes('opus'))
@@ -146,6 +170,100 @@ function getModelCtxSize(model, contextTierHint) {
         return 200000;
     return 200000; // Default Anthropic context
 }
+function parseExplicitContextWindowSize(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value.trim());
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return Math.floor(parsed);
+        }
+    }
+    return undefined;
+}
+function resolveDashboardContextSize(model, contextTierHint, launchMetadata, explicitContextWindow) {
+    const explicitSize = parseExplicitContextWindowSize(explicitContextWindow);
+    if (explicitSize)
+        return explicitSize;
+    if (typeof launchMetadata?.claudeContextSize === 'number' && launchMetadata.claudeContextSize > 0) {
+        return launchMetadata.claudeContextSize;
+    }
+    const launchWindowHint = normalizeLaunchContextWindow(launchMetadata?.claudeContextWindow);
+    return getModelCtxSize(model, contextTierHint || launchWindowHint);
+}
+function humanizeModelName(model, includeVendor = false) {
+    if (!model)
+        return null;
+    const normalized = model.toLowerCase();
+    const prefix = includeVendor ? 'Claude ' : '';
+    if (normalized.includes('claude-opus-4-6'))
+        return `${prefix}Opus 4.6`;
+    if (normalized.includes('claude-opus-4-5'))
+        return `${prefix}Opus 4.5`;
+    if (normalized.includes('claude-sonnet-4-6'))
+        return `${prefix}Sonnet 4.6`;
+    if (normalized.includes('claude-sonnet-4-5'))
+        return `${prefix}Sonnet 4.5`;
+    if (normalized.includes('claude-haiku-4-5'))
+        return `${prefix}Haiku 4.5`;
+    if (normalized.includes('gemini-3.1-pro'))
+        return includeVendor ? 'Gemini 3.1 Pro' : 'Gemini 3.1 Pro';
+    if (normalized.includes('gemini-3-pro'))
+        return includeVendor ? 'Gemini 3 Pro' : 'Gemini 3 Pro';
+    if (normalized.includes('gemini-3.1-flash-lite'))
+        return includeVendor ? 'Gemini 3.1 Flash Lite' : 'Gemini 3.1 Flash Lite';
+    if (normalized.includes('gemini-3-flash'))
+        return includeVendor ? 'Gemini 3 Flash' : 'Gemini 3 Flash';
+    if (normalized.includes('gemini-2.5-pro'))
+        return includeVendor ? 'Gemini 2.5 Pro' : 'Gemini 2.5 Pro';
+    if (normalized.includes('gemini-2.5-flash-lite'))
+        return includeVendor ? 'Gemini 2.5 Flash Lite' : 'Gemini 2.5 Flash Lite';
+    if (normalized.includes('gemini-2.5-flash'))
+        return includeVendor ? 'Gemini 2.5 Flash' : 'Gemini 2.5 Flash';
+    if (normalized.startsWith('gemini-'))
+        return includeVendor ? 'Gemini' : 'Gemini';
+    if (normalized.startsWith('gpt-'))
+        return model;
+    return model;
+}
+function formatCompactLaunchModel(metadata) {
+    const model = metadata?.claudeModel || metadata?.claudeLaunchModel;
+    const label = humanizeModelName(model, false);
+    if (!label)
+        return null;
+    const window = normalizeLaunchContextWindow(metadata?.claudeContextWindow);
+    if (window === '200k')
+        return `${label} [200K]`;
+    if (window === '1m')
+        return `${label} [1M]`;
+    return label;
+}
+function formatActiveRoutedModel(model) {
+    return humanizeModelName(model, false);
+}
+function formatContextLaneCompact(contextSize, metadata) {
+    const explicitSize = parseExplicitContextWindowSize(contextSize);
+    const launchSize = typeof metadata?.claudeContextSize === 'number' ? metadata.claudeContextSize : undefined;
+    const resolvedSize = explicitSize || launchSize;
+    const maxOutput = metadata?.claudeMaxOutputTokens
+        || (resolvedSize && resolvedSize >= 1000000 ? 128000 : 32768);
+    if (resolvedSize && resolvedSize >= 1000000) {
+        return `1M / out ${fmtK(maxOutput)}`;
+    }
+    if (resolvedSize && resolvedSize > 0) {
+        return `200K / out ${fmtK(maxOutput)}`;
+    }
+    const launchWindow = normalizeLaunchContextWindow(metadata?.claudeContextWindow);
+    if (launchWindow === '1m')
+        return `1M / out ${fmtK(maxOutput)}`;
+    if (launchWindow === '200k')
+        return `200K / out ${fmtK(maxOutput)}`;
+    return null;
+}
+function buildRuntimeSignal(label, color, value) {
+    return `{${color}-fg}[${label}]{/${color}-fg} ${value}`;
+}
 /** Model tag for dashboard display */
 function modelTag(model) {
     if (model.includes('opus'))
@@ -154,6 +272,8 @@ function modelTag(model) {
         return 'Sonnet';
     if (model.includes('haiku'))
         return 'Haiku';
+    if (model.includes('gemini'))
+        return 'Gem';
     return '?';
 }
 function parseCacheHintValue(cacheHint, key) {
@@ -169,14 +289,15 @@ function parseCacheHintValue(cacheHint, key) {
     }
     return null;
 }
-function parseJsonlFile(jsonlPath, sessionName) {
+function parseJsonlFile(jsonlPath, sessionName, launchMetadata) {
     const content = fs.readFileSync(jsonlPath, 'utf-8');
     const lines = content.trim().split('\n');
     const turnsByMsgId = new Map();
     const msgIdOrder = [];
     let startedAt = '';
-    let model = 'unknown';
+    let model = launchMetadata?.claudeModel || launchMetadata?.claudeLaunchModel || 'unknown';
     const toolsByMessage = new Map();
+    const fallbackContextWindow = normalizeLaunchContextWindow(launchMetadata?.claudeContextWindow);
     for (const line of lines) {
         try {
             const entry = JSON.parse(line);
@@ -226,7 +347,7 @@ function parseJsonlFile(jsonlPath, sessionName) {
                     : (parseCacheHintValue(cacheHint, 'eviction') || 'unknown');
                 const contextTierHint = typeof entry.message._ekkos_context_tier === 'string'
                     ? entry.message._ekkos_context_tier.trim().toLowerCase()
-                    : undefined;
+                    : fallbackContextWindow;
                 const explicitExtraUsage = entry.message._ekkos_extra_usage === true
                     || entry.message._ekkos_extra_usage === '1'
                     || entry.message._ekkos_extra_usage === 'true';
@@ -235,7 +356,7 @@ function parseJsonlFile(jsonlPath, sessionName) {
                 const cacheReadTokens = usage.cache_read_input_tokens || 0;
                 const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
                 const contextTokens = inputTokens + cacheReadTokens + cacheCreationTokens;
-                const modelCtxSize = getModelCtxSize(routedModel, contextTierHint);
+                const modelCtxSize = resolveDashboardContextSize(routedModel, contextTierHint, launchMetadata, entry.message._ekkos_context_window);
                 const contextPct = (contextTokens / modelCtxSize) * 100;
                 const ts = entry.timestamp || new Date().toISOString();
                 if (!startedAt)
@@ -325,7 +446,7 @@ function parseJsonlFile(jsonlPath, sessionName) {
         : 0;
     const modelContextSize = lastTurn
         ? lastTurn.modelContextSize
-        : getModelCtxSize(model);
+        : resolveDashboardContextSize(model, fallbackContextWindow, launchMetadata);
     return {
         sessionName,
         model,
@@ -350,6 +471,106 @@ function parseJsonlFile(jsonlPath, sessionName) {
         turns,
     };
 }
+function parseGeminiSessionFile(sessionPath, sessionName, launchMetadata) {
+    const raw = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+    const messages = Array.isArray(raw.messages) ? raw.messages : [];
+    const turns = [];
+    const fallbackWindow = normalizeLaunchContextWindow(launchMetadata?.claudeContextWindow) || '1m';
+    let model = launchMetadata?.claudeModel || launchMetadata?.claudeLaunchModel || 'gemini';
+    const startedAt = raw.startTime || messages.find(m => typeof m.timestamp === 'string')?.timestamp || '';
+    for (const message of messages) {
+        if (message?.type !== 'gemini' || !message.tokens)
+            continue;
+        const tokenInput = Math.max(0, Number(message.tokens.input || 0));
+        const tokenCached = Math.max(0, Math.min(tokenInput, Number(message.tokens.cached || 0)));
+        const tokenOutput = Math.max(0, Number(message.tokens.output || 0));
+        const tokenThoughts = Math.max(0, Number(message.tokens.thoughts || 0));
+        const tokenTool = Math.max(0, Number(message.tokens.tool || 0));
+        const uncachedInput = Math.max(0, tokenInput - tokenCached);
+        const effectiveOutput = tokenOutput + tokenThoughts + tokenTool;
+        const routedModel = message.model || model;
+        model = routedModel;
+        const modelCtxSize = resolveDashboardContextSize(routedModel, fallbackWindow, launchMetadata, launchMetadata?.claudeContextSize);
+        const contextPct = modelCtxSize > 0 ? (tokenInput / modelCtxSize) * 100 : 0;
+        const toolNames = Array.isArray(message.toolCalls)
+            ? Array.from(new Set(message.toolCalls
+                .map(tool => typeof tool?.name === 'string' ? tool.name : '')
+                .filter(Boolean)))
+            : [];
+        const usageData = {
+            input_tokens: uncachedInput,
+            output_tokens: effectiveOutput,
+            cache_read_tokens: tokenCached,
+            cache_creation_tokens: 0,
+        };
+        turns.push({
+            turn: turns.length + 1,
+            contextPct,
+            modelContextSize: modelCtxSize,
+            input: uncachedInput,
+            cacheRead: tokenCached,
+            cacheCreate: 0,
+            output: effectiveOutput,
+            cost: calculateTurnCost(routedModel, usageData),
+            opusCost: calculateTurnCost(routedModel, usageData),
+            savings: 0,
+            tools: toolNames.length > 0 ? toolNames.join(',') : '-',
+            model: routedModel,
+            routedModel,
+            replayState: 'n/a',
+            replayStore: 'n/a',
+            evictionState: 'n/a',
+            timestamp: message.timestamp || raw.lastUpdated || raw.startTime || new Date().toISOString(),
+        });
+    }
+    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);
+    const totalCacheCreate = turns.reduce((sum, turn) => sum + turn.cacheCreate, 0);
+    const totalOutput = turns.reduce((sum, turn) => sum + turn.output, 0);
+    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);
+    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.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,
+        turnCount: turns.length,
+        totalCost,
+        totalTokens: totalInput + totalCacheRead + totalCacheCreate + totalOutput,
+        totalInput,
+        totalCacheRead,
+        totalCacheCreate,
+        totalOutput,
+        avgCostPerTurn,
+        maxContextPct,
+        currentContextPct,
+        currentContextTokens: lastTurn ? lastTurn.input + lastTurn.cacheRead + lastTurn.cacheCreate : 0,
+        modelContextSize: lastTurn
+            ? lastTurn.modelContextSize
+            : resolveDashboardContextSize(model, fallbackWindow, launchMetadata, launchMetadata?.claudeContextSize),
+        cacheHitRate,
+        replayAppliedCount: 0,
+        replaySkippedSizeCount: 0,
+        replaySkipStoreCount: 0,
+        startedAt,
+        duration,
+        turns,
+    };
+}
+function tokenSafePercent(numerator, denominator) {
+    if (!Number.isFinite(denominator) || denominator <= 0)
+        return 0;
+    return (numerator / denominator) * 100;
+}
 function readJsonFile(filePath) {
     try {
         if (!fs.existsSync(filePath))
@@ -360,6 +581,94 @@ function readJsonFile(filePath) {
         return null;
     }
 }
+function normalizeLaunchContextWindow(value) {
+    const normalized = (value || '').trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === 'auto')
+        return 'auto';
+    if (normalized === '200k' || normalized === '200000')
+        return '200k';
+    if (normalized === '1m' || normalized === '1000000')
+        return '1m';
+    return undefined;
+}
+function normalizeDashboardProvider(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (normalized === 'gemini' || normalized === 'google')
+        return 'gemini';
+    if (normalized === 'claude' || normalized === 'anthropic')
+        return 'claude';
+    return undefined;
+}
+function readSessionLaunchMetadata(sessionName) {
+    const candidates = [];
+    const active = (0, state_js_1.getActiveSessions)()
+        .filter((session) => session.sessionName === sessionName)
+        .sort((a, b) => (b.lastHeartbeat || '').localeCompare(a.lastHeartbeat || ''));
+    if (active.length > 0)
+        candidates.push(active[0]);
+    const sessionHint = readJsonFile(path.join(state_js_1.EKKOS_DIR, 'session-hint.json'));
+    if (!sessionHint || !sessionHint.session_name || sessionHint.session_name === sessionName) {
+        if (sessionHint)
+            candidates.push(sessionHint);
+    }
+    const current = readJsonFile(path.join(state_js_1.EKKOS_DIR, 'current-session.json'));
+    if (!current || !current.session_name || current.session_name === sessionName) {
+        if (current)
+            candidates.push(current);
+    }
+    for (const candidate of candidates) {
+        if (candidate.provider
+            || candidate.geminiProjectId
+            || candidate.claudeModel
+            || candidate.claudeLaunchModel
+            || candidate.claudeProfile
+            || candidate.claudeContextWindow
+            || candidate.claudeContextSize) {
+            return {
+                provider: normalizeDashboardProvider(candidate.provider),
+                claudeModel: typeof candidate.claudeModel === 'string' ? candidate.claudeModel : undefined,
+                claudeLaunchModel: typeof candidate.claudeLaunchModel === 'string' ? candidate.claudeLaunchModel : undefined,
+                claudeProfile: typeof candidate.claudeProfile === 'string' ? candidate.claudeProfile : undefined,
+                claudeContextWindow: normalizeLaunchContextWindow(typeof candidate.claudeContextWindow === 'string' ? candidate.claudeContextWindow : undefined),
+                claudeContextSize: typeof candidate.claudeContextSize === 'number' ? candidate.claudeContextSize : undefined,
+                claudeMaxOutputTokens: typeof candidate.claudeMaxOutputTokens === 'number' ? candidate.claudeMaxOutputTokens : undefined,
+                claudeCodeVersion: typeof candidate.claudeCodeVersion === 'string' ? candidate.claudeCodeVersion : undefined,
+                geminiProjectId: typeof candidate.geminiProjectId === 'string' ? candidate.geminiProjectId : undefined,
+                dashboardEnabled: candidate.dashboardEnabled === true,
+                bypassEnabled: candidate.bypassEnabled === true,
+            };
+        }
+    }
+    return null;
+}
+function formatLaunchModelLabel(metadata) {
+    const model = metadata?.claudeModel || metadata?.claudeLaunchModel;
+    if (!model)
+        return null;
+    const window = normalizeLaunchContextWindow(metadata?.claudeContextWindow);
+    const label = humanizeModelName(model, true) || model;
+    if (window === '200k')
+        return `${label} [200K]`;
+    if (window === '1m')
+        return `${label} [1M]`;
+    return label;
+}
+function formatLaunchWindowLabel(metadata) {
+    const window = normalizeLaunchContextWindow(metadata?.claudeContextWindow);
+    const exactSize = typeof metadata?.claudeContextSize === 'number' && metadata.claudeContextSize > 0
+        ? metadata.claudeContextSize
+        : undefined;
+    if (window === '200k')
+        return `Window ${fmtK(exactSize || 200000)} · out ${fmtK(metadata?.claudeMaxOutputTokens || 32768)}`;
+    if (window === '1m')
+        return `Window ${fmtK(exactSize || 1000000)} · out ${fmtK(metadata?.claudeMaxOutputTokens || 128000)}`;
+    if (typeof metadata?.claudeContextSize === 'number' && metadata.claudeContextSize > 0) {
+        return `Window ${fmtK(metadata.claudeContextSize)}`;
+    }
+    return null;
+}
 function resolveSessionAlias(sessionId) {
     const normalized = sessionId.toLowerCase();
     // Project-local hook state (most reliable for the active session)
@@ -410,7 +719,73 @@ function isPendingSessionId(sessionId) {
         return true;
     return normalized === 'pending' || normalized === '_pending' || normalized.startsWith('_pending-');
 }
-// ── Resolve session to JSONL path ──
+function inferDashboardProvider(explicitProvider, launchMetadata, transcriptPath) {
+    if (explicitProvider)
+        return explicitProvider;
+    const metadataProvider = normalizeDashboardProvider(launchMetadata?.provider);
+    if (metadataProvider)
+        return metadataProvider;
+    if (transcriptPath?.endsWith('.json'))
+        return 'gemini';
+    return 'claude';
+}
+function resolveGeminiProjectId(projectPath) {
+    const registry = readJsonFile(path.join(os.homedir(), '.gemini', 'projects.json'));
+    const projectId = registry?.projects?.[projectPath];
+    return typeof projectId === 'string' && projectId.length > 0 ? projectId : null;
+}
+function findLatestGeminiSession(projectPath, createdAfterMs) {
+    const projectId = resolveGeminiProjectId(projectPath);
+    if (!projectId)
+        return null;
+    const chatsDir = path.join(os.homedir(), '.gemini', 'tmp', projectId, 'chats');
+    if (!fs.existsSync(chatsDir))
+        return null;
+    try {
+        const files = fs.readdirSync(chatsDir)
+            .filter(file => file.startsWith('session-') && file.endsWith('.json'))
+            .map(file => {
+            const filePath = path.join(chatsDir, file);
+            const stat = fs.statSync(filePath);
+            return { filePath, createdMs: stat.birthtimeMs || stat.mtimeMs };
+        })
+            .filter(entry => !createdAfterMs || entry.createdMs >= createdAfterMs)
+            .sort((a, b) => b.createdMs - a.createdMs);
+        return files[0]?.filePath || null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveGeminiSessionPath(sessionName, createdAfterMs, launchCwd) {
+    const active = (0, state_js_1.getActiveSessions)()
+        .filter(session => session.sessionName === sessionName && normalizeDashboardProvider(session.provider) === 'gemini')
+        .sort((a, b) => (b.lastHeartbeat || '').localeCompare(a.lastHeartbeat || ''));
+    const sessionHint = readJsonFile(path.join(state_js_1.EKKOS_DIR, 'session-hint.json'));
+    const hintedProjectPath = !sessionHint?.session_name || sessionHint.session_name === sessionName
+        ? sessionHint?.project_path
+        : undefined;
+    const candidateProjectPath = active[0]?.projectPath
+        || hintedProjectPath
+        || launchCwd
+        || null;
+    if (!candidateProjectPath)
+        return null;
+    return findLatestGeminiSession(candidateProjectPath, createdAfterMs);
+}
+function resolveTranscriptPath(provider, sessionName, createdAfterMs, launchCwd) {
+    if (provider === 'gemini') {
+        return resolveGeminiSessionPath(sessionName, createdAfterMs, launchCwd);
+    }
+    return resolveJsonlPath(sessionName, createdAfterMs);
+}
+function parseTranscriptFile(transcriptPath, provider, sessionName, launchMetadata) {
+    if (provider === 'gemini') {
+        return parseGeminiSessionFile(transcriptPath, sessionName, launchMetadata);
+    }
+    return parseJsonlFile(transcriptPath, sessionName, launchMetadata);
+}
+// ── Resolve session to transcript 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);
@@ -651,9 +1026,11 @@ function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 // ── TUI Dashboard ──
-async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs, launchCwd, launchTs) {
+async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs, launchCwd, launchTs, initialProvider) {
     let jsonlPath = initialJsonlPath;
     let sessionName = displaySessionName(initialSessionName);
+    let launchMetadata = readSessionLaunchMetadata(sessionName) || readSessionLaunchMetadata(initialSessionName);
+    let provider = inferDashboardProvider(initialProvider, launchMetadata, initialJsonlPath);
     const blessed = require('blessed');
     const contrib = require('blessed-contrib');
     const inTmux = process.env.TMUX !== undefined;
@@ -784,7 +1161,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     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 MASCOT_W = 16; // Width reserved for runtime mascot in context box
     const FIXED_H = HEADER_H + CONTEXT_H + USAGE_H + FOOTER_H; // 15
     function resolveChartRatio(height) {
         if (height >= 62)
@@ -824,7 +1201,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         tags: true,
         style: { fg: 'white', border: { fg: 'cyan' } },
         border: { type: 'line' },
-        label: ' ekkOS_ ',
+        label: ' ekkOS_PULSE ',
     });
     // Explicit header message row: with HEADER_H=3 and a border, this is the
     // single inner content row (visual line 2 of the widget).
@@ -845,24 +1222,41 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         tags: true,
         style: { fg: 'white', border: { fg: 'cyan' } },
         border: { type: 'line' },
-        label: ' Context ',
+        label: ' PULSE // Runtime ',
     });
-    // Clawd mascot — official Claude Code mascot (redBright / rgb(215,119,87))
-    const clawdBox = blessed.box({
+    const mascotBox = 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
+        content: '',
+        tags: true,
+        style: { fg: 'cyan', bold: true },
     });
+    const GEMINI_MASCOT_COLORS = ['cyan', 'blue', 'magenta', 'yellow', 'white', 'green'];
+    let geminiMascotPhase = 0;
+    function renderRuntimeMascot() {
+        if (provider === 'gemini') {
+            const base = GEMINI_MASCOT_COLORS[geminiMascotPhase % GEMINI_MASCOT_COLORS.length];
+            const wing = GEMINI_MASCOT_COLORS[(geminiMascotPhase + 2) % GEMINI_MASCOT_COLORS.length];
+            const core = GEMINI_MASCOT_COLORS[(geminiMascotPhase + 4) % GEMINI_MASCOT_COLORS.length];
+            mascotBox.setContent(`    {${base}-fg}✦{/${base}-fg}\n` +
+                `   {${wing}-fg}✦{/${wing}-fg}{${core}-fg}◆{/${core}-fg}{${wing}-fg}✦{/${wing}-fg}\n` +
+                `    {${base}-fg}✦{/${base}-fg}`);
+            mascotBox.style = { fg: 'cyan', bold: true };
+            return;
+        }
+        // Clawd mascot — official Claude Code mascot.
+        mascotBox.setContent('  ▐▛███▜▌\n ▝▜█████▛▘\n   ▘▘ ▝▝');
+        mascotBox.style = { fg: 'red', bold: true };
+    }
+    renderRuntimeMascot();
     // Token chart (fills 40% of remaining)
     function createTokenChart(top, left, width, height) {
         return contrib.line({
             top, left, width, height,
-            label: ' Tokens/Turn (K) ',
+            label: ' Signal // Tokens (K) ',
             showLegend: true,
             legend: { width: 8 },
             style: {
@@ -893,7 +1287,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         mouse: false, // Mouse disabled (use keyboard for scrolling, allows text selection)
         input: !inTmux,
         interactive: !inTmux, // Standalone only; passive in tmux split
-        label: ' Turns (scroll: ↑↓/k/j, page: PgUp/u, home/end: g/G) ',
+        label: ' Trace // Turns (scroll: ↑↓/k/j, page: PgUp/u, home/end: g/G) ',
         border: { type: 'line', fg: 'cyan' },
         style: { fg: 'white', border: { fg: 'cyan' } },
     });
@@ -904,7 +1298,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         tags: true,
         style: { fg: 'white', border: { fg: 'magenta' } },
         border: { type: 'line' },
-        label: ' Rate Limit ',
+        label: ' Pulse Limits ',
     });
     // Footer (totals + routing + keys)
     const footerBox = blessed.box({
@@ -913,7 +1307,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         tags: true,
         style: { fg: 'white', border: { fg: 'cyan' } },
         border: { type: 'line' },
-        label: ' Session ',
+        label: ' Session Bus ',
     });
     // Add all widgets to screen
     screen.append(headerBox);
@@ -1082,8 +1476,13 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     }
     function renderPreTurnState() {
         try {
+            const launchModelLabel = formatLaunchModelLabel(launchMetadata);
+            const launchWindowLabel = formatLaunchWindowLabel(launchMetadata);
+            const compactSelected = formatCompactLaunchModel(launchMetadata) || 'Awaiting profile';
+            const compactLane = formatContextLaneCompact(launchMetadata?.claudeContextSize, launchMetadata) || 'Awaiting lane';
             contextBox.setContent(` {green-fg}Session active{/green-fg}  {gray-fg}${sessionName}{/gray-fg}\n` +
-                ` Token and cost metrics appear after the first assistant response.`);
+                ` ${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.'}`);
             turnBox.setContent(`{bold}Turns{/bold}\n` +
                 `{gray-fg}—{/gray-fg}`);
             const timerStr = sessionStartMs
@@ -1108,10 +1507,15 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             const shouldUseCwdFallback = initialSessionName === 'initializing'
                 || initialSessionName === 'session'
                 || UUID_REGEX.test(initialSessionName);
-            const resolved = resolveJsonlPath(initialSessionName, launchTs)
-                || (shouldUseCwdFallback && launchCwd ? findLatestJsonl(launchCwd, launchTs) : null);
+            const resolved = resolveTranscriptPath(provider, initialSessionName, launchTs, launchCwd)
+                || (provider === 'claude'
+                    && shouldUseCwdFallback
+                    && launchCwd
+                    ? findLatestJsonl(launchCwd, launchTs)
+                    : null);
             if (resolved) {
                 jsonlPath = resolved;
+                provider = inferDashboardProvider(initialProvider, launchMetadata, resolved);
                 dlog(`Lazy-resolved JSONL: ${jsonlPath}`);
             }
             else {
@@ -1131,6 +1535,8 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                 const basename = path.basename(jsonlPath, '.jsonl');
                 if (/^[0-9a-f]{8}-/.test(basename)) {
                     sessionName = displaySessionName(basename);
+                    launchMetadata = readSessionLaunchMetadata(sessionName) || launchMetadata;
+                    provider = inferDashboardProvider(initialProvider, launchMetadata, jsonlPath);
                     screen.title = `ekkOS - ${sessionName}`;
                 }
             }
@@ -1141,6 +1547,9 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             const resolvedName = displaySessionName(sessionName);
             if (resolvedName !== sessionName) {
                 sessionName = resolvedName;
+                launchMetadata = readSessionLaunchMetadata(sessionName) || launchMetadata;
+                provider = inferDashboardProvider(initialProvider, launchMetadata, jsonlPath);
+                renderRuntimeMascot();
                 screen.title = `ekkOS - ${sessionName}`;
             }
         }
@@ -1150,7 +1559,10 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             if (stat.size === lastFileSize && lastData)
                 return;
             lastFileSize = stat.size;
-            data = parseJsonlFile(jsonlPath, sessionName);
+            launchMetadata = readSessionLaunchMetadata(sessionName) || launchMetadata;
+            provider = inferDashboardProvider(initialProvider, launchMetadata, jsonlPath);
+            renderRuntimeMascot();
+            data = parseTranscriptFile(jsonlPath, provider, sessionName, launchMetadata);
             lastData = data;
             if (!sessionStartMs && data.startedAt) {
                 sessionStartMs = new Date(data.startedAt).getTime();
@@ -1173,10 +1585,17 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             const ctxColor = ctxPct < 50 ? 'green' : ctxPct < 80 ? 'yellow' : 'red';
             const tokensLabel = fmtK(data.currentContextTokens);
             const maxLabel = fmtK(data.modelContextSize);
+            const lastTurn = data.turns.length > 0 ? data.turns[data.turns.length - 1] : null;
+            const selectedProfile = formatCompactLaunchModel(launchMetadata)
+                || humanizeModelName(data.model, false)
+                || 'Auto';
+            const activeModel = formatActiveRoutedModel(lastTurn?.routedModel || data.model) || 'Unknown';
+            const laneLabel = formatContextLaneCompact(data.modelContextSize, launchMetadata)
+                || `${maxLabel} window`;
             // 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 barWidth = Math.max(10, contextInnerWidth - 4 - MASCOT_W);
             const filled = Math.round((ctxPct / 100) * barWidth);
             const bar = `{${ctxColor}-fg}${'█'.repeat(filled)}{/${ctxColor}-fg}${'░'.repeat(barWidth - filled)}`;
             // Cost breakdown by actual routed model per turn.
@@ -1192,12 +1611,13 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             const hitColor = data.cacheHitRate >= 80 ? 'green' : data.cacheHitRate >= 50 ? 'yellow' : 'red';
             const cappedMax = Math.min(data.maxContextPct, 100);
             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}Input{/white-fg} $${breakdown.input.toFixed(2)}` +
+                `  {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}Output{/cyan-fg} $${breakdown.output.toFixed(2)}\n` +
-                ` {${hitColor}-fg}${data.cacheHitRate.toFixed(0)}% cache{/${hitColor}-fg}` +
+                `  {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}` +
@@ -1773,6 +2193,10 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     }
     // Fetch fresh usage data from API (called on interval)
     async function fetchAndCacheUsage() {
+        if (provider === 'gemini') {
+            renderWindowBox();
+            return;
+        }
         if (usageFetchInFlight)
             return;
         // Respect shared state across dashboard processes.
@@ -1819,6 +2243,35 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     // Render countdown from cached data (called every 1s)
     function renderWindowBox(skipRender = false) {
         try {
+            if (provider === 'gemini') {
+                windowBox.setLabel(' Gemini Runtime ');
+                const runtimeModel = formatLaunchModelLabel(launchMetadata)
+                    || humanizeModelName(lastData?.model, true)
+                    || 'Gemini';
+                const contextSize = fmtK(lastData?.modelContextSize
+                    || launchMetadata?.claudeContextSize
+                    || 1048576);
+                const turnCount = lastData?.turnCount || 0;
+                const tokenCount = fmtK(lastData?.currentContextTokens || 0);
+                const projectId = launchMetadata?.geminiProjectId || resolveGeminiProjectId(launchCwd || process.cwd()) || 'unknown';
+                const transcriptLabel = jsonlPath
+                    ? path.basename(jsonlPath)
+                    : 'awaiting chat transcript';
+                const line1 = ` {bold}Model:{/bold} ${runtimeModel}` +
+                    `  {bold}Ctx:{/bold} ${contextSize}` +
+                    `  {bold}Turns:{/bold} ${turnCount}` +
+                    `  {bold}In:{/bold} ${tokenCount}`;
+                const line2 = ` {bold}Project:{/bold} ${projectId}` +
+                    `  {bold}Chat:{/bold} ${transcriptLabel}`;
+                windowBox.setContent(line1 + '\n' + line2);
+                if (!skipRender)
+                    try {
+                        screen.render();
+                    }
+                    catch { }
+                return;
+            }
+            windowBox.setLabel(' Pulse Limits ');
             const usage = cachedUsage;
             let line1 = ' {gray-fg}No usage data{/gray-fg}';
             let line2 = '';
@@ -2123,6 +2576,10 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     const headerAnimInterval = setInterval(() => {
         // Keep advancing across the full session label; wrap at a large value.
         waveOffset = (waveOffset + 1) % 1000000;
+        if (provider === 'gemini') {
+            geminiMascotPhase = (geminiMascotPhase + 1) % GEMINI_MASCOT_COLORS.length;
+            renderRuntimeMascot();
+        }
         renderHeader();
     }, animMs);
     const fortuneInterval = setInterval(() => {
@@ -2165,9 +2622,27 @@ function formatElapsed(startMs) {
 // ── 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.'));
+    if (sessions.length > 0) {
+        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;
+    }
+    const active = (0, state_js_1.getActiveSessions)()
+        .filter(session => session.sessionName && !UUID_REGEX.test(session.sessionName))
+        .sort((a, b) => (b.lastHeartbeat || '').localeCompare(a.lastHeartbeat || ''));
+    if (active.length === 0) {
+        console.log(chalk_1.default.yellow('No active sessions found.'));
+        console.log(chalk_1.default.gray('Start a session with "ekkos run" or "ekkos gemini" first.'));
         return null;
     }
     const { default: inquirer } = await Promise.resolve().then(() => __importStar(require('inquirer')));
@@ -2175,10 +2650,10 @@ async function pickSession() {
         {
             type: 'list',
             name: 'session',
-            message: 'Choose session:',
-            choices: sessions.map(s => ({
-                name: `${s.name}  ($${s.cost.toFixed(2)}, ${s.turnCount}t)`,
-                value: s.name,
+            message: 'Choose active session:',
+            choices: active.map(session => ({
+                name: `${session.sessionName}  [${normalizeDashboardProvider(session.provider) === 'gemini' ? 'Gemini' : 'Claude'}]`,
+                value: session.sessionName,
             })),
         },
     ]);
@@ -2186,18 +2661,20 @@ async function pickSession() {
 }
 // ── Commander command ──
 exports.dashboardCommand = new commander_1.Command('dashboard')
-    .description('Live TUI dashboard for monitoring Claude Code session usage')
+    .description('Live TUI dashboard for monitoring ekkOS 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')
+    .option('--provider <name>', 'Session provider override (claude|gemini)')
     .action(async (sessionNameArg, options) => {
     const refreshMs = parseInt(options.refresh) || 2000;
+    const explicitProvider = normalizeDashboardProvider(options.provider);
     // --wait-for-new: poll until session name appears (JSONL may not exist yet)
     if (options.waitForNew) {
         const result = await waitForNewSession();
-        await launchDashboard(result.sessionName, result.jsonlPath, refreshMs, result.launchCwd, result.launchTs);
+        await launchDashboard(result.sessionName, result.jsonlPath, refreshMs, result.launchCwd, result.launchTs, explicitProvider);
         return;
     }
     let sessionName = null;
@@ -2221,10 +2698,11 @@ exports.dashboardCommand = new commander_1.Command('dashboard')
     // stale JSONL files from previous sessions (the lazy resolution already does
     // this correctly — this ensures the INITIAL resolve matches).
     const launchTs = Date.now();
-    const jsonlPath = resolveJsonlPath(sessionName, launchTs);
+    const launchMetadata = readSessionLaunchMetadata(sessionName);
+    const provider = inferDashboardProvider(explicitProvider, launchMetadata, null);
+    const jsonlPath = resolveTranscriptPath(provider, sessionName, launchTs, null);
     if (!jsonlPath) {
-        // JSONL may not exist yet (session just started) — launch with lazy resolution
-        console.log(chalk_1.default.gray(`Waiting for JSONL for "${sessionName}"...`));
+        console.log(chalk_1.default.gray(`Waiting for transcript for "${sessionName}"...`));
     }
-    await launchDashboard(sessionName, jsonlPath || null, refreshMs, null, launchTs);
+    await launchDashboard(sessionName, jsonlPath || null, refreshMs, null, launchTs, provider);
 });