@ekkos/cli 1.3.0 → 1.3.2

package/dist/commands/dashboard.js

@@ -322,6 +322,17 @@ function displaySessionName(rawName) {
         return rawName;
     return resolveSessionAlias(rawName) || (0, state_js_1.uuidToWords)(rawName);
 }
+function isStableSessionId(sessionId) {
+    return typeof sessionId === 'string' && UUID_REGEX.test(sessionId);
+}
+function isPendingSessionId(sessionId) {
+    if (typeof sessionId !== 'string')
+        return true;
+    const normalized = sessionId.trim().toLowerCase();
+    if (!normalized)
+        return true;
+    return normalized === 'pending' || normalized === '_pending' || normalized.startsWith('_pending-');
+}
 // ── Resolve session to JSONL path ──
 function resolveJsonlPath(sessionName, createdAfterMs) {
     // 1) Try standard resolution (works when sessionId is a real UUID)
@@ -331,13 +342,21 @@ function resolveJsonlPath(sessionName, createdAfterMs) {
         if (fs.existsSync(jsonlPath))
             return jsonlPath;
     }
-    // 2) Fallback: active session has "pending" UUID
+    // 2) Active-session fallback.
+    // IMPORTANT: never resolve "pending" sessions to "latest file in project" because
+    // that can cross-bind concurrent sessions to the same dashboard transcript.
     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) {
+                if (isStableSessionId(match.sessionId)) {
+                    return findJsonlBySessionId(match.projectPath, match.sessionId);
+                }
+                if (isPendingSessionId(match.sessionId)) {
+                    return null;
+                }
                 return findLatestJsonl(match.projectPath, createdAfterMs);
             }
         }
@@ -353,12 +372,15 @@ function resolveJsonlPath(sessionName, createdAfterMs) {
 function findLatestJsonl(projectPath, createdAfterMs) {
     // Claude encodes project paths by replacing separators with '-'.
     // On Windows, ':' is also illegal in directory names so it gets replaced too.
+    // Claude also replaces underscores and other non-alphanumeric chars with '-'.
     // Try all plausible encodings since Claude's exact scheme varies by platform.
     const candidateEncodings = new Set([
         projectPath.replace(/[\\/]/g, '-'), // C:-Users-name  (backslash only)
         projectPath.replace(/[:\\/]/g, '-'), // C--Users-name  (colon + backslash)
         '-' + projectPath.replace(/[:\\/]/g, '-'), // -C--Users-name (leading separator)
         projectPath.replace(/\//g, '-'), // macOS: /Users/name → -Users-name
+        projectPath.replace(/[^a-zA-Z0-9]/g, '-'), // Replace ALL non-alphanumeric (handles _)
+        `-${projectPath.replace(/^[\\/]+/, '').replace(/[^a-zA-Z0-9]/g, '-')}`, // Leading - variant
     ]);
     const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
     for (const encoded of Array.from(candidateEncodings)) {
@@ -390,6 +412,8 @@ function findJsonlBySessionId(projectPath, sessionId) {
         projectPath.replace(/[:\\/]/g, '-'),
         '-' + projectPath.replace(/[:\\/]/g, '-'),
         projectPath.replace(/\//g, '-'),
+        projectPath.replace(/[^a-zA-Z0-9]/g, '-'),
+        `-${projectPath.replace(/^[\\/]+/, '').replace(/[^a-zA-Z0-9]/g, '-')}`,
     ]);
     const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
     for (const encoded of Array.from(candidateEncodings)) {
@@ -436,8 +460,8 @@ async function waitForNewSession() {
                 const hint = JSON.parse(fs.readFileSync(hintPath, 'utf-8'));
                 if (hint.ts >= launchTs - 5000 && hint.sessionName && hint.projectPath) {
                     candidateName = hint.sessionName;
-                    const jsonlPath = findJsonlBySessionId(hint.projectPath, hint.sessionId || '')
-                        || findLatestJsonl(hint.projectPath, launchTs)
+                    const hintSessionId = typeof hint.sessionId === 'string' ? hint.sessionId : '';
+                    const jsonlPath = (isStableSessionId(hintSessionId) ? findJsonlBySessionId(hint.projectPath, hintSessionId) : null)
                         || resolveJsonlPath(hint.sessionName, launchTs);
                     // Return immediately — JSONL may be null; dashboard will lazy-resolve
                     console.log(chalk_1.default.green(`  Found session (hook hint): ${hint.sessionName}`));
@@ -451,26 +475,24 @@ async function waitForNewSession() {
         for (const s of sessions) {
             const startedMs = new Date(s.startedAt).getTime();
             if (startedMs >= launchTs - 2000) {
-                candidateName = s.sessionName;
-                // Try to resolve JSONL immediately (may succeed if Claude already created it)
-                let jsonlPath = resolveJsonlPath(s.sessionName, launchTs);
-                if (!jsonlPath) {
-                    const allPaths = new Set(sessions.filter(x => x.sessionName === s.sessionName && x.projectPath)
-                        .map(x => x.projectPath));
-                    for (const pp of Array.from(allPaths)) {
-                        jsonlPath = findLatestJsonl(pp, launchTs);
-                        if (jsonlPath)
-                            break;
-                    }
+                if (!isStableSessionId(s.sessionId)) {
+                    // Wait for stable session identity; pending IDs can collide across concurrent runs.
+                    continue;
                 }
+                candidateName = s.sessionName;
+                // Try exact by sessionId first, then constrained name resolution.
+                let jsonlPath = s.projectPath ? findJsonlBySessionId(s.projectPath, s.sessionId) : null;
+                if (!jsonlPath)
+                    jsonlPath = resolveJsonlPath(s.sessionName, launchTs);
                 // Return immediately with session name — JSONL may still be null
                 // (Claude Code hasn't created it yet). Dashboard will lazy-resolve.
-                console.log(chalk_1.default.green(`  Found session: ${s.sessionName}`));
+                console.log(chalk_1.default.green(`  Found session: ${s.sessionName}${jsonlPath ? '' : ' (awaiting transcript)'}`));
                 return { sessionName: s.sessionName, jsonlPath, launchCwd: s.projectPath || launchCwd, launchTs };
             }
         }
-        // Fallback: use launch CWD to find any new JSONL
-        if (launchCwd) {
+        // Fallback: use launch CWD to find any new JSONL only if we don't even
+        // have a candidate session name yet.
+        if (launchCwd && !candidateName) {
             const latestJsonl = findLatestJsonl(launchCwd, launchTs);
             if (latestJsonl) {
                 const name = candidateName || path.basename(latestJsonl, '.jsonl');
@@ -478,8 +500,9 @@ async function waitForNewSession() {
                 return { sessionName: name, jsonlPath: latestJsonl, launchCwd, launchTs };
             }
         }
-        // Broad fallback: scan ALL project directories for any new JSONL
-        {
+        // Broad fallback: scan ALL project directories for any new JSONL only
+        // when no candidate name is known.
+        if (!candidateName) {
             const projectsRoot = path.join(os.homedir(), '.claude', 'projects');
             try {
                 if (fs.existsSync(projectsRoot)) {
@@ -580,7 +603,7 @@ 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'], // Only capture Ctrl+C for quit
+        ignoreLocked: ['C-c', 'C-q'], // Capture Ctrl+C and Ctrl+Q for quit
         input: ttyInput, // Use /dev/tty for input (isolated from stdout pipe)
         output: ttyOutput, // Use /dev/tty for output (isolated from stdout pipe)
         forceUnicode: true, // Better text rendering
@@ -678,6 +701,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     let layout = calcLayout();
     let lastFileSize = 0;
     let lastData = null;
+    let sessionStartMs = launchTs || null; // epoch ms of session start, for live timer
     let lastChartSeries = null;
     let lastScrollPerc = 0; // Preserve scroll position across updates
     let fortuneIdx = Math.floor(Math.random() * activeFortunes.length);
@@ -945,14 +969,36 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         }
         catch { }
     }
+    function renderPreTurnState() {
+        try {
+            contextBox.setContent(` {green-fg}Session active{/green-fg}  {gray-fg}${sessionName}{/gray-fg}\n` +
+                ` Token and cost metrics appear after the first assistant response.`);
+            turnBox.setContent(`{bold}Turns{/bold}\n` +
+                `{gray-fg}—{/gray-fg}`);
+            const timerStr = sessionStartMs
+                ? `{cyan-fg}${formatElapsed(sessionStartMs)}{/cyan-fg}  `
+                : '';
+            footerBox.setLabel(` ${sessionName} `);
+            footerBox.setContent(` ${timerStr}{green-fg}Ready{/green-fg}` +
+                (inTmux
+                    ? `  {gray-fg}Ctrl+Q quit{/gray-fg}`
+                    : `  {gray-fg}? help  q quit  r refresh{/gray-fg}`));
+        }
+        catch (err) {
+            dlog(`Pre-turn render: ${err.message}`);
+        }
+    }
     function updateDashboard() {
         ensureLayoutSynced();
         // ── Lazy JSONL resolution ──────────────────────────────────────────────
         // Dashboard may launch before Claude Code creates the JSONL file.
         // Keep trying to find it on each poll tick.
         if (!jsonlPath || !fs.existsSync(jsonlPath)) {
+            const shouldUseCwdFallback = initialSessionName === 'initializing'
+                || initialSessionName === 'session'
+                || UUID_REGEX.test(initialSessionName);
             const resolved = resolveJsonlPath(initialSessionName, launchTs)
-                || (launchCwd ? findLatestJsonl(launchCwd, launchTs) : null);
+                || (shouldUseCwdFallback && launchCwd ? findLatestJsonl(launchCwd, launchTs) : null);
             if (resolved) {
                 jsonlPath = resolved;
                 dlog(`Lazy-resolved JSONL: ${jsonlPath}`);
@@ -960,6 +1006,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             else {
                 // Still no JSONL — render the header/footer so the dashboard isn't blank
                 renderHeader();
+                renderPreTurnState();
                 try {
                     screen.render();
                 }
@@ -994,6 +1041,9 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             lastFileSize = stat.size;
             data = parseJsonlFile(jsonlPath, sessionName);
             lastData = data;
+            if (!sessionStartMs && data.startedAt) {
+                sessionStartMs = new Date(data.startedAt).getTime();
+            }
         }
         catch (err) {
             dlog(`Parse error: ${err.message}`);
@@ -1089,14 +1139,15 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             let header = '';
             let separator = '';
             let rows = [];
-            // Always show all 7 columns: Turn, Model, Context, Cache Rd, Cache Wr, Output, Cost
+            // Always show all 8 columns: Turn, Time, Model, Context, Cache Rd, Cache Wr, Output, Cost
             // Shrink flex columns to fit narrow panes instead of dropping them.
             const colNum = 4;
+            const colTime = 8; // "HH:MM:SS" or "H:MM AM"
             const colM = 7;
             const colCtx = 7;
             const colCost = 8;
-            const nDividers = 6;
-            const fixedW = colNum + colM + colCtx + colCost;
+            const nDividers = 7;
+            const fixedW = colNum + colTime + colM + colCtx + colCost;
             const flexTotal = Math.max(0, w - fixedW - nDividers);
             let rdW = Math.max(5, Math.floor(flexTotal * 0.35));
             let wrW = Math.max(5, Math.floor(flexTotal * 0.30));
@@ -1118,14 +1169,30 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                     rdW -= trimRd;
                 }
             }
-            header = `{bold}${pad('Turn', colNum)}${div}${pad('Model', colM)}${div}${pad('Context', colCtx)}${div}${rpad('Cache Rd', rdW)}${div}${rpad('Cache Wr', wrW)}${div}${rpad('Output', outW)}${div}${rpad('Cost', colCost)}{/bold}`;
-            separator = `{gray-fg}${'─'.repeat(colNum)}┼${'─'.repeat(colM)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(rdW)}┼${'─'.repeat(wrW)}┼${'─'.repeat(outW)}┼${'─'.repeat(colCost)}{/gray-fg}`;
+            // Format turn timestamp to short time string
+            const fmtTime = (iso) => {
+                if (!iso)
+                    return '--:--';
+                try {
+                    const d = new Date(iso);
+                    const h = d.getHours();
+                    const m = d.getMinutes().toString().padStart(2, '0');
+                    const s = d.getSeconds().toString().padStart(2, '0');
+                    return `${h}:${m}:${s}`;
+                }
+                catch {
+                    return '--:--';
+                }
+            };
+            header = `{bold}${pad('Turn', colNum)}${div}${pad('Time', colTime)}${div}${pad('Model', colM)}${div}${pad('Context', colCtx)}${div}${rpad('Cache Rd', rdW)}${div}${rpad('Cache Wr', wrW)}${div}${rpad('Output', outW)}${div}${rpad('Cost', colCost)}{/bold}`;
+            separator = `{gray-fg}${'─'.repeat(colNum)}┼${'─'.repeat(colTime)}┼${'─'.repeat(colM)}┼${'─'.repeat(colCtx)}┼${'─'.repeat(rdW)}┼${'─'.repeat(wrW)}┼${'─'.repeat(outW)}┼${'─'.repeat(colCost)}{/gray-fg}`;
             rows = turns.map(t => {
                 const mTag = modelTag(t.routedModel);
                 const mColor = t.routedModel.includes('haiku') ? 'green' : t.routedModel.includes('sonnet') ? 'blue' : 'magenta';
                 const costFlag = t.cost > 1.0 ? '{red-fg}' : t.cost > 0.5 ? '{yellow-fg}' : '{white-fg}';
                 const costEnd = t.cost > 1.0 ? '{/red-fg}' : t.cost > 0.5 ? '{/yellow-fg}' : '{/white-fg}';
                 return (pad(String(t.turn), colNum) + div +
+                    `{gray-fg}${pad(fmtTime(t.timestamp), colTime)}{/gray-fg}` + 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 +
@@ -1145,13 +1212,20 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             dlog(`Table: ${err.message}`);
         }
         // ── Session Totals (footer) ──
+        renderFooter(data);
+    }
+    /** Render footer bar — called from updateDashboard and the 1s timer tick */
+    function renderFooter(data, skipRender = false) {
+        const d = data || lastData;
+        if (!d)
+            return;
         try {
-            const totalTokensM = ((data.totalCacheRead + data.totalCacheCreate + data.totalOutput) / 1000000).toFixed(2);
-            const totalSavings = data.turns.reduce((s, t) => s + t.savings, 0);
+            const totalTokensM = ((d.totalCacheRead + d.totalCacheCreate + d.totalOutput) / 1000000).toFixed(2);
+            const totalSavings = d.turns.reduce((s, t) => s + t.savings, 0);
             // Model routing breakdown (uses routedModel for actual model counts)
-            const opusCount = data.turns.filter(t => t.routedModel.includes('opus')).length;
-            const sonnetCount = data.turns.filter(t => t.routedModel.includes('sonnet')).length;
-            const haikuCount = data.turns.filter(t => t.routedModel.includes('haiku')).length;
+            const opusCount = d.turns.filter(t => t.routedModel.includes('opus')).length;
+            const sonnetCount = d.turns.filter(t => t.routedModel.includes('sonnet')).length;
+            const haikuCount = d.turns.filter(t => t.routedModel.includes('haiku')).length;
             const routingParts = [`{magenta-fg}O{/magenta-fg}:${opusCount}`];
             if (sonnetCount > 0)
                 routingParts.push(`{blue-fg}S{/blue-fg}:${sonnetCount}`);
@@ -1160,25 +1234,30 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             const savingsStr = totalSavings > 0
                 ? `  {green-fg}saved $${totalSavings.toFixed(2)}{/green-fg}`
                 : '';
+            const timerStr = sessionStartMs
+                ? `{cyan-fg}${formatElapsed(sessionStartMs)}{/cyan-fg}  `
+                : '';
             footerBox.setLabel(` ${sessionName} `);
-            footerBox.setContent(` {green-fg}$${data.totalCost.toFixed(2)}{/green-fg}` +
+            footerBox.setContent(` ${timerStr}` +
+                `{green-fg}$${d.totalCost.toFixed(2)}{/green-fg}` +
                 `  ${totalTokensM}M` +
                 `  ${routingStr}` +
-                `  R[A:${data.replayAppliedCount} SZ:${data.replaySkippedSizeCount} ST:${data.replaySkipStoreCount}]` +
+                `  R[A:${d.replayAppliedCount} SZ:${d.replaySkippedSizeCount} ST:${d.replaySkipStoreCount}]` +
                 savingsStr +
                 (inTmux
-                    ? `  {gray-fg}Ctrl+C quit{/gray-fg}`
+                    ? `  {gray-fg}Ctrl+Q quit{/gray-fg}`
                     : `  {gray-fg}? help  q quit  r refresh{/gray-fg}`));
         }
         catch (err) {
             dlog(`Footer: ${err.message}`);
         }
-        try {
-            screen.render();
-        }
-        catch (err) {
-            dlog(`Render: ${err.message}`);
-        }
+        if (!skipRender)
+            try {
+                screen.render();
+            }
+            catch (err) {
+                dlog(`Render: ${err.message}`);
+            }
     }
     // ── Usage window update — calls Anthropic's OAuth usage API ──
     /**
@@ -1220,36 +1299,72 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             return null;
         }
     }
-    async function updateWindowBox() {
+    // Cache last fetched usage data so the countdown can tick every second
+    let cachedUsage = null;
+    // Fetch fresh usage data from API (called every 15s)
+    async function fetchAndCacheUsage() {
+        try {
+            cachedUsage = await fetchAnthropicUsage();
+        }
+        catch (err) {
+            dlog(`Window fetch: ${err.message}`);
+        }
+        renderWindowBox();
+    }
+    // Render countdown from cached data (called every 1s)
+    function renderWindowBox(skipRender = false) {
         try {
-            const usage = await fetchAnthropicUsage();
+            const usage = cachedUsage;
             let line1 = ' {gray-fg}No usage data{/gray-fg}';
             let line2 = '';
+            // Fixed-width column helpers for aligned rendering:
+            //  " 5h:   26% used  ⏱ 1h16m12s  resets Feb 27, 2026, 12:00 AM"
+            //  " Week:  91% used  ⏱ 0h16m12s  resets Thu, Feb 26, 2026, 11:00 PM"
+            //  ^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+            //  label  pct col    countdown    reset time
+            const COL_LABEL = 6; // "5h:   " or "Week: " — padded to same width
+            const COL_PCT = 9; // "100% used" max
+            const COL_CD = 11; // "10h00m00s " max
+            const rpad = (s, w) => s.length >= w ? s : s + ' '.repeat(w - s.length);
             // ── 5h Window (from Anthropic OAuth API) ──
             if (usage?.five_hour) {
                 const pct = usage.five_hour.utilization;
                 const resetAt = new Date(usage.five_hour.resets_at).getTime();
                 const remainMs = Math.max(0, resetAt - Date.now());
-                const remainMin = Math.round(remainMs / 60000);
-                const rH = Math.floor(remainMin / 60);
-                const rM = remainMin % 60;
+                const remainSec = Math.round(remainMs / 1000);
+                const rH = Math.floor(remainSec / 3600);
+                const rM = Math.floor((remainSec % 3600) / 60);
+                const rS = remainSec % 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}`;
+                const countdown = `${rH}h${rM.toString().padStart(2, '0')}m${rS.toString().padStart(2, '0')}s`;
+                const pctStr = `${pct.toFixed(0)}% used`;
+                const resetDate = new Date(resetAt);
+                const resetTime = resetDate.toLocaleString('en-US', { month: 'short', day: 'numeric', year: 'numeric', hour: 'numeric', minute: '2-digit' });
+                line1 = ` {bold}${rpad('5h:', COL_LABEL)}{/bold}` +
+                    `{${pctColor}-fg}${rpad(pctStr, COL_PCT)}{/${pctColor}-fg}` +
+                    `  {${pctColor}-fg}⏱ ${rpad(countdown, COL_CD)}{/${pctColor}-fg}` +
+                    `resets ${resetTime}`;
             }
             // ── Weekly (from Anthropic OAuth API) ──
             if (usage?.seven_day) {
                 const pct = usage.seven_day.utilization;
                 const resetAt = new Date(usage.seven_day.resets_at);
-                const dayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
-                const resetDay = dayNames[resetAt.getDay()];
-                const resetHour = resetAt.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' });
+                const remainMs = Math.max(0, resetAt.getTime() - Date.now());
+                const remainSec = Math.round(remainMs / 1000);
+                const rD = Math.floor(remainSec / 86400);
+                const rH = Math.floor((remainSec % 86400) / 3600);
+                const rM = Math.floor((remainSec % 3600) / 60);
+                const rS = remainSec % 60;
                 const pctColor = pct < 50 ? 'green' : pct < 80 ? 'yellow' : 'red';
-                line2 = ` {bold}Week:{/bold}` +
-                    ` {${pctColor}-fg}${pct.toFixed(0)}% used{/${pctColor}-fg}` +
-                    `  resets ${resetDay} ${resetHour}`;
+                const countdown = rD > 0
+                    ? `${rD}d${rH}h${rM.toString().padStart(2, '0')}m`
+                    : `${rH}h${rM.toString().padStart(2, '0')}m${rS.toString().padStart(2, '0')}s`;
+                const pctStr = `${pct.toFixed(0)}% used`;
+                const resetTime = resetAt.toLocaleString('en-US', { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric', hour: 'numeric', minute: '2-digit' });
+                line2 = ` {bold}${rpad('Week:', COL_LABEL)}{/bold}` +
+                    `{${pctColor}-fg}${rpad(pctStr, COL_PCT)}{/${pctColor}-fg}` +
+                    `  {${pctColor}-fg}⏱ ${rpad(countdown, COL_CD)}{/${pctColor}-fg}` +
+                    `resets ${resetTime}`;
             }
             windowBox.setContent(line1 + (line2 ? '\n' + line2 : ''));
         }
@@ -1257,11 +1372,14 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
             dlog(`Window: ${err.message}`);
             windowBox.setContent(` {gray-fg}Usage data unavailable{/gray-fg}`);
         }
-        try {
-            screen.render();
-        }
-        catch { }
+        if (!skipRender)
+            try {
+                screen.render();
+            }
+            catch { }
     }
+    // Legacy wrapper for backward compat
+    async function updateWindowBox() { await fetchAndCacheUsage(); }
     // ── Handle terminal resize ──
     // Recalculate all widget positions from new screen.height
     screen.on('resize', () => {
@@ -1289,9 +1407,10 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
     // KEYBOARD SHORTCUTS - Only capture when dashboard pane has focus
     // In tmux split mode, this prevents capturing keys from Claude Code pane
     // ══════════════════════════════════════════════════════════════════════════
-    screen.key(['C-c'], () => {
+    screen.key(['C-c', 'C-q'], () => {
         clearInterval(pollInterval);
         clearInterval(windowPollInterval);
+        clearInterval(tickInterval);
         clearInterval(headerAnimInterval);
         clearInterval(fortuneInterval);
         screen.destroy();
@@ -1301,6 +1420,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         screen.key(['q'], () => {
             clearInterval(pollInterval);
             clearInterval(windowPollInterval);
+            clearInterval(tickInterval);
             clearInterval(headerAnimInterval);
             clearInterval(fortuneInterval);
             screen.destroy();
@@ -1363,7 +1483,7 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
                     '\n' +
                     '{bold}Controls{/bold}\n' +
                     '  r          Refresh now\n' +
-                    '  q/Ctrl+C   Quit\n' +
+                    '  q/Ctrl+Q   Quit\n' +
                     '\n' +
                     '{gray-fg}Press any key to close{/gray-fg}'),
                 tags: true,
@@ -1408,7 +1528,17 @@ async function launchDashboard(initialSessionName, initialJsonlPath, refreshMs,
         fortuneText = activeFortunes[fortuneIdx];
         renderHeader();
     }, 30000);
-    const windowPollInterval = setInterval(updateWindowBox, 15000); // every 15s
+    const windowPollInterval = setInterval(fetchAndCacheUsage, 15000); // fetch fresh data every 15s
+    // Single 1s tick for both countdown + session timer (one screen.render instead of three)
+    const tickInterval = setInterval(() => {
+        renderWindowBox(true);
+        if (sessionStartMs)
+            renderFooter(null, true);
+        try {
+            screen.render();
+        }
+        catch { }
+    }, 1000);
 }
 // ── Helpers ──
 function fmtK(n) {
@@ -1419,6 +1549,14 @@ function fmtK(n) {
     return String(n);
 }
 function formatK(n) { return fmtK(n); }
+function formatElapsed(startMs) {
+    const diff = Math.max(0, Math.floor((Date.now() - startMs) / 1000));
+    const h = Math.floor(diff / 3600);
+    const m = Math.floor((diff % 3600) / 60);
+    const s = diff % 60;
+    const pad = (n) => String(n).padStart(2, '0');
+    return h > 0 ? `${h}:${pad(m)}:${pad(s)}` : `${m}:${pad(s)}`;
+}
 // ── Session picker ──
 async function pickSession() {
     const sessions = await (0, usage_parser_js_1.listEkkosSessions)(20);
@@ -1476,9 +1614,8 @@ exports.dashboardCommand = new commander_1.Command('dashboard')
     }
     const jsonlPath = resolveJsonlPath(sessionName);
     if (!jsonlPath) {
-        console.log(chalk_1.default.red(`No JSONL found for "${sessionName}"`));
-        console.log(chalk_1.default.gray('Run "ekkos sessions" to see active sessions'));
-        process.exit(1);
+        // JSONL may not exist yet (session just started) — launch with lazy resolution
+        console.log(chalk_1.default.gray(`Waiting for JSONL for "${sessionName}"...`));
     }
-    await launchDashboard(sessionName, jsonlPath, refreshMs);
+    await launchDashboard(sessionName, jsonlPath || null, refreshMs, null, Date.now());
 });

package/dist/commands/init.d.ts

@@ -4,6 +4,7 @@ interface InitOptions {
     force?: boolean;
     skipHooks?: boolean;
     skipSkills?: boolean;
+    quick?: boolean;
 }
 export declare function init(options: InitOptions): Promise<void>;
 export {};

package/dist/commands/init.js

@@ -11,8 +11,8 @@ const ora_1 = __importDefault(require("ora"));
 const open_1 = __importDefault(require("open"));
 const platform_1 = require("../utils/platform");
 const mcp_1 = require("../deploy/mcp");
+const settings_1 = require("../deploy/settings");
 // DEPRECATED: Hooks removed in hookless architecture migration
-// import { deployClaudeSettings } from '../deploy/settings';
 // import { deployHooks } from '../deploy/hooks';
 const skills_1 = require("../deploy/skills");
 const agents_1 = require("../deploy/agents");
@@ -200,23 +200,37 @@ async function manualKeyAuth(providedKey) {
 // ═══════════════════════════════════════════════════════════════════════════
 // IDE SETUP
 // ═══════════════════════════════════════════════════════════════════════════
-async function selectIDEs() {
+async function selectIDEs(autoSelect = false) {
     console.log(chalk_1.default.cyan('Step 2/3: IDE Setup'));
     console.log(chalk_1.default.gray('─'.repeat(40)));
     console.log('');
     const detected = (0, platform_1.detectInstalledIDEs)();
     const current = (0, platform_1.detectCurrentIDE)();
-    if (detected.length > 0) {
-        console.log(chalk_1.default.gray(`Detected: ${detected.join(', ')}`));
+    // Build the unique ordered list: current IDE first, then any others detected
+    const detectedSet = new Set(detected);
+    if (current && (current === 'claude' || current === 'cursor' || current === 'windsurf')) {
+        detectedSet.add(current);
+    }
+    const detectedList = Array.from(detectedSet);
+    if (detectedList.length > 0) {
+        console.log(chalk_1.default.gray(`Detected: ${detectedList.join(', ')}`));
         if (current) {
             console.log(chalk_1.default.gray(`Current: ${current}`));
         }
         console.log('');
     }
+    // Auto-select when exactly one IDE is detected or autoSelect flag is set
+    if (autoSelect || detectedList.length === 1) {
+        const autoIDE = detectedList.length === 1 ? detectedList[0] : (current ?? detectedList[0] ?? 'claude');
+        const ideName = autoIDE === 'claude' ? 'Claude Code' : autoIDE === 'cursor' ? 'Cursor' : 'Windsurf';
+        console.log(chalk_1.default.green(`✓ Auto-detected: ${chalk_1.default.bold(ideName)}`));
+        console.log('');
+        return [autoIDE];
+    }
     const ideChoices = [
-        { name: 'Claude Code', value: 'claude', checked: detected.includes('claude') || current === 'claude' },
-        { name: 'Cursor', value: 'cursor', checked: detected.includes('cursor') || current === 'cursor' },
-        { name: 'Windsurf (Cascade)', value: 'windsurf', checked: detected.includes('windsurf') || current === 'windsurf' }
+        { name: 'Claude Code', value: 'claude', checked: detectedList.includes('claude') || current === 'claude' },
+        { name: 'Cursor', value: 'cursor', checked: detectedList.includes('cursor') || current === 'cursor' },
+        { name: 'Windsurf (Cascade)', value: 'windsurf', checked: detectedList.includes('windsurf') || current === 'windsurf' }
     ];
     // If nothing was auto-detected, default to Claude Code
     if (!ideChoices.some(c => c.checked)) {
@@ -252,10 +266,17 @@ async function deployForClaude(apiKey, userId, options) {
     catch (error) {
         spinner.fail('MCP server configuration failed');
     }
-    // DEPRECATED: Hooks removed in hookless architecture migration
-    // Settings.json hook registration and hook script deployment are no longer needed.
-    // Use `ekkos run` instead.
-    result.settings = true; // Mark as satisfied so downstream logic is unaffected
+    // Claude Code settings (disable auto-memory, clean up legacy hooks)
+    spinner = (0, ora_1.default)('Configuring Claude Code settings...').start();
+    try {
+        (0, settings_1.deployClaudeSettings)();
+        result.settings = true;
+        spinner.succeed('Claude Code settings (auto-memory disabled)');
+    }
+    catch (error) {
+        spinner.fail('Claude Code settings failed');
+        result.settings = true; // Non-critical — don't block init
+    }
     // Skills
     if (!options.skipSkills) {
         spinner = (0, ora_1.default)('Deploying skills...').start();
@@ -325,9 +346,15 @@ async function deployForWindsurf(apiKey, userId) {
 // MAIN INIT COMMAND
 // ═══════════════════════════════════════════════════════════════════════════
 async function init(options) {
+    const isQuick = options.quick ?? false;
     console.log('');
     console.log(chalk_1.default.cyan.bold('╔═══════════════════════════════════════╗'));
-    console.log(chalk_1.default.cyan.bold('║     🧠 ekkOS Memory System Setup      ║'));
+    if (isQuick) {
+        console.log(chalk_1.default.cyan.bold('║   ⚡ ekkOS Quick Setup                ║'));
+    }
+    else {
+        console.log(chalk_1.default.cyan.bold('║     🧠 ekkOS Memory System Setup      ║'));
+    }
     console.log(chalk_1.default.cyan.bold('╚═══════════════════════════════════════╝'));
     console.log('');
     // Check templates exist
@@ -347,11 +374,11 @@ async function init(options) {
     // STEP 1: Authentication
     let auth;
     if (options.key) {
-        // Manual API key provided
+        // Manual API key provided — always use it (respects --quick)
         auth = await manualKeyAuth(options.key);
     }
     else if (existingConfig?.apiKey && !options.force) {
-        // Already authenticated
+        // Already authenticated — skip auth step entirely (works great with --quick)
         console.log(chalk_1.default.cyan('Step 1/3: Authentication'));
         console.log(chalk_1.default.gray('─'.repeat(40)));
         console.log('');
@@ -365,6 +392,10 @@ async function init(options) {
             tier: existingConfig.tier || 'unknown'
         };
     }
+    else if (isQuick) {
+        // --quick with no stored key: fall back to manual key prompt (one question only)
+        auth = await manualKeyAuth();
+    }
     else {
         // Device auth flow
         try {
@@ -395,7 +426,8 @@ async function init(options) {
         console.log('');
     }
     else {
-        selectedIDEs = await selectIDEs();
+        // Pass autoSelect=true when --quick is set so we skip the checkbox prompt
+        selectedIDEs = await selectIDEs(isQuick);
     }
     // STEP 3: Deployment
     console.log(chalk_1.default.cyan('Step 3/3: Deploying'));
@@ -461,7 +493,13 @@ async function init(options) {
     };
     console.log('');
     console.log(chalk_1.default.green.bold('╔═══════════════════════════════════════╗'));
-    console.log(chalk_1.default.green.bold('║          ✓ Setup complete!            ║'));
+    if (isQuick) {
+        const quickIdeName = ideNames.join(' / ') || 'Claude Code';
+        console.log(chalk_1.default.green.bold(`║  ⚡ Quick setup complete for ${quickIdeName.padEnd(11)}║`));
+    }
+    else {
+        console.log(chalk_1.default.green.bold('║          ✓ Setup complete!            ║'));
+    }
     console.log(chalk_1.default.green.bold('╚═══════════════════════════════════════╝'));
     console.log('');
     console.log(chalk_1.default.white.bold('  MCP configured:'));