pyre-cli 9.0.0 → 9.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-cli",
-  "version": "9.0.0",
+  "version": "9.1.0",
   "description": "CLI Mac monitoring tool: temps, system stats, live dashboard, packet monitor, battery predictor, export",
   "main": "dist/index.js",
   "type": "module",

package/src/anomaliesCmd.ts

@@ -20,7 +20,7 @@ export function runAnomaliesDigest(opts: AnomaliesCmdOptions = {}): void {
     return;
   }
 
-  const files = fs.readdirSync(dir).filter(f => f.startsWith('pyre-log-') && f.endsWith('.csv'));
+  const files = fs.readdirSync(dir).filter(f => f.startsWith('pyre-') && f.endsWith('.csv'));
   if (files.length === 0) {
     console.log(chalk.yellow(`  No CSV logs found for range '${sinceStr}' in ${dir}.`));
     console.log(chalk.dim('  Enable background logging with `pyre --log` to record history.\n'));

package/src/formatters/render.ts

@@ -474,7 +474,8 @@ function pctColor(v: number): (s: string) => string {
 function processTableLines(
    processes: { pid: number; ppid: number; user: string; cpu: number; mem: number; command: string; state: string; threads: number; runtime: number }[],
    contentWidth: number,
-   borderAccent = THEMES.default.border
+   borderAccent = THEMES.default.border,
+   selectedIdx: number = -1
  ): string[] {
     const pidW = 8, ppidW = 8, userW = 12, cpuW = 8, memW = 8, stateW = 8, thrW = 6, rtW = 10;
 
@@ -490,13 +491,14 @@ function processTableLines(
       chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' RUNTIME  ') +
       chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' COMMAND'.padEnd(cmdW + 1));
 
-   const rows = processes.map(p => {
+   const rows = processes.map((p, idx) => {
+     const isSelected = idx === selectedIdx;
      const cpuStr = pctColor(p.cpu)(`${p.cpu.toFixed(1)}`.padEnd(cpuW));
      const memStr = pctColor(p.mem)(`${p.mem.toFixed(1)}`.padEnd(memW));
      const stateStr = chalk.dim(p.state.padEnd(stateW));
      const thrStr = String(p.threads).padEnd(thrW);
      const rtStr = formatRuntime(p.runtime).padEnd(rtW);
-     return (
+     const line = (
        String(p.pid).padEnd(pidW) +
        String(p.ppid).padEnd(ppidW) +
        truncatePlain(p.user, userW - 1).padEnd(userW) +
@@ -507,6 +509,7 @@ function processTableLines(
        rtStr +
        truncatePlain(p.command, cmdW)
      );
+     return isSelected ? chalk.bgCyan.black(line) : line;
    });
    return [head, borderAccent('─'.repeat(contentWidth)), ...rows];
  }
@@ -605,7 +608,7 @@ function diskTableLines(
 
 // --- main dashboard ------------------------------------------------------------
 
-function detailPanelTitle(panel: string): string {
+function detailPanelTitle(panel: string, trackedPid?: number | null): string {
   const map: Record<string, string> = {
     cpu: 'CPU',
     mem: 'Memory',
@@ -617,7 +620,7 @@ function detailPanelTitle(panel: string): string {
     packets: 'Packets',
     tasks: 'Tasks',
     disk: 'Disk',
-    process: 'Processes',
+    process: trackedPid !== undefined && trackedPid !== null ? `Processes (Following PID ${trackedPid})` : 'Processes',
   };
   return map[panel] || panel;
 }
@@ -681,11 +684,51 @@ function activeDetailLines(data: StatsData, activePanel: string, width: number,
         ? data.processes.filter(p => p.command.toLowerCase().includes(opts.filter!.toLowerCase()))
         : data.processes;
       const sorted = sortProcesses(filtered, opts.sortBy ?? 'cpu');
-      const limited = opts.processLimit ? sorted.slice(0, opts.processLimit) : sorted;
+      let selectedIdx = opts.selectedProcessIndex ?? -1;
+      const isTracking = opts.trackedPid !== undefined && opts.trackedPid !== null;
+      if (isTracking) {
+        const trackedIdx = sorted.findIndex(p => p.pid === opts.trackedPid);
+        if (trackedIdx >= 0) {
+          selectedIdx = trackedIdx;
+        }
+      }
+
+      // Build tracking info header lines if we're following a process
+      const trackingLines: string[] = [];
+      if (isTracking) {
+        const tp = sorted.find(p => p.pid === opts.trackedPid);
+        if (tp) {
+          const cpuColor = tp.cpu > 50 ? chalk.red.bold : tp.cpu > 20 ? chalk.yellow : chalk.green;
+          const memColor = tp.mem > 50 ? chalk.red.bold : tp.mem > 20 ? chalk.yellow : chalk.green;
+          trackingLines.push(chalk.bgHex('#1a1a2e').hex('#e94560').bold(` ◉ FOLLOWING PID ${tp.pid} — ${truncatePlain(tp.command, Math.max(10, contentWidth - 30))} `));
+          trackingLines.push(
+            `  ${chalk.bold('CPU:')} ${cpuColor(tp.cpu.toFixed(1) + '%')}   ` +
+            `${chalk.bold('MEM:')} ${memColor(tp.mem.toFixed(1) + '%')}   ` +
+            `${chalk.bold('State:')} ${chalk.dim(tp.state)}   ` +
+            `${chalk.bold('Threads:')} ${tp.threads}   ` +
+            `${chalk.bold('Runtime:')} ${formatRuntime(tp.runtime)}   ` +
+            `${chalk.bold('User:')} ${tp.user}`
+          );
+          trackingLines.push(chalk.dim(`  Full: ${tp.command}`));
+          trackingLines.push(theme.border('─'.repeat(contentWidth)));
+        } else {
+          trackingLines.push(chalk.yellow(` ◉ PID ${opts.trackedPid} exited — no longer in process list`));
+          trackingLines.push(theme.border('─'.repeat(contentWidth)));
+        }
+      }
+
+      const availableRows = Math.max(1, (opts.processLimit || sorted.length) - trackingLines.length);
+      let offset = 0;
+      if (selectedIdx >= 0) {
+        if (selectedIdx >= availableRows) {
+          offset = selectedIdx - availableRows + 1;
+        }
+      }
+      const visible = sorted.slice(offset, offset + availableRows);
       if (opts.treeView) {
-        return buildProcessTree(limited);
+        return [...trackingLines, ...buildProcessTree(visible)];
       }
-      return processTableLines(limited, width - 4, theme.border);
+      return [...trackingLines, ...processTableLines(visible, width - 4, theme.border, selectedIdx - offset)];
     }
     case 'anomalies': {
       if (!opts.anomalyHistory || opts.anomalyHistory.length === 0) return ['No anomalies detected yet.'];
@@ -854,9 +897,48 @@ function btopProcBox(data: StatsData, width: number, targetHeight: number, theme
 
   const headerRowOverhead = 2; // top & bottom border
   const tableHeaderOverhead = 2; // header + separator line
-  const availableRows = Math.max(1, targetHeight - headerRowOverhead - tableHeaderOverhead);
 
-  const limited = sorted.slice(0, availableRows);
+  const isTracking = opts.trackedPid !== undefined && opts.trackedPid !== null;
+
+  // Build compact tracking info lines
+  const trackingLines: string[] = [];
+  if (isTracking) {
+    const tp = sorted.find(p => p.pid === opts.trackedPid);
+    if (tp) {
+      const cpuColor = tp.cpu > 50 ? chalk.red.bold : tp.cpu > 20 ? chalk.yellow : chalk.green;
+      const memColor = tp.mem > 50 ? chalk.red.bold : tp.mem > 20 ? chalk.yellow : chalk.green;
+      trackingLines.push(chalk.bgHex('#1a1a2e').hex('#e94560').bold(` ◉ PID ${tp.pid} ${truncatePlain(tp.command, Math.max(6, contentWidth - 20))} `));
+      trackingLines.push(
+        ` ${cpuColor('CPU ' + tp.cpu.toFixed(1) + '%')} ` +
+        `${memColor('MEM ' + tp.mem.toFixed(1) + '%')} ` +
+        `${chalk.dim(tp.state)} ` +
+        `THR:${tp.threads} ` +
+        `${formatRuntime(tp.runtime)}`
+      );
+      trackingLines.push(theme.border('─'.repeat(contentWidth)));
+    } else {
+      trackingLines.push(chalk.yellow(` ◉ PID ${opts.trackedPid} exited`));
+      trackingLines.push(theme.border('─'.repeat(contentWidth)));
+    }
+  }
+
+  const availableRows = Math.max(1, targetHeight - headerRowOverhead - tableHeaderOverhead - trackingLines.length);
+
+  let selectedIdx = opts.selectedProcessIndex ?? -1;
+  if (isTracking) {
+    const trackedIdx = sorted.findIndex(p => p.pid === opts.trackedPid);
+    if (trackedIdx >= 0) {
+      selectedIdx = trackedIdx;
+    }
+  }
+
+  let offset = 0;
+  if (selectedIdx >= 0) {
+    if (selectedIdx >= availableRows) {
+      offset = selectedIdx - availableRows + 1;
+    }
+  }
+  const visible = sorted.slice(offset, offset + availableRows);
 
   const pidW = 6, userW = 7, thrW = 3, memW = 6, cpuW = 6;
   const fixedW = pidW + userW + thrW + memW + cpuW + 5;
@@ -871,12 +953,14 @@ function btopProcBox(data: StatsData, width: number, targetHeight: number, theme
     chalk.bold('CPU%'.padStart(cpuW));
 
   if (opts.treeView) {
-    const treeLines = buildProcessTree(limited);
-    const rightTitle = opts.filter ? `filter: "${opts.filter}"` : `tree · sort: ${opts.sortBy || 'cpu'}`;
-    return panel('P proc', [head, theme.border('─'.repeat(contentWidth)), ...treeLines], width, theme.process, theme.border, targetHeight - 2, rightTitle);
+    const treeLines = buildProcessTree(visible);
+    let rightTitle = opts.filter ? `filter: "${opts.filter}"` : `tree · sort: ${opts.sortBy || 'cpu'}`;
+    if (isTracking) rightTitle += ` · following PID ${opts.trackedPid}`;
+    return panel('P proc', [...trackingLines, head, theme.border('─'.repeat(contentWidth)), ...treeLines], width, theme.process, theme.border, targetHeight - 2, rightTitle);
   }
 
-  const rows = limited.map(p => {
+  const rows = visible.map((p, idx) => {
+    const isSelected = (offset + idx) === selectedIdx;
     const cpuVal = p.cpu.toFixed(1) + '%';
     const cpuStr = p.cpu > 50 ? chalk.red.bold(cpuVal.padStart(cpuW)) : p.cpu > 20 ? chalk.yellow(cpuVal.padStart(cpuW)) : chalk.green(cpuVal.padStart(cpuW));
     const memStr = (p.mem.toFixed(1) + '%').padStart(memW);
@@ -885,15 +969,19 @@ function btopProcBox(data: StatsData, width: number, targetHeight: number, theme
     const pidStr = String(p.pid).padEnd(pidW);
     const cmdStr = truncatePlain(p.command, cmdW).padEnd(cmdW);
 
-    return `${pidStr} ${cmdStr} ${userStr} ${thrStr} ${memStr} ${cpuStr}`;
+    const line = `${pidStr} ${cmdStr} ${userStr} ${thrStr} ${memStr} ${cpuStr}`;
+    return isSelected ? chalk.bgCyan.black(line) : line;
   });
 
-  const lines = [head, theme.border('─'.repeat(contentWidth)), ...rows];
+  const lines = [...trackingLines, head, theme.border('─'.repeat(contentWidth)), ...rows];
   if (rows.length === 0) {
     lines.push(chalk.dim(`No processes match "${opts.filter || ''}"`));
   }
 
-  const rightTitle = opts.filter ? `filter: "${opts.filter}"` : `sort: ${opts.sortBy || 'cpu'}`;
+  let rightTitle = opts.filter ? `filter: "${opts.filter}"` : `sort: ${opts.sortBy || 'cpu'}`;
+  if (isTracking) {
+    rightTitle += ` · following PID ${opts.trackedPid}`;
+  }
   return panel('P proc', lines, width, theme.process, theme.border, targetHeight - 2, rightTitle);
 }
 
@@ -920,33 +1008,34 @@ export function formatTable(data: StatsData, opts: TableOptions = {}): string {
   if (activePanel !== 'grid') {
     const lines = activeDetailLines(data, activePanel, width, opts);
     if (lines) {
-      out.push(...panel(detailPanelTitle(activePanel), lines, width, theme[activePanel as keyof ThemeColors] ?? theme.cpu, theme.border));
+      out.push(...panel(detailPanelTitle(activePanel, opts.trackedPid), lines, width, theme[activePanel as keyof ThemeColors] ?? theme.cpu, theme.border));
     }
-    return out.join('\n');
-  }
-
-  // --- btop Dashboard Grid ---
-  // 1. Top CPU & System Overview Box
-  out.push(...btopCpuBox(data, width, theme, opts));
-  out.push('');
+  } else {
+    // --- btop Dashboard Grid ---
+    // 1. Top CPU & System Overview Box
+    out.push(...btopCpuBox(data, width, theme, opts));
+    out.push('');
 
-  // 2. Bottom Split Section
-  if (width >= 85) {
-    const leftColW = Math.max(32, Math.floor(width * 0.38));
-    const rightColW = width - leftColW - 2;
+    // 2. Bottom Split Section
+    if (width >= 85) {
+      const leftColW = Math.max(32, Math.floor(width * 0.38));
+      const rightColW = width - leftColW - 2;
 
-    const leftLines = btopLeftColumn(data, leftColW, theme, opts);
-    const procLines = btopProcBox(data, rightColW, leftLines.length, theme, opts);
+      const leftLines = btopLeftColumn(data, leftColW, theme, opts);
+      const procLines = btopProcBox(data, rightColW, leftLines.length, theme, opts);
 
-    out.push(...hstack([leftLines, procLines], 2, width));
-  } else {
-    const leftLines = btopLeftColumn(data, width, theme, opts);
-    out.push(...leftLines);
-    out.push('');
-    const procLines = btopProcBox(data, width, 12, theme, opts);
-    out.push(...procLines);
+      out.push(...hstack([leftLines, procLines], 2, width));
+    } else {
+      const leftLines = btopLeftColumn(data, width, theme, opts);
+      out.push(...leftLines);
+      out.push('');
+      const procLines = btopProcBox(data, width, 12, theme, opts);
+      out.push(...procLines);
+    }
   }
 
+  // Inspect process modal has been replaced by inline tracking headers
+
   return out.join('\n');
 }
 

package/src/formatters/types.ts

@@ -80,4 +80,10 @@ export interface TableOptions {
     graphMode?: 'spark' | 'bar';
     /** Panel layout order. */
     panelLayout?: string[];
+    /** Currently selected process index for highlight. */
+    selectedProcessIndex?: number;
+    /** Currently tracked PID. */
+    trackedPid?: number | null;
+    /** Currently inspected process details for modal overlay. */
+    inspectProcess?: any;
 }

package/src/live/input.ts

@@ -10,7 +10,7 @@ import readline from 'node:readline';
 import chalk from 'chalk';
 import { collectAll, StatsData } from '../monitors/index.js';
 import { THEMES, type ThemeName, type VisibleItems, getTabHitboxes, TAB_BAR_ROW } from '../formatters/index.js';
-import { state, setStatus, getToggleKey, type SplashColorScheme, type SplashAnimation } from './state.js';
+import { state, setStatus, getToggleKey, type SplashColorScheme, type SplashAnimation, MENU_OPTIONS } from './state.js';
 import { exportSnapshot, startLogging, stopLogging, toggleLogging, writeLogRow } from './export.js';
 import { render, footerLine, checkAlerts, invalidateTableCache, invalidateFrame } from './render.js';
 import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode, ActivePanel } from './types.js';
@@ -115,6 +115,70 @@ function handleInputModeKey(str: string, key: readline.Key) {
       return;
    }
 
+    if (state.inputMode === 'menu') {
+      if (isEscKey(key, str)) {
+        state.inputMode = null;
+        render();
+        return;
+      }
+      if (isUpKey(key, str)) {
+        state.menuSelectionIndex = (state.menuSelectionIndex - 1 + MENU_OPTIONS.length) % MENU_OPTIONS.length;
+        render();
+        return;
+      }
+      if (isDownKey(key, str)) {
+        state.menuSelectionIndex = (state.menuSelectionIndex + 1) % MENU_OPTIONS.length;
+        render();
+        return;
+      }
+      if (isEnterKey(key, str) || str === ' ') {
+        const option = MENU_OPTIONS[state.menuSelectionIndex];
+        switch (option) {
+          case 'Resume Dashboard':
+            state.inputMode = null;
+            break;
+          case 'Settings (Customizer)':
+            state.inputMode = 'customizer';
+            state.customizerIndex = 0;
+            break;
+          case 'Readme':
+            state.inputMode = 'readme';
+            break;
+          case 'Credits':
+            state.inputMode = 'credits';
+            break;
+          case 'Quit pyre':
+            process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+            process.exit(0);
+        }
+        render();
+        return;
+      }
+      render();
+      return;
+    }
+
+    if (state.inputMode === 'readme' || state.inputMode === 'credits') {
+      if (isEscKey(key, str) || isEnterKey(key, str)) {
+        state.inputMode = 'menu';
+        render();
+        return;
+      }
+      if (state.inputMode === 'readme') {
+        if (isUpKey(key, str)) {
+          state.readmeScrollOffset = Math.max(0, state.readmeScrollOffset - 1);
+          render();
+          return;
+        }
+        if (isDownKey(key, str)) {
+          state.readmeScrollOffset += 1;
+          render();
+          return;
+        }
+      }
+      return;
+    }
+
     if (state.inputMode === 'signal') {
       if (isUpKey(key, str)) {
        const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
@@ -569,11 +633,72 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
         case 'tab':
           cycleTab(1);
           break;
+        case 'up':
+          if (state.lastData?.processes?.length) {
+            state.trackedPid = null;
+            state.processSelectionIndex = Math.max(0, state.processSelectionIndex - 1);
+            render();
+          }
+          break;
+        case 'down':
+          if (state.lastData?.processes?.length) {
+            state.trackedPid = null;
+            const count = state.lastData.processes.length;
+            state.processSelectionIndex = Math.min(count - 1, state.processSelectionIndex + 1);
+            render();
+          }
+          break;
+        case 'space':
+        case ' ':
+          if (state.lastData?.processes?.length && state.processSelectionIndex >= 0) {
+            const sorted = state.lastData.processes;
+            const proc = sorted[state.processSelectionIndex];
+            if (proc) {
+              if (state.trackedPid === proc.pid) {
+                state.trackedPid = null;
+                setStatus(`Stopped following PID ${proc.pid}`);
+              } else {
+                state.trackedPid = proc.pid;
+                setStatus(`Following PID ${proc.pid} (${proc.command})`);
+              }
+              render();
+            }
+          }
+          break;
+        case 'return':
+        case 'enter':
+          if (state.inspectingProcess) {
+            state.inspectingProcess = null;
+            render();
+          } else if (state.lastData?.processes?.length && state.processSelectionIndex >= 0) {
+            const sorted = state.lastData.processes;
+            const proc = sorted[state.processSelectionIndex];
+            if (proc) {
+              state.inspectingProcess = proc;
+              state.trackedPid = proc.pid;
+              setStatus(`Inspecting & following PID ${proc.pid}`);
+              render();
+            }
+          }
+          break;
         case 'escape':
         case 'esc':
-          state.activePanel = 'grid';
-          setStatus('Grid view');
-          render();
+          if (state.inspectingProcess) {
+            state.inspectingProcess = null;
+            render();
+          } else if (state.trackedPid !== null) {
+            state.trackedPid = null;
+            setStatus('Stopped following process');
+            render();
+          } else if (state.activePanel !== 'grid') {
+            state.activePanel = 'grid';
+            setStatus('Grid view');
+            render();
+          } else {
+            state.inputMode = 'menu';
+            state.menuSelectionIndex = 0;
+            render();
+          }
           break;
         default:
           if (str && str.length === 1) {
@@ -592,7 +717,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
   }
 
   function tabKeyToId(str: string): string | null {
-    const map: Record<string, string> = { '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power', '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks', '0': 'disk', 'p': 'process', 'r': 'p2p' };
+    const map: Record<string, string> = { '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power', '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks', '0': 'disk', 'p': 'process', 'r': 'p2p', 'A': 'anomalies' };
     return map[str] ?? null;
   }
 
@@ -612,6 +737,12 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
     const cy = seq.charCodeAt(5) - 32;
     if (cb === 0 || cb === 1) {
       handleMouseClick(cy, cx);
+    } else if (cb === 64) {
+      // scroll up
+      scrollProcessSelection(-1);
+    } else if (cb === 65) {
+      // scroll down
+      scrollProcessSelection(1);
     }
   }
 
@@ -623,6 +754,19 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
     const cy = parseInt(match[3]) - 1;
     if (button === 0 || button === 1) {
       handleMouseClick(cy, cx);
+    } else if (button === 64) {
+      scrollProcessSelection(-1);
+    } else if (button === 65) {
+      scrollProcessSelection(1);
+    }
+  }
+
+  function scrollProcessSelection(dir: number) {
+    if (state.lastData?.processes?.length) {
+      state.trackedPid = null;
+      const count = state.lastData.processes.length;
+      state.processSelectionIndex = Math.max(0, Math.min(count - 1, state.processSelectionIndex + dir));
+      render();
     }
   }
 

package/src/live/render.ts

@@ -7,10 +7,13 @@
  * `state.ts`.
  */
 import { execFile, exec } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
-import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel, fitVisible } from '../formatters/index.js';
+import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel, fitVisible, visLen } from '../formatters/index.js';
 import { detectAnomalies } from '../anomalies.js';
-import { state, setStatus, SIGNAL_OPTIONS, getToggleKey } from './state.js';
+import { state, setStatus, SIGNAL_OPTIONS, getToggleKey, MENU_OPTIONS } from './state.js';
 import type { StatsData } from '../monitors/index.js';
 
 function formatTempForUnit(c: number): string {
@@ -48,6 +51,9 @@ function tableCacheParams(): string {
   return [
     state.sortMode,
     state.processFilter || '',
+    state.processSelectionIndex,
+    state.trackedPid || '',
+    state.inspectingProcess ? state.inspectingProcess.pid : '',
     limit,
     state.currentTheme,
     state.activePanel,
@@ -197,13 +203,41 @@ function render() {
     writeFrame(out);
     return;
   }
+
+  if (state.inputMode === 'menu') {
+    writeFrame(renderSplashMenu(cols, rows));
+    return;
+  }
+  if (state.inputMode === 'readme') {
+    writeFrame(renderReadme(cols, rows));
+    return;
+  }
+  if (state.inputMode === 'credits') {
+    writeFrame(renderCredits(cols, rows));
+    return;
+  }
   const lines: string[] = [];
   const theme = THEMES[state.currentTheme] || THEMES.default;
 
    const params = tableCacheParams();
    const anomalies = detectAnomalies(state.lastData, state.history);
+   if (anomalies.length > 0) {
+     for (const a of anomalies) {
+       const now = new Date();
+       const alertWithTime = { ...a, timestamp: now };
+       const exists = state.anomalyHistory.some(
+         h => h.metric === a.metric && Math.abs(h.zScore - a.zScore) < 0.1 && (now.getTime() - (h.timestamp?.getTime() || 0)) < 10000
+       );
+       if (!exists) {
+         state.anomalyHistory.unshift(alertWithTime);
+       }
+     }
+     if (state.anomalyHistory.length > 100) {
+       state.anomalyHistory.length = 100;
+     }
+   }
    const anomalyCacheKey = anomalies.map(a => `${a.metric}:${a.zScore.toFixed(2)}`).join(',');
-   const cacheParams = params + '|' + anomalyCacheKey;
+   const cacheParams = params + '|' + anomalyCacheKey + '|' + state.anomalyHistory.length;
     const tableStr = _tableDataDirty || state.lastData !== _cachedTableData || cacheParams !== _cachedTableParams
       ? (() => {
           const out = formatTable(state.lastData, {
@@ -221,6 +255,9 @@ function render() {
             history: state.history,
             graphMode: state.graphMode,
             panelLayout: state.panelLayout,
+            selectedProcessIndex: state.processSelectionIndex,
+            trackedPid: state.trackedPid,
+            inspectProcess: state.inspectingProcess,
           });
           _cachedTableData = state.lastData;
           _cachedTableParams = cacheParams;
@@ -422,4 +459,109 @@ function checkAlerts(data: StatsData) {
    }
   }
 
+function renderSplashMenu(cols: number, rows: number): string[] {
+  const out: string[] = [];
+  const contentLines: string[] = [];
+  const logo = [
+    chalk.hex('#ff6004').bold('                ██████╗ ██╗   ██╗██████╗ ███████╗'),
+    chalk.hex('#ff8004').bold('                ██╔══██╗╚██╗ ██╔╝██╔══██╗██╔════╝'),
+    chalk.hex('#ffa004').bold('                ██████╔╝ ╚████╔╝ ██████╔╝█████╗  '),
+    chalk.hex('#ffc004').bold('                ██╔═══╝   ╚██╔╝  ██╔══██╗██╔══╝  '),
+    chalk.hex('#ffe004').bold('                ██║        ██║   ██║  ██║███████╗'),
+    chalk.hex('#ffff40').bold('                ╚═╝        ╚═╝   ╚═╝  ╚═╝╚══════╝')
+  ];
+
+  const menuTop = Math.max(0, Math.floor(rows / 2) - 8);
+  for (let i = 0; i < menuTop; i++) out.push('');
+
+  const strip = (s: string) => s.replace(/^(\x1b\[[0-9;]*m)+( +)/, '$1');
+  for (const line of logo) contentLines.push(strip(line));
+  contentLines.push('');
+  contentLines.push(strip(chalk.dim('                  system monitor v9.0.0')));
+  contentLines.push('');
+  contentLines.push('');
+
+  for (let i = 0; i < MENU_OPTIONS.length; i++) {
+    const isSelected = i === state.menuSelectionIndex;
+    const opt = MENU_OPTIONS[i];
+    const prefix = isSelected ? chalk.cyan.bold('  ▶ ') : '    ';
+    const text = isSelected ? chalk.bgCyan.black(` ${opt} `) : chalk.dim(` ${opt} `);
+    contentLines.push(prefix + text);
+  }
+
+  contentLines.push('');
+  contentLines.push('');
+  contentLines.push(strip(chalk.dim('             Use ↑/↓ to navigate, Enter to select')));
+
+  while (contentLines.length < rows) contentLines.push('');
+  const maxWidth = Math.max(...contentLines.map(visLen));
+  const padding = Math.max(0, Math.floor((cols - maxWidth) / 2));
+  const padStr = ' '.repeat(padding);
+  for (const line of contentLines) out.push(padStr + fitVisible(line, cols));
+  return out;
+}
+
+let cachedReadmeLines: string[] | null = null;
+
+function getReadmeLines(): string[] {
+  if (cachedReadmeLines) return cachedReadmeLines;
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const rootDir = path.resolve(__dirname, '..', '..');
+    const readmePath = path.join(rootDir, 'README.md');
+    const content = fs.readFileSync(readmePath, 'utf8');
+    cachedReadmeLines = content.split('\n');
+    return cachedReadmeLines;
+  } catch (err) {
+    return [chalk.red('Failed to load README.md')];
+  }
+}
+
+function renderReadme(cols: number, rows: number): string[] {
+  const lines = getReadmeLines();
+  const availableLines = Math.max(1, rows - 2); // Body height of the panel
+  
+  const startIdx = Math.min(state.readmeScrollOffset, Math.max(0, lines.length - availableLines));
+  state.readmeScrollOffset = startIdx; // Clamp the state value
+  
+  const content = lines.slice(startIdx, startIdx + availableLines).map(l => {
+    let out = l;
+    if (out.startsWith('#')) {
+       out = chalk.cyan.bold(out);
+    } else if (out.startsWith('```')) {
+       out = chalk.dim(out);
+    } else if (out.startsWith('- ') || out.startsWith('* ')) {
+       out = '  ' + chalk.yellow(out.substring(0, 2)) + out.substring(2);
+    }
+    return out;
+  });
+
+  const out: string[] = [];
+  const pct = Math.round((startIdx / Math.max(1, lines.length - availableLines)) * 100);
+  const title = lines.length > availableLines 
+    ? `README (${pct}%)` 
+    : 'README';
+  out.push(...panel(title, content, cols, chalk.cyan, chalk.dim, availableLines));
+  return out;
+}
+
+function renderCredits(cols: number, rows: number): string[] {
+  const out: string[] = [];
+  const content = [
+    chalk.bold.hex('#ff6004')('Pyre - The Terminal System Monitor'),
+    '',
+    'Created with ❤️  using Node.js',
+    '',
+    chalk.cyan('Libraries used:'),
+    '  - chalk       (Terminal styling)',
+    '  - systeminformation (System metrics)',
+    '',
+    chalk.dim('Press Esc or Enter to return to menu.')
+  ];
+
+  out.push(...panel('CREDITS', content, cols, chalk.magenta, chalk.dim, rows - 2));
+  return out;
+}
+
 export { render, footerLine, renderCustomizerOverlay, checkAlerts, processRowBudget, invalidateTableCache, invalidateFrame };