pyre-cli 4.17.0 → 5.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-cli",
-  "version": "4.17.0",
+  "version": "5.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/anomalies.ts

@@ -0,0 +1,102 @@
+/**
+ * Anomaly / spike detection for pyre.
+ *
+ * Uses the rolling history windows in {@link History} to compute
+ * per-metric z-scores and flag statistically unusual behaviour
+ * (deviation > N sigma from the baseline).
+ */
+import { History } from './history.js';
+import type { StatsData } from './monitors/types.js';
+
+export interface AnomalyAlert {
+  metric: string;
+  value: number;
+  zScore: number;
+  severity: 'warning' | 'critical';
+}
+
+const ZSCORE_THRESHOLD = 2.5;
+const CRITICAL_ZSCORE = 3.5;
+const MIN_SAMPLES = 5;
+
+export function detectAnomalies(data: StatsData, history: History): AnomalyAlert[] {
+  const alerts: AnomalyAlert[] = [];
+
+  const cpuZ = History.zScore(data.cpu.usage, history.cpuUsage);
+  if (Math.abs(cpuZ) > ZSCORE_THRESHOLD && history.cpuUsage.length >= MIN_SAMPLES) {
+    alerts.push({
+      metric: 'CPU',
+      value: data.cpu.usage,
+      zScore: cpuZ,
+      severity: Math.abs(cpuZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+    });
+  }
+
+  const memZ = History.zScore(data.memory.usagePercent, history.memUsage);
+  if (Math.abs(memZ) > ZSCORE_THRESHOLD && history.memUsage.length >= MIN_SAMPLES) {
+    alerts.push({
+      metric: 'Memory',
+      value: data.memory.usagePercent,
+      zScore: memZ,
+      severity: Math.abs(memZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+    });
+  }
+
+  if (data.cpu.temperature !== undefined) {
+    const tempZ = History.zScore(data.cpu.temperature, history.temp);
+    if (Math.abs(tempZ) > ZSCORE_THRESHOLD && history.temp.length >= MIN_SAMPLES) {
+      alerts.push({
+        metric: 'Temp',
+        value: data.cpu.temperature,
+        zScore: tempZ,
+        severity: Math.abs(tempZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+      });
+    }
+  }
+
+  const netRxZ = History.zScore(data.network.rxBytes, history.netRxRate);
+  if (Math.abs(netRxZ) > ZSCORE_THRESHOLD && history.netRxRate.length >= MIN_SAMPLES) {
+    alerts.push({
+      metric: 'Net RX',
+      value: data.network.rxBytes,
+      zScore: netRxZ,
+      severity: Math.abs(netRxZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+    });
+  }
+
+  const netTxZ = History.zScore(data.network.txBytes, history.netTxRate);
+  if (Math.abs(netTxZ) > ZSCORE_THRESHOLD && history.netTxRate.length >= MIN_SAMPLES) {
+    alerts.push({
+      metric: 'Net TX',
+      value: data.network.txBytes,
+      zScore: netTxZ,
+      severity: Math.abs(netTxZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+    });
+  }
+
+  if (data.power?.combinedWatts !== undefined) {
+    const powerZ = History.zScore(data.power.combinedWatts, history.powerWatts);
+    if (Math.abs(powerZ) > ZSCORE_THRESHOLD && history.powerWatts.length >= MIN_SAMPLES) {
+      alerts.push({
+        metric: 'Power',
+        value: data.power.combinedWatts,
+        zScore: powerZ,
+        severity: Math.abs(powerZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+      });
+    }
+  }
+
+  if (data.gpu) {
+    const gpuZ = History.zScore(data.gpu.utilization, history.gpuUtil);
+    if (Math.abs(gpuZ) > ZSCORE_THRESHOLD && history.gpuUtil.length >= MIN_SAMPLES) {
+      alerts.push({
+        metric: 'GPU',
+        value: data.gpu.utilization,
+        zScore: gpuZ,
+        severity: Math.abs(gpuZ) > CRITICAL_ZSCORE ? 'critical' : 'warning',
+      });
+    }
+  }
+
+  return alerts;
+}

package/src/formatters/index.ts

@@ -11,7 +11,7 @@
  * - `render.ts` — dashboard layout, cards, tables, and the main `formatTable`
  * - `output.ts` — JSON/CSV/TSV export and sparkline graph rendering
  */
-export { formatTable, clampWidth, gridColumns, thermalColor, capacityColor, getTabHitboxes, TAB_BAR_ROW, TAB_DEFS, panel } from './render.js';
-export { formatJson, formatCsv, formatTsv, formatGraphs } from './output.js';
-export type { ThemeName, ThemeColors, VisibleItems, TableOptions } from './types.js';
+export { formatTable, clampWidth, gridColumns, thermalColor, capacityColor, getTabHitboxes, TAB_BAR_ROW, TAB_DEFS, panel, formatBytes } from './render.js';
+export { formatJson, formatCsv, formatTsv, formatGraphs, formatHtml, formatMarkdown } from './output.js';
+export type { ThemeName, ThemeColors, VisibleItems, TableOptions, AnomalyAlert } from './types.js';
 export { THEMES } from './themes.js';

package/src/formatters/output.ts

@@ -17,6 +17,337 @@ export function formatJson(data: StatsData): string {
   return JSON.stringify(data, null, 2);
 }
 
+export function formatHtml(data: StatsData): string {
+  const rows = (items: { label: string; value: string }[]) =>
+    items.map(i => `<tr><td class="label">${escapeHtml(i.label)}</td><td class="value">${escapeHtml(i.value)}</td></tr>`).join('\n');
+
+  const sections: string[] = [];
+
+  sections.push(`<h2>System</h2>
+<table>
+  ${rows([
+    { label: 'Hostname', value: data.header.hostname },
+    { label: 'OS', value: data.header.os },
+    { label: 'Uptime', value: data.header.uptime },
+    { label: 'Timestamp', value: data.timestamp },
+  ]).trim()}
+</table>`);
+
+  sections.push(`<h2>CPU</h2>
+<table>
+  ${rows([
+    { label: 'Brand', value: data.cpu.brand },
+    { label: 'Cores', value: `${data.cpu.physicalCores}/${data.cpu.cores}` },
+    { label: 'Frequency', value: `${data.cpu.frequency} MHz` },
+    { label: 'Usage', value: `${data.cpu.usage}%` },
+    { label: 'Load Avg', value: data.cpu.loadAvg.map(l => l.toFixed(2)).join(' ') },
+    ...(data.cpu.temperature ? [{ label: 'Temperature', value: `${data.cpu.temperature.toFixed(1)}°C` }] : []),
+  ]).trim()}
+</table>`);
+
+  sections.push(`<h2>Memory</h2>
+<table>
+  ${rows([
+    { label: 'Total', value: formatBytes(data.memory.total) },
+    { label: 'Used', value: formatBytes(data.memory.used) },
+    { label: 'Free', value: formatBytes(data.memory.free) },
+    { label: 'Usage', value: `${data.memory.usagePercent}%` },
+    { label: 'Swap', value: `${formatBytes(data.memory.swapUsed)} / ${formatBytes(data.memory.swapTotal)}` },
+  ]).trim()}
+</table>`);
+
+  if (data.gpu) {
+    sections.push(`<h2>GPU</h2>
+<table>
+  ${rows([
+    { label: 'Model', value: data.gpu.model },
+    { label: 'Memory', value: formatBytes(data.gpu.memory) },
+    { label: 'Utilization', value: `${data.gpu.utilization}%` },
+    ...(data.gpu.temperature ? [{ label: 'Temperature', value: `${data.gpu.temperature.toFixed(1)}°C` }] : []),
+    { label: 'Processes', value: String(data.gpu.processes) },
+  ]).trim()}
+</table>`);
+  }
+
+  if (data.power) {
+    const powerRows: { label: string; value: string }[] = [];
+    if (data.power.cpuWatts !== undefined) powerRows.push({ label: 'CPU', value: `${data.power.cpuWatts.toFixed(2)} W` });
+    if (data.power.gpuWatts !== undefined) powerRows.push({ label: 'GPU', value: `${data.power.gpuWatts.toFixed(2)} W` });
+    if (data.power.combinedWatts !== undefined) powerRows.push({ label: 'Combined', value: `${data.power.combinedWatts.toFixed(2)} W` });
+    if (powerRows.length) {
+      sections.push(`<h2>Power</h2>\n<table>\n  ${rows(powerRows).trim()}\n</table>`);
+    }
+  }
+
+  if (data.battery) {
+    const battRows: { label: string; value: string }[] = [
+      { label: 'Level', value: `${data.battery.level}%` },
+      { label: 'State', value: data.battery.state },
+      { label: 'Time Remaining', value: data.battery.timeRemaining },
+      { label: 'Health', value: data.battery.health },
+      { label: 'Power Source', value: data.battery.powerSource },
+    ];
+    if (data.battery.condition) battRows.push({ label: 'Condition', value: data.battery.condition });
+    if (data.battery.maxCapacityPercent !== undefined) battRows.push({ label: 'Max Capacity', value: `${data.battery.maxCapacityPercent}%` });
+    if (data.battery.cycles !== undefined) battRows.push({ label: 'Cycles', value: String(data.battery.cycles) });
+    if (data.battery.estimatedTimeToEmpty) battRows.push({ label: 'Est. Empty', value: data.battery.estimatedTimeToEmpty });
+    if (data.battery.dischargeRatePerHour !== undefined) battRows.push({ label: 'Discharge Rate', value: `${data.battery.dischargeRatePerHour}%/h` });
+    sections.push(`<h2>Battery</h2>\n<table>\n  ${rows(battRows).trim()}\n</table>`);
+  }
+
+  sections.push(`<h2>Thermal</h2>
+<table>
+  ${rows([
+    { label: 'State', value: data.thermal.state },
+    { label: 'Pressure', value: ['Nominal', 'Fair', 'Serious', 'Critical'][data.thermal.pressureLevel] || 'Unknown' },
+    ...(data.thermal.temperatures
+      ? Object.entries(data.thermal.temperatures).flatMap(([k, v]) =>
+          v !== null && v !== undefined ? [{ label: k.replace(/_/g, ' '), value: `${v.toFixed(1)}°C` }] : []
+        )
+      : []),
+  ]).trim()}
+</table>`);
+
+  sections.push(`<h2>Network</h2>
+<table>
+  ${rows([
+    { label: 'Interface', value: `${data.network.interface} (${data.network.ip})` },
+    { label: 'RX', value: `${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt` },
+    { label: 'TX', value: `${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt` },
+  ]).trim()}
+</table>`);
+
+  if (data.packets) {
+    sections.push(`<h2>Packets</h2>
+<table>
+  ${rows([
+    { label: 'Total', value: `${data.packets.totalPackets} pkt` },
+    { label: 'RX', value: `${data.packets.rxPackets} pkt` },
+    { label: 'TX', value: `${data.packets.txPackets} pkt` },
+    { label: 'Connections', value: `${data.packets.connections} TCP` },
+  ]).trim()}
+</table>`);
+  }
+
+  if (data.tasks.length) {
+    const taskRows = data.tasks.slice(0, 20).map(t => ({
+      label: `${t.pid}`,
+      value: `${t.user.padEnd(10)} ${t.cpu.toFixed(1).padStart(6)}% ${t.mem.toFixed(1).padStart(6)}% ${t.state} ${t.command}`,
+    }));
+    sections.push(`<h2>Tasks</h2>\n<table>\n  ${rows(taskRows).trim()}\n</table>`);
+  }
+
+  if (data.disk.length) {
+    const diskRows = data.disk.map(d => ({
+      label: d.mountpoint,
+      value: `${d.used} / ${d.size} (${d.capacity})`,
+    }));
+    sections.push(`<h2>Disk</h2>\n<table>\n  ${rows(diskRows).trim()}\n</table>`);
+  }
+
+  if (data.processes.length) {
+    const procRows = data.processes.slice(0, 50).map(p => ({
+      label: String(p.pid),
+      value: `${p.user.padEnd(10)} ${p.cpu.toFixed(1).padStart(6)}% ${p.mem.toFixed(1).padStart(6)}% ${p.state} ${p.command}`,
+    }));
+    sections.push(`<h2>Processes</h2>\n<table>\n  ${rows(procRows).trim()}\n</table>`);
+  }
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>pyre — ${data.header.hostname}</title>
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #1e1e2e; color: #cdd6f4; margin: 0; padding: 24px; }
+  h1 { color: #ff6a39; margin-bottom: 4px; }
+  .meta { color: #a6adc8; margin-bottom: 24px; }
+  h2 { color: #89b4fa; margin-top: 28px; border-bottom: 1px solid #313244; padding-bottom: 6px; }
+  table { width: 100%; border-collapse: collapse; margin-bottom: 16px; }
+  td { padding: 6px 10px; border-bottom: 1px solid #313244; vertical-align: top; }
+  td.label { color: #a6adc8; width: 22%; font-weight: 500; }
+  td.value { color: #cdd6f4; }
+  tr:last-child td { border-bottom: none; }
+</style>
+</head>
+<body>
+  <h1>PYRE</h1>
+  <div class="meta">${escapeHtml(data.header.hostname)} · ${escapeHtml(data.header.os)} · up ${escapeHtml(data.header.uptime)} · ${escapeHtml(data.timestamp)}</div>
+  ${sections.join('\n  ')}
+</body>
+</html>`;
+}
+
+export function formatMarkdown(data: StatsData): string {
+  const lines: string[] = [];
+  lines.push(`# pyre — ${data.header.hostname}`);
+  lines.push('');
+  lines.push(`**${data.header.os}** · up ${data.header.uptime} · ${data.timestamp}`);
+  lines.push('');
+
+  lines.push('## System');
+  lines.push('');
+  lines.push('| Property | Value |');
+  lines.push('|---|---|');
+  lines.push(`| Hostname | ${mdCell(data.header.hostname)} |`);
+  lines.push(`| OS | ${mdCell(data.header.os)} |`);
+  lines.push(`| Uptime | ${mdCell(data.header.uptime)} |`);
+  lines.push('');
+
+  lines.push('## CPU');
+  lines.push('');
+  lines.push('| Property | Value |');
+  lines.push('|---|---|');
+  lines.push(`| Brand | ${mdCell(data.cpu.brand)} |`);
+  lines.push(`| Cores | ${mdCell(`${data.cpu.physicalCores}/${data.cpu.cores}`)} |`);
+  lines.push(`| Frequency | ${mdCell(`${data.cpu.frequency} MHz`)} |`);
+  lines.push(`| Usage | ${mdCell(`${data.cpu.usage}%`)} |`);
+  lines.push(`| Load Avg | ${mdCell(data.cpu.loadAvg.map(l => l.toFixed(2)).join(' '))} |`);
+  if (data.cpu.temperature) lines.push(`| Temperature | ${mdCell(`${data.cpu.temperature.toFixed(1)}°C`)} |`);
+  lines.push('');
+
+  lines.push('## Memory');
+  lines.push('');
+  lines.push('| Property | Value |');
+  lines.push('|---|---|');
+  lines.push(`| Total | ${mdCell(formatBytes(data.memory.total))} |`);
+  lines.push(`| Used | ${mdCell(formatBytes(data.memory.used))} |`);
+  lines.push(`| Free | ${mdCell(formatBytes(data.memory.free))} |`);
+  lines.push(`| Usage | ${mdCell(`${data.memory.usagePercent}%`)} |`);
+  lines.push(`| Swap | ${mdCell(`${formatBytes(data.memory.swapUsed)} / ${formatBytes(data.memory.swapTotal)}`)} |`);
+  lines.push('');
+
+  if (data.gpu) {
+    lines.push('## GPU');
+    lines.push('');
+    lines.push('| Property | Value |');
+    lines.push('|---|---|');
+    lines.push(`| Model | ${mdCell(data.gpu.model)} |`);
+    lines.push(`| Memory | ${mdCell(formatBytes(data.gpu.memory))} |`);
+    lines.push(`| Utilization | ${mdCell(`${data.gpu.utilization}%`)} |`);
+    if (data.gpu.temperature) lines.push(`| Temperature | ${mdCell(`${data.gpu.temperature.toFixed(1)}°C`)} |`);
+    lines.push(`| Processes | ${mdCell(String(data.gpu.processes))} |`);
+    lines.push('');
+  }
+
+  if (data.power) {
+    const pw: string[] = [];
+    if (data.power.cpuWatts !== undefined) pw.push(`CPU ${data.power.cpuWatts.toFixed(2)} W`);
+    if (data.power.gpuWatts !== undefined) pw.push(`GPU ${data.power.gpuWatts.toFixed(2)} W`);
+    if (data.power.combinedWatts !== undefined) pw.push(`Combined ${data.power.combinedWatts.toFixed(2)} W`);
+    if (pw.length) {
+      lines.push('## Power');
+      lines.push('');
+      lines.push('| Metric | Value |');
+      lines.push('|---|---|');
+      if (data.power.cpuWatts !== undefined) lines.push(`| CPU | ${mdCell(`${data.power.cpuWatts.toFixed(2)} W`)} |`);
+      if (data.power.gpuWatts !== undefined) lines.push(`| GPU | ${mdCell(`${data.power.gpuWatts.toFixed(2)} W`)} |`);
+      if (data.power.combinedWatts !== undefined) lines.push(`| Combined | ${mdCell(`${data.power.combinedWatts.toFixed(2)} W`)} |`);
+      lines.push('');
+    }
+  }
+
+  if (data.battery) {
+    lines.push('## Battery');
+    lines.push('');
+    lines.push('| Property | Value |');
+    lines.push('|---|---|');
+    lines.push(`| Level | ${mdCell(`${data.battery.level}%`)} |`);
+    lines.push(`| State | ${mdCell(data.battery.state)} |`);
+    lines.push(`| Time Remaining | ${mdCell(data.battery.timeRemaining)} |`);
+    lines.push(`| Health | ${mdCell(data.battery.health)} |`);
+    lines.push(`| Power Source | ${mdCell(data.battery.powerSource)} |`);
+    if (data.battery.condition) lines.push(`| Condition | ${mdCell(data.battery.condition)} |`);
+    if (data.battery.maxCapacityPercent !== undefined) lines.push(`| Max Capacity | ${mdCell(`${data.battery.maxCapacityPercent}%`)} |`);
+    if (data.battery.cycles !== undefined) lines.push(`| Cycles | ${mdCell(String(data.battery.cycles))} |`);
+    if (data.battery.estimatedTimeToEmpty) lines.push(`| Est. Empty | ${mdCell(data.battery.estimatedTimeToEmpty)} |`);
+    if (data.battery.dischargeRatePerHour !== undefined) lines.push(`| Discharge Rate | ${mdCell(`${data.battery.dischargeRatePerHour}%/h`)} |`);
+    lines.push('');
+  }
+
+  lines.push('## Thermal');
+  lines.push('');
+  lines.push('| Property | Value |');
+  lines.push('|---|---|');
+  lines.push(`| State | ${mdCell(data.thermal.state)} |`);
+  lines.push(`| Pressure | ${mdCell(['Nominal', 'Fair', 'Serious', 'Critical'][data.thermal.pressureLevel] || 'Unknown')} |`);
+  if (data.thermal.temperatures) {
+    for (const [k, v] of Object.entries(data.thermal.temperatures)) {
+      if (v !== null && v !== undefined) lines.push(`| ${mdCell(k.replace(/_/g, ' '))} | ${mdCell(`${v.toFixed(1)}°C`)} |`);
+    }
+  }
+  lines.push('');
+
+  lines.push('## Network');
+  lines.push('');
+  lines.push('| Property | Value |');
+  lines.push('|---|---|');
+  lines.push(`| Interface | ${mdCell(`${data.network.interface} (${data.network.ip})`)} |`);
+  lines.push(`| RX | ${mdCell(`${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt`)} |`);
+  lines.push(`| TX | ${mdCell(`${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt`)} |`);
+  lines.push('');
+
+  if (data.packets) {
+    lines.push('## Packets');
+    lines.push('');
+    lines.push('| Property | Value |');
+    lines.push('|---|---|');
+    lines.push(`| Total | ${mdCell(`${data.packets.totalPackets} pkt`)} |`);
+    lines.push(`| RX | ${mdCell(`${data.packets.rxPackets} pkt`)} |`);
+    lines.push(`| TX | ${mdCell(`${data.packets.txPackets} pkt`)} |`);
+    lines.push(`| Connections | ${mdCell(`${data.packets.connections} TCP`)} |`);
+    lines.push('');
+  }
+
+  if (data.tasks.length) {
+    lines.push('## Tasks');
+    lines.push('');
+    lines.push('| PID | User | CPU% | MEM% | State | Command |');
+    lines.push('|---|---|---|---|---|---|');
+    for (const t of data.tasks.slice(0, 20)) {
+      lines.push(`| ${t.pid} | ${mdCell(t.user)} | ${t.cpu.toFixed(1)} | ${t.mem.toFixed(1)} | ${t.state} | ${mdCell(t.command)} |`);
+    }
+    lines.push('');
+  }
+
+  if (data.disk.length) {
+    lines.push('## Disk');
+    lines.push('');
+    lines.push('| Mountpoint | Used / Size | Capacity |');
+    lines.push('|---|---|---|');
+    for (const d of data.disk) {
+      lines.push(`| ${mdCell(d.mountpoint)} | ${mdCell(`${d.used} / ${d.size}`)} | ${mdCell(d.capacity)} |`);
+    }
+    lines.push('');
+  }
+
+  if (data.processes.length) {
+    lines.push('## Processes');
+    lines.push('');
+    lines.push('| PID | User | CPU% | MEM% | State | Command |');
+    lines.push('|---|---|---|---|---|---|');
+    for (const p of data.processes.slice(0, 50)) {
+      lines.push(`| ${p.pid} | ${mdCell(p.user)} | ${p.cpu.toFixed(1)} | ${p.mem.toFixed(1)} | ${p.state} | ${mdCell(p.command)} |`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+function escapeHtml(s: string): string {
+  return s
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function mdCell(s: string): string {
+  return String(s).replace(/\|/g, '\\|');
+}
+
 export function formatCsv(data: StatsData): string {
   const rows: string[][] = [
     ['property', 'key', 'value'],
@@ -25,6 +356,9 @@ export function formatCsv(data: StatsData): string {
     ['cpu', 'loadAvg_1m', String(data.cpu.loadAvg[0])],
     ['cpu', 'loadAvg_5m', String(data.cpu.loadAvg[1])],
     ['cpu', 'loadAvg_15m', String(data.cpu.loadAvg[2])],
+    ['cpu', 'cores', String(data.cpu.cores)],
+    ['cpu', 'physicalCores', String(data.cpu.physicalCores)],
+    ['cpu', 'frequency', String(data.cpu.frequency)],
     ['memory', 'total', String(data.memory.total)],
     ['memory', 'used', String(data.memory.used)],
     ['memory', 'usagePercent', String(data.memory.usagePercent)],
@@ -32,11 +366,7 @@ export function formatCsv(data: StatsData): string {
     ['memory', 'swapTotal', String(data.memory.swapTotal)],
     ['thermal', 'state', data.thermal.state],
     ['thermal', 'cpuTempC', data.thermal.temperatures?.cpu_die ? String(data.thermal.temperatures.cpu_die) : ''],
-    [
-      'thermal',
-      'cpuTempF',
-      data.thermal.temperatures?.cpu_die != null ? String(celsiusToFahrenheit(data.thermal.temperatures.cpu_die)) : '',
-    ],
+    ['thermal', 'cpuTempF', data.thermal.temperatures?.cpu_die != null ? String(celsiusToFahrenheit(data.thermal.temperatures.cpu_die)) : ''],
     ['network', 'rxBytes', String(data.network.rxBytes)],
     ['network', 'txBytes', String(data.network.txBytes)],
     ['network', 'rxPackets', String(data.network.rxPackets)],
@@ -54,9 +384,12 @@ export function formatCsv(data: StatsData): string {
     ['power', 'gpuWatts', data.power?.gpuWatts !== undefined ? String(data.power.gpuWatts) : ''],
     ['power', 'combinedWatts', data.power?.combinedWatts !== undefined ? String(data.power.combinedWatts) : ''],
     ['system', 'hostname', data.header.hostname],
-     ['system', 'uptime', data.header.uptime],
-     ['system', 'timestamp', data.timestamp],
-   ];
+    ['system', 'uptime', data.header.uptime],
+    ['system', 'timestamp', data.timestamp],
+  ];
+  if (data.cpu.coreUsage && data.cpu.coreUsage.length) {
+    data.cpu.coreUsage.forEach((u, i) => rows.push(['cpu', `coreUsage_${i}`, String(u)]));
+  }
 
   if (data.packets) {
     rows.push(['packets', 'totalPackets', String(data.packets.totalPackets)]);

package/src/formatters/render.ts

@@ -12,7 +12,7 @@
 import chalk from 'chalk';
 import { sparkline } from '../sparkline.js';
 import type { History } from '../history.js';
-import type { StatsData, VisibleItems, TableOptions } from './types.js';
+import type { StatsData, VisibleItems, TableOptions, AnomalyAlert } from './types.js';
 import { THEMES, type ThemeName } from './themes.js';
 
 // --- low-level box drawing ---------------------------------------------------
@@ -132,6 +132,14 @@ export function formatTemp(c: number): string {
   return `${c.toFixed(1)}°C / ${celsiusToFahrenheit(c).toFixed(1)}°F`;
 }
 
+/** Render a Celsius reading in the requested unit. */
+export function formatTempUnit(c: number, unit: 'c' | 'f' = 'c'): string {
+  if (unit === 'f') {
+    return `${(c * (9 / 5) + 32).toFixed(1)}°F`;
+  }
+  return `${c.toFixed(1)}°C`;
+}
+
 // --- cards -------------------------------------------------------------------
 
 function cpuCard(data: StatsData, contentWidth: number): string[] {
@@ -142,6 +150,18 @@ function cpuCard(data: StatsData, contentWidth: number): string[] {
     gaugeRow('Usage', data.cpu.usage, contentWidth),
     statRow('Load', data.cpu.loadAvg.map(l => l.toFixed(2)).join(' ')),
   ];
+  if (data.cpu.coreUsage && data.cpu.coreUsage.length) {
+    const slotW = 2;
+    const maxCores = Math.max(1, Math.floor((contentWidth - 10) / (slotW + 1)));
+    const cores = data.cpu.coreUsage.slice(0, maxCores);
+    const bars = cores.map(u => {
+      const fill = Math.round((Math.min(100, u) / 100) * slotW);
+      const str = '█'.repeat(Math.max(0, fill)) + '░'.repeat(slotW - fill);
+      const color = u > 90 ? chalk.red : u > 70 ? chalk.yellow : chalk.green;
+      return color(str);
+    });
+    lines.push(statRow('Cores', bars.join(' ')));
+  }
   if (data.cpu.temperature) lines.push(statRow('Temp', formatTemp(data.cpu.temperature)));
   return lines;
 }
@@ -571,23 +591,40 @@ function activeDetailLines(data: StatsData, activePanel: string, width: number,
   }
 }
 
-export function formatTable(data: StatsData, opts: TableOptions = {}): string {
-  const width = clampWidth(opts.width);
-  const activePanel = opts.activePanel || 'grid';
-  const columns = gridColumns(width);
-  const gap = 2;
-  const cardWidth = Math.floor((width - gap * (columns - 1)) / columns);
-  const contentWidth = cardWidth - 4;
+function anomalyPanel(anomalies: AnomalyAlert[], width: number, theme: ThemeColors): string[] {
+  const lines: string[] = [];
+  for (const a of anomalies) {
+    const color = a.severity === 'critical' ? chalk.red.bold : chalk.yellow;
+    const direction = a.zScore > 0 ? '↑ spike' : '↓ drop';
+    lines.push(color(` ⚠ ${a.metric}: ${a.value.toFixed(1)} (${direction}, σ=${a.zScore.toFixed(1)})`));
+  }
+  return lines;
+}
 
-  const themeName = opts.theme || 'default';
-  const theme = THEMES[themeName] || THEMES.default;
-  const vis = opts.visible ?? {};
+export function formatTable(data: StatsData, opts: TableOptions = {}): string {
+   const width = clampWidth(opts.width);
+   const activePanel = opts.activePanel || 'grid';
+   const columns = gridColumns(width);
+   const gap = 2;
+   const cardWidth = Math.floor((width - gap * (columns - 1)) / columns);
+   const contentWidth = cardWidth - 4;
+
+   const themeName = opts.theme || 'default';
+   const theme = THEMES[themeName] || THEMES.default;
+   const vis = opts.visible ?? {};
+
+   const out: string[] = [];
+   out.push(...header(data, width, [], theme.border));
+   out.push('');
+
+   const anomalies = opts.anomalies ?? [];
+   if (anomalies.length && activePanel === 'grid') {
+     out.push(...anomalyPanel(anomalies, width, theme));
+     out.push('');
+   }
 
-  const out: string[] = [];
-  out.push(...header(data, width, [], theme.border));
-  out.push('');
-  out.push(tabBar(activePanel, width, theme));
-  out.push('');
+   out.push(tabBar(activePanel, width, theme));
+   out.push('');
 
   if (activePanel !== 'grid') {
     const lines = activeDetailLines(data, activePanel, width, opts);

package/src/formatters/types.ts

@@ -42,21 +42,32 @@ export interface VisibleItems {
    tree?: boolean;
 }
 
+export interface AnomalyAlert {
+  metric: string;
+  value: number;
+  zScore: number;
+  severity: 'warning' | 'critical';
+}
+
 export interface TableOptions {
-   /** Terminal width in columns; controls layout, bar sizing, and column count. Defaults to 80. */
-   width?: number;
-   /** Process sort key. Defaults to 'cpu'. */
-   sortBy?: 'cpu' | 'mem' | 'pid' | 'user' | 'command' | 'state' | 'threads' | 'runtime';
-   /** Case-insensitive substring filter applied to the process command. */
-   filter?: string;
-   /** Max process rows to show (the live dashboard sizes this to available terminal height). */
-   processLimit?: number;
-   /** Selected visual theme. */
-   theme?: ThemeName;
-   /** Visibility toggle settings for individual cards. */
-   visible?: VisibleItems;
-   /** Show process tree view instead of flat list. */
-   treeView?: boolean;
-   /** Active panel for detail/focus view. 'grid' means show all panels. */
-   activePanel?: 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process';
+    /** Terminal width in columns; controls layout, bar sizing, and column count. Defaults to 80. */
+    width?: number;
+    /** Process sort key. Defaults to 'cpu'. */
+    sortBy?: 'cpu' | 'mem' | 'pid' | 'user' | 'command' | 'state' | 'threads' | 'runtime';
+    /** Case-insensitive substring filter applied to the process command. */
+    filter?: string;
+    /** Max process rows to show (the live dashboard sizes this to available terminal height). */
+    processLimit?: number;
+    /** Selected visual theme. */
+    theme?: ThemeName;
+    /** Visibility toggle settings for individual cards. */
+    visible?: VisibleItems;
+    /** Show process tree view instead of flat list. */
+    treeView?: boolean;
+    /** Active panel for detail/focus view. 'grid' means show all panels. */
+    activePanel?: 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p';
+    /** Active anomaly alerts from the statistical detector. */
+    anomalies?: AnomalyAlert[];
+    /** Temperature display unit: 'c' or 'f'. */
+    tempUnit?: 'c' | 'f';
 }