pyre-cli 1.3.0 → 2.0.0

package/dist/index.js

@@ -2,11 +2,14 @@
 
 // src/index.ts
 import fs2 from "fs";
+import readline2 from "readline";
 import { Command } from "commander";
-import chalk4 from "chalk";
+import chalk8 from "chalk";
 
-// src/monitors.ts
+// src/monitors/collectors.ts
 import chalk from "chalk";
+
+// src/monitors/run.ts
 async function run(cmd, fallback = "") {
   try {
     const { execSync } = await import("child_process");
@@ -15,6 +18,8 @@ async function run(cmd, fallback = "") {
     return fallback;
   }
 }
+
+// src/monitors/smc.ts
 var smcCache = null;
 async function getSmcMetrics() {
   const now = Date.now();
@@ -53,17 +58,53 @@ async function getSmcMetrics() {
 function parseSuffix(s) {
   return s.toUpperCase() === "K" ? 1024 : s.toUpperCase() === "M" ? 1024 * 1024 : s.toUpperCase() === "G" ? 1024 * 1024 * 1024 : 1;
 }
+
+// src/monitors/collectors.ts
+var BATTERY_WINDOW_MS = 15 * 60 * 1e3;
+var MIN_ESTIMATE_WINDOW_MS = 30 * 1e3;
+var prevBattery = { samples: [] };
+function estimateBatteryLife(level, state2) {
+  const now = Date.now();
+  if (state2 === "charged" || state2 === "charging") {
+    prevBattery.samples = [];
+    return {};
+  }
+  prevBattery.samples.push({ level, ts: now });
+  prevBattery.samples = prevBattery.samples.filter((s) => now - s.ts <= BATTERY_WINDOW_MS);
+  const first = prevBattery.samples[0];
+  const elapsedMs = now - first.ts;
+  if (elapsedMs < MIN_ESTIMATE_WINDOW_MS) {
+    return {};
+  }
+  const dtHours = Math.max(elapsedMs / 1e3 / 3600, 1e-4);
+  const discharged = first.level - level;
+  if (discharged <= 0) {
+    return { estimatedTimeToEmpty: "calculating" };
+  }
+  const dischargeRate = discharged / dtHours;
+  const remainingLevel = Math.max(level, 0);
+  const hoursToEmpty = remainingLevel / dischargeRate;
+  const h = Math.floor(hoursToEmpty);
+  const m = Math.round((hoursToEmpty - h) * 60);
+  const estimatedTimeToEmpty = hoursToEmpty > 0 ? `${h}h ${m}m` : "calculating";
+  const ASSUMED_CAPACITY_WH = 55;
+  const powerWatts = Math.round(dischargeRate * (ASSUMED_CAPACITY_WH / 100) * 100) / 100;
+  return { estimatedTimeToEmpty, dischargeRatePerHour: Math.round(dischargeRate * 10) / 10, powerWatts };
+}
 async function collectAll(opts2 = {}) {
-  const [cpu, memory, disk, battery, thermal, network, processes, system, power] = await Promise.all([
+  const [cpu, gpu, memory, disk, battery, thermal, network, processes, system, power, packets, tasks] = await Promise.all([
     collectCpu(),
+    collectGpu(opts2.detailed),
     collectMemory(),
     collectDisk(),
     collectBattery(),
     collectThermal(opts2.detailed),
     collectNetwork(),
-    collectProcesses(opts2.processLimit ?? 10),
+    collectProcesses(opts2.processLimit),
     collectSystem(),
-    collectPower()
+    collectPower(),
+    collectPackets(),
+    collectTasks()
   ]);
   return {
     header: {
@@ -73,6 +114,7 @@ async function collectAll(opts2 = {}) {
       uptime: system.uptime
     },
     cpu,
+    gpu,
     memory,
     disk,
     battery,
@@ -80,14 +122,79 @@ async function collectAll(opts2 = {}) {
     network,
     processes,
     power,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    packets,
+    tasks
   };
 }
 async function collectPower() {
   try {
     const { power } = await getSmcMetrics();
-    if (power.cpu === void 0 && power.gpu === void 0 && power.combined === void 0) return null;
-    return { cpuWatts: power.cpu, gpuWatts: power.gpu, combinedWatts: power.combined };
+    if (power.cpu !== void 0 || power.gpu !== void 0 || power.combined !== void 0) {
+      return { cpuWatts: power.cpu, gpuWatts: power.gpu, combinedWatts: power.combined };
+    }
+  } catch {
+  }
+  try {
+    const ioreg = (await run("ioreg -rn AppleSmartBattery 2>/dev/null")).trim();
+    const ampMatch = ioreg.match(/"InstantAmperage"\s*=\s*(-?\d+)/);
+    const voltMatch = ioreg.match(/"Voltage"\s*=\s*(\d+)/);
+    if (ampMatch && voltMatch) {
+      let ampsBig = BigInt(ampMatch[1]);
+      if (!ampMatch[1].startsWith("-")) {
+        const UINT64_MAX_PLUS_1 = 1n << 64n;
+        const INT64_MAX = (1n << 63n) - 1n;
+        if (ampsBig > INT64_MAX) ampsBig -= UINT64_MAX_PLUS_1;
+      }
+      const amps = Number(ampsBig);
+      const volts = parseInt(voltMatch[1], 10) / 1e3;
+      const watts = Math.abs(amps / 1e3 * volts);
+      if (Number.isFinite(watts) && watts < 500) {
+        return { combinedWatts: Math.round(watts * 100) / 100 };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function collectGpu(detailed) {
+  try {
+    const spRaw = (await run("system_profiler SPDisplaysDataType 2>/dev/null")).trim();
+    if (!spRaw) return null;
+    const modelMatch = spRaw.match(/Chipset Model:\s*(.+)/i);
+    const model = modelMatch ? modelMatch[1].trim() : "Unknown";
+    const memMatch = spRaw.match(/VRAM \(Total\):\s*(.+)/i);
+    let memory = 0;
+    if (memMatch) {
+      const memStr = memMatch[1].trim();
+      const memNum = parseFloat(memStr);
+      if (memStr.includes("GB")) memory = memNum * 1024 * 1024 * 1024;
+      else if (memStr.includes("MB")) memory = memNum * 1024 * 1024;
+    }
+    let utilization = 0;
+    let temperature;
+    let gpuProcesses = 0;
+    if (detailed) {
+      try {
+        const pm = (await run("sudo -n powermetrics --samplers gpu_power -n 1 --format text 2>/dev/null", "")).trim();
+        const gpuPowerMatch = pm.match(/GPU Power:\s*([\d.]+)\s*mW/i);
+        if (gpuPowerMatch) {
+          utilization = Math.min(100, Math.round(parseFloat(gpuPowerMatch[1]) / 10));
+        }
+      } catch {
+      }
+      try {
+        const { temps } = await getSmcMetrics();
+        if (temps.gpu_die !== void 0) temperature = temps.gpu_die;
+      } catch {
+      }
+      try {
+        const psRaw = (await run('ps aux | grep -i "[g]pu" | wc -l')).trim();
+        gpuProcesses = parseInt(psRaw) || 0;
+      } catch {
+      }
+    }
+    return { model, memory, utilization, temperature, processes: gpuProcesses };
   } catch {
     return null;
   }
@@ -113,7 +220,9 @@ async function collectCpu() {
     try {
       const { freq } = await getSmcMetrics();
       const values = Object.values(freq);
-      if (values.length) frequency = Math.round(Math.max(...values));
+      if (values.length) {
+        frequency = Math.round(Math.max(...values) / 1e6);
+      }
     } catch {
     }
   }
@@ -200,10 +309,10 @@ async function collectBattery() {
     if (!raw.includes("Battery Power") && !raw.includes("AC Power")) return null;
     const levelMatch = raw.match(/(\d+)%/);
     const stateMatch = raw.match(/;\s*(charging|discharging|charged|finishing charge|attached to charger)/i);
-    const timeMatch = raw.match(/:\s*([\d:]+)\s+remaining/i);
+    const timeMatch = raw.match(/:\s*([\d:]+)\s+remaining/i) || raw.match(/(\d+:\d+)\s+remaining/i);
     const powerPlugged = raw.includes("AC Power") || raw.includes("attached to charger");
     const level = levelMatch ? parseInt(levelMatch[1]) : 0;
-    const state = powerPlugged ? "charged" : stateMatch ? stateMatch[1].toLowerCase() : "discharging";
+    const state2 = powerPlugged ? "charged" : stateMatch ? stateMatch[1].toLowerCase() : "discharging";
     const timeRemaining = timeMatch ? timeMatch[1] : powerPlugged ? "\u221E" : "calculating";
     let cycles;
     let condition;
@@ -233,50 +342,52 @@ async function collectBattery() {
     if (maxCapacityPercent !== void 0) healthParts.push(`${maxCapacityPercent}% capacity`);
     if (cycles !== void 0) healthParts.push(`${cycles} cycles`);
     const health = healthParts.length ? healthParts.join(", ") : "unknown";
+    const estimate = estimateBatteryLife(level, state2);
     return {
       level,
-      state,
+      state: state2,
       timeRemaining,
       health,
       powerSource: powerPlugged ? "AC" : "Battery",
       cycles,
       condition,
-      maxCapacityPercent
+      maxCapacityPercent,
+      ...estimate
     };
   } catch {
     return null;
   }
 }
-function pressureFromState(state) {
-  const s = state.toLowerCase();
+function pressureFromState(state2) {
+  const s = state2.toLowerCase();
   if (s.includes("critical")) return 3;
   if (s.includes("serious") || s.includes("heavy")) return 2;
   if (s.includes("fair") || s.includes("moderate")) return 1;
   return 0;
 }
-async function collectThermal(detailed2) {
+async function collectThermal(detailed) {
   try {
     const therm = (await run("pmset -g therm", "")).trim();
-    let state = "Unknown";
+    let state2 = "Unknown";
     let detail = therm || "No pmset thermal data";
     const stateMatch = therm.match(/Thermal state:\s*(.+)/i);
     if (stateMatch) {
       const raw = stateMatch[1].trim();
-      state = /0|no warning|normal/i.test(raw) ? "Nominal" : raw;
-      detail = state;
+      state2 = /0|no warning|normal/i.test(raw) ? "Nominal" : raw;
+      detail = state2;
     } else {
       const limitMatch = therm.match(
         /CPU_(?:Speed|Scheduler)_Limit\s*(?:=|:)\s*([\d.]+)/i
       );
       if (limitMatch) {
         const limit = parseFloat(limitMatch[1]);
-        if (limit >= 100) state = "Nominal";
-        else if (limit >= 85) state = "Fair";
-        else if (limit >= 50) state = "Serious";
-        else state = "Critical";
-        detail = `${state} (CPU limit ${limit}%)`;
+        if (limit >= 100) state2 = "Nominal";
+        else if (limit >= 85) state2 = "Fair";
+        else if (limit >= 50) state2 = "Serious";
+        else state2 = "Critical";
+        detail = `${state2} (CPU limit ${limit}%)`;
       } else if (/no thermal warning level has been recorded/i.test(therm)) {
-        state = "Nominal";
+        state2 = "Nominal";
         detail = "Nominal (no thermal warning recorded)";
       }
     }
@@ -285,7 +396,7 @@ async function collectThermal(detailed2) {
     try {
       const { temps } = await getSmcMetrics();
       cpuDieTemp = temps.cpu_die;
-      if (detailed2) {
+      if (detailed) {
         if (temps.cpu_die !== void 0) temperatures["cpu_die"] = temps.cpu_die;
         if (temps.gpu_die !== void 0) temperatures["gpu_die"] = temps.gpu_die;
         if (temps.smc_die !== void 0) temperatures["smc_die"] = temps.smc_die;
@@ -294,19 +405,19 @@ async function collectThermal(detailed2) {
         }
       }
     } catch {
-      if (detailed2) detail += " (powermetrics unavailable)";
+      if (detailed) detail += " (powermetrics unavailable)";
     }
-    if (state === "Unknown" && cpuDieTemp !== void 0) {
-      if (cpuDieTemp >= 100) state = "Critical";
-      else if (cpuDieTemp >= 90) state = "Serious";
-      else if (cpuDieTemp >= 80) state = "Fair";
-      else state = "Nominal";
-      detail = `${state} (estimated from ${cpuDieTemp}\xB0C)`;
+    if (state2 === "Unknown" && cpuDieTemp !== void 0) {
+      if (cpuDieTemp >= 100) state2 = "Critical";
+      else if (cpuDieTemp >= 90) state2 = "Serious";
+      else if (cpuDieTemp >= 80) state2 = "Fair";
+      else state2 = "Nominal";
+      detail = `${state2} (estimated from ${cpuDieTemp}\xB0C)`;
     }
     return {
-      state,
+      state: state2,
       detail,
-      pressureLevel: pressureFromState(state),
+      pressureLevel: pressureFromState(state2),
       temperatures: Object.keys(temperatures).length ? temperatures : void 0
     };
   } catch {
@@ -346,43 +457,125 @@ async function collectNetwork() {
     return { interface: "unknown", ip: "0.0.0.0", rxBytes: 0, txBytes: 0, rxPackets: 0, txPackets: 0 };
   }
 }
-async function collectProcesses(limit = 10) {
+async function collectProcesses(limit) {
   try {
-    const raw = (await run(`ps -Ao pid,user,pcpu,pmem,comm -r | head -n ${limit + 1}`)).trim();
+    const isMac = process.platform === "darwin";
+    const sortArg = isMac ? "-r" : "--sort=-pcpu";
+    const threadsArg = isMac ? "threads" : "nlwp";
+    const headClause = limit && limit > 0 ? ` | head -n ${limit + 1}` : "";
+    const raw = (await run(`ps -eo pid,ppid,user,pcpu,pmem,state,${threadsArg},time,comm ${sortArg}${headClause}`)).trim();
     const lines = raw.split("\n").slice(1);
     return lines.map((line) => {
-      const parts = line.match(/\s*(\d+)\s+(\S+)\s+([\d.]+)\s+([\d.]+)\s+(.+)/);
+      const parts = line.match(/\s*(\d+)\s+(\d+)\s+(\S+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+(\d+)\s+([\d:]+)\s+(.+)/);
       if (!parts) return null;
-      return { pid: parseInt(parts[1]), user: parts[2], cpu: parseFloat(parts[3]), mem: parseFloat(parts[4]), command: parts[5] };
+      const runtimeSec = parts[8].split(":").reduce((acc, val, idx) => acc + parseInt(val) * Math.pow(60, 2 - idx), 0);
+      return { pid: parseInt(parts[1]), ppid: parseInt(parts[2]), user: parts[3], cpu: parseFloat(parts[4]), mem: parseFloat(parts[5]), state: parts[6], threads: parseInt(parts[7]), runtime: runtimeSec, command: parts[9] };
     }).filter((p) => p !== null && p.pid > 0);
   } catch {
     return [];
   }
 }
-
-// src/formatters.ts
-import chalk2 from "chalk";
-
-// src/sparkline.ts
-var BLOCKS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
-function sparkline(values, opts2 = {}) {
-  if (!values.length) return "";
-  const min = opts2.min ?? Math.min(...values);
-  const max = opts2.max ?? Math.max(...values);
-  const range = max - min || 1;
-  return values.map((v) => {
-    const idx = Math.round((v - min) / range * (BLOCKS.length - 1));
-    const clamped = Math.min(BLOCKS.length - 1, Math.max(0, idx));
-    return BLOCKS[clamped];
-  }).join("");
+async function collectPackets() {
+  try {
+    const netStat = (await run("netstat -ib")).trim();
+    const lines = netStat.split("\n").slice(1);
+    let totalRxPackets = 0;
+    let totalTxPackets = 0;
+    let totalRxBytes = 0;
+    let totalTxBytes = 0;
+    const ifaceStats = [];
+    for (const line of lines) {
+      const parts = line.split(/\s+/);
+      if (parts.length >= 11 && parts[0] && !parts[0].startsWith("Name")) {
+        const iface = parts[0];
+        const rxPackets = parseInt(parts[4]) || 0;
+        const rxBytes = parseInt(parts[5]) || 0;
+        const txPackets = parseInt(parts[6]) || 0;
+        const txBytes = parseInt(parts[7]) || 0;
+        totalRxPackets += rxPackets;
+        totalTxPackets += txPackets;
+        totalRxBytes += rxBytes;
+        totalTxBytes += txBytes;
+        if (iface && !iface.includes("lo")) {
+          ifaceStats.push({ iface, rxPackets, txPackets, rxBytes, txBytes });
+        }
+      }
+    }
+    let connections = 0;
+    try {
+      const tcpConns = (await run("netstat -an | grep ESTABLISHED | wc -l", "0")).trim();
+      connections = parseInt(tcpConns) || 0;
+    } catch {
+      connections = 0;
+    }
+    let topProcesses = [];
+    let allProcesses = [];
+    try {
+      const lsof = (await run("lsof -i -n -P -r 1 2>/dev/null | tail -n +2 | awk '{print $1, $2}' | sort | uniq -c | sort -rn", "")).trim();
+      const lsofLines = lsof.split("\n");
+      topProcesses = lsofLines.map((line) => {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 3) {
+          return { pid: parseInt(parts[2]) || 0, command: parts[1], rxBytes: 0, txBytes: parseInt(parts[0]) || 0 };
+        }
+        return { pid: 0, command: "", rxBytes: 0, txBytes: 0 };
+      }).filter((p) => p.pid > 0);
+      const allLsof = (await run("lsof -i -n -P 2>/dev/null | tail -n +2 | awk '{print $1, $2}' | sort | uniq -c | sort -rn", "")).trim();
+      const allLsofLines = allLsof.split("\n");
+      allProcesses = allLsofLines.map((line) => {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 3) {
+          return { pid: parseInt(parts[2]) || 0, command: parts[1], rxBytes: 0, txBytes: parseInt(parts[0]) || 0 };
+        }
+        return { pid: 0, command: "", rxBytes: 0, txBytes: 0 };
+      }).filter((p) => p.pid > 0);
+    } catch {
+      topProcesses = [];
+      allProcesses = [];
+    }
+    return {
+      totalPackets: totalRxPackets + totalTxPackets,
+      rxPackets: totalRxPackets,
+      txPackets: totalTxPackets,
+      rxRate: 0,
+      txRate: 0,
+      connections,
+      topProcesses,
+      interfaces: ifaceStats,
+      allProcesses
+    };
+  } catch {
+    return null;
+  }
+}
+async function collectTasks(limit = 12) {
+  try {
+    const isMac = process.platform === "darwin";
+    const sortArg = isMac ? "-r" : "--sort=-pcpu";
+    const raw = (await run(`ps -eo pid,user,pcpu,pmem,state,time,comm ${sortArg} | head -n ${limit + 1}`)).trim();
+    const lines = raw.split("\n").slice(1);
+    return lines.map((line) => {
+      const parts = line.match(/\s*(\d+)\s+(\S+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+([\d:]+)\s+(.+)/);
+      if (!parts) return null;
+      const runtimeSec = parts[6].split(":").reduce((acc, val, idx) => acc + parseInt(val) * Math.pow(60, 2 - idx), 0);
+      return { pid: parseInt(parts[1]), user: parts[2], cpu: parseFloat(parts[3]), mem: parseFloat(parts[4]), state: parts[5], runtime: runtimeSec, command: parts[7] };
+    }).filter((t) => t !== null && t.pid > 0);
+  } catch {
+    return [];
+  }
 }
 
-// src/formatters.ts
+// src/formatters/render.ts
+import chalk3 from "chalk";
+
+// src/formatters/themes.ts
+import chalk2 from "chalk";
 var THEMES = {
   default: {
     border: chalk2.hex("#4b5563"),
     cpu: chalk2.hex("#22d3ee"),
     mem: chalk2.hex("#a78bfa"),
+    gpu: chalk2.hex("#f472b6"),
     power: chalk2.hex("#fbbf24"),
     battery: chalk2.hex("#34d399"),
     thermal: chalk2.hex("#fb923c"),
@@ -395,6 +588,7 @@ var THEMES = {
     border: chalk2.hex("#6272a4"),
     cpu: chalk2.hex("#8be9fd"),
     mem: chalk2.hex("#bd93f9"),
+    gpu: chalk2.hex("#ff5555"),
     power: chalk2.hex("#f1fa8c"),
     battery: chalk2.hex("#50fa7b"),
     thermal: chalk2.hex("#ffb86c"),
@@ -407,6 +601,7 @@ var THEMES = {
     border: chalk2.hex("#ff0055"),
     cpu: chalk2.hex("#00ffcc"),
     mem: chalk2.hex("#ff00ff"),
+    gpu: chalk2.hex("#ffff00"),
     power: chalk2.hex("#ffff00"),
     battery: chalk2.hex("#00ff00"),
     thermal: chalk2.hex("#ff6600"),
@@ -419,6 +614,7 @@ var THEMES = {
     border: chalk2.gray,
     cpu: chalk2.white.bold,
     mem: chalk2.white.bold,
+    gpu: chalk2.white.bold,
     power: chalk2.white.bold,
     battery: chalk2.white.bold,
     thermal: chalk2.white.bold,
@@ -426,17 +622,36 @@ var THEMES = {
     disk: chalk2.white.bold,
     graphs: chalk2.white.bold,
     process: chalk2.white.bold
+  },
+  nord: {
+    border: chalk2.hex("#4c566a"),
+    cpu: chalk2.hex("#88c0d0"),
+    mem: chalk2.hex("#b48ead"),
+    gpu: chalk2.hex("#bf616a"),
+    power: chalk2.hex("#ebcb8b"),
+    battery: chalk2.hex("#a3be8c"),
+    thermal: chalk2.hex("#d08770"),
+    network: chalk2.hex("#81a1c1"),
+    disk: chalk2.hex("#b48ead"),
+    graphs: chalk2.hex("#88c0d0"),
+    process: chalk2.hex("#eceff4")
+  },
+  gruvbox: {
+    border: chalk2.hex("#928374"),
+    cpu: chalk2.hex("#fb4934"),
+    mem: chalk2.hex("#b8bb26"),
+    gpu: chalk2.hex("#d3869b"),
+    power: chalk2.hex("#fabd2f"),
+    battery: chalk2.hex("#b8bb26"),
+    thermal: chalk2.hex("#fb4934"),
+    network: chalk2.hex("#83a598"),
+    disk: chalk2.hex("#d3869b"),
+    graphs: chalk2.hex("#fb4934"),
+    process: chalk2.hex("#ebdbb2")
   }
 };
-function clampWidth(width) {
-  if (!width || Number.isNaN(width)) return 80;
-  return Math.max(60, Math.min(width, 240));
-}
-function gridColumns(width) {
-  if (width >= 150) return 3;
-  if (width >= 96) return 2;
-  return 1;
-}
+
+// src/formatters/render.ts
 function visLen(s) {
   return s.replace(/\x1b\[[0-9;]*m/g, "").length;
 }
@@ -453,9 +668,8 @@ function panel(title, lines, width, accent, borderAccent, height) {
   const h = height ?? lines.length;
   const contentWidth = Math.max(1, width - 4);
   const label = ` ${title} `;
-  const dashLen = Math.max(0, width - 3 - label.length);
-  const top = borderAccent("\u256D\u2500" + label + "\u2500".repeat(dashLen) + "\u256E");
-  const bottom = borderAccent("\u2570" + "\u2500".repeat(width - 2) + "\u256F");
+  const top = borderAccent("\u250C" + label + "\u2500".repeat(width - label.length - 2) + "\u2510");
+  const bottom = borderAccent("\u2514" + "\u2500".repeat(width - 2) + "\u2518");
   const body = [];
   for (let i = 0; i < h; i++) {
     const line = lines[i] ?? "";
@@ -481,31 +695,28 @@ function hstack(blocks, gap = 2) {
 }
 function statRow(label, value, width = 9) {
   const w = Math.max(width, label.length + 1);
-  return `${chalk2.dim(label.padEnd(w))}${value}`;
-}
-function bar(percent, width = 20) {
-  const filled = Math.round(Math.min(100, Math.max(0, percent)) / 100 * width);
-  const empty = width - filled;
-  const barStr = "\u2588".repeat(Math.max(0, filled)) + "\u2591".repeat(Math.max(0, empty));
-  const color = percent > 90 ? chalk2.red : percent > 70 ? chalk2.yellow : chalk2.green;
-  return color(barStr);
+  return `${chalk3.dim(label.padEnd(w))}${value}`;
 }
 function gaugeRow(label, percent, contentWidth) {
   const labelW = 9;
   const pctText = `${Math.round(percent)}%`;
   const barW = Math.max(6, contentWidth - labelW - pctText.length - 1);
-  return `${chalk2.dim(label.padEnd(labelW))}${bar(percent, barW)} ${pctText}`;
+  const filled = Math.round(Math.min(100, Math.max(0, percent)) / 100 * barW);
+  const empty = barW - filled;
+  const barStr = "\u2588".repeat(Math.max(0, filled)) + "\u2591".repeat(Math.max(0, empty));
+  const color = percent > 90 ? chalk3.red : percent > 70 ? chalk3.yellow : chalk3.green;
+  return `${chalk3.dim(label.padEnd(labelW))}${color(barStr)} ${pctText}`;
 }
 function thermalColor(pressureLevel) {
-  if (pressureLevel >= 3) return chalk2.red;
-  if (pressureLevel === 2) return chalk2.yellow;
-  if (pressureLevel === 1) return chalk2.yellowBright;
-  return chalk2.green;
+  if (pressureLevel >= 3) return chalk3.red;
+  if (pressureLevel === 2) return chalk3.yellow;
+  if (pressureLevel === 1) return chalk3.yellowBright;
+  return chalk3.green;
 }
 function capacityColor(percent) {
-  if (percent < 80) return chalk2.red;
-  if (percent < 90) return chalk2.yellow;
-  return chalk2.green;
+  if (percent < 80) return chalk3.red;
+  if (percent < 90) return chalk3.yellow;
+  return chalk3.green;
 }
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -525,7 +736,7 @@ function cpuCard(data, contentWidth) {
     statRow("Cores", `${data.cpu.physicalCores}/${data.cpu.cores} phys/log`),
     statRow("Freq", `${data.cpu.frequency} MHz`),
     gaugeRow("Usage", data.cpu.usage, contentWidth),
-    statRow("Load", data.cpu.loadAvg.map((l) => l.toFixed(2)).join(" \xB7 "))
+    statRow("Load", data.cpu.loadAvg.map((l) => l.toFixed(2)).join(" "))
   ];
   if (data.cpu.temperature) lines.push(statRow("Temp", formatTemp(data.cpu.temperature)));
   return lines;
@@ -534,17 +745,32 @@ function memCard(data, contentWidth) {
   return [
     statRow("Total", formatBytes(data.memory.total)),
     statRow("Used", formatBytes(data.memory.used)),
+    statRow("Cached", formatBytes(data.memory.total - data.memory.free - data.memory.used)),
     statRow("Free", formatBytes(data.memory.free)),
     gaugeRow("Usage", data.memory.usagePercent, contentWidth),
     statRow("Swap", `${formatBytes(data.memory.swapUsed)} / ${formatBytes(data.memory.swapTotal)}`)
   ];
 }
+function gpuCard(data, contentWidth) {
+  if (!data.gpu) return null;
+  const lines = [];
+  lines.push(statRow("Model", truncatePlain(data.gpu.model, Math.max(4, contentWidth - 8))));
+  lines.push(statRow("Memory", formatBytes(data.gpu.memory)));
+  lines.push(statRow("Util", `${data.gpu.utilization}%`));
+  if (data.gpu.temperature) lines.push(statRow("Temp", formatTemp(data.gpu.temperature)));
+  lines.push(statRow("Procs", String(data.gpu.processes)));
+  return lines;
+}
 function powerCard(data) {
-  if (!data.power) return null;
   const lines = [];
-  if (data.power.cpuWatts !== void 0) lines.push(statRow("CPU", `${data.power.cpuWatts.toFixed(2)} W`));
-  if (data.power.gpuWatts !== void 0) lines.push(statRow("GPU", `${data.power.gpuWatts.toFixed(2)} W`));
-  if (data.power.combinedWatts !== void 0) lines.push(statRow("Total", `${data.power.combinedWatts.toFixed(2)} W`));
+  if (data.power) {
+    if (data.power.cpuWatts !== void 0) lines.push(statRow("CPU", `${data.power.cpuWatts.toFixed(2)} W`));
+    if (data.power.gpuWatts !== void 0) lines.push(statRow("GPU", `${data.power.gpuWatts.toFixed(2)} W`));
+    if (data.power.combinedWatts !== void 0) lines.push(statRow("Total", `${data.power.combinedWatts.toFixed(2)} W`));
+  }
+  if (data.battery?.powerWatts !== void 0 && data.battery.powerWatts > 0) {
+    lines.push(statRow("Battery", `${data.battery.powerWatts.toFixed(2)} W`));
+  }
   return lines.length ? lines : null;
 }
 function batteryCard(data, contentWidth) {
@@ -553,12 +779,19 @@ function batteryCard(data, contentWidth) {
   const lines = [
     statRow("Level", `${data.battery.level}%  (${data.battery.state})`),
     statRow("Time", data.battery.timeRemaining),
-    statRow("Health", truncatePlain(data.battery.health, valW))
+    statRow("Cycles", String(data.battery.cycles ?? "N/A")),
+    statRow("Condition", data.battery.condition ?? "N/A")
   ];
   if (data.battery.maxCapacityPercent !== void 0) {
     lines.push(statRow("Capacity", capacityColor(data.battery.maxCapacityPercent)(`${data.battery.maxCapacityPercent}%`)));
   }
   lines.push(statRow("Source", data.battery.powerSource));
+  if (data.battery.estimatedTimeToEmpty && data.battery.state !== "charged") {
+    lines.push(statRow("Est. Empty", data.battery.estimatedTimeToEmpty));
+  }
+  if (data.battery.dischargeRatePerHour !== void 0 && data.battery.state !== "charged") {
+    lines.push(statRow("Disch. Rate", `${data.battery.dischargeRatePerHour}%/h`));
+  }
   return lines;
 }
 function thermalCard(data, contentWidth) {
@@ -576,50 +809,251 @@ function networkCard(data, contentWidth) {
   const valW = Math.max(6, contentWidth - 8);
   return [
     statRow("Iface", truncatePlain(`${data.network.interface} (${data.network.ip})`, valW)),
-    statRow("RX", `${formatBytes(data.network.rxBytes)} \xB7 ${data.network.rxPackets} pkts`),
-    statRow("TX", `${formatBytes(data.network.txBytes)} \xB7 ${data.network.txPackets} pkts`)
+    statRow("RX", `${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt`),
+    statRow("TX", `${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt`)
   ];
 }
+function packetCard(data, contentWidth) {
+  if (!data.packets) return null;
+  const lines = [];
+  lines.push(statRow("Total", `${data.packets.totalPackets} pkt`));
+  lines.push(statRow("RX", `${data.packets.rxPackets} pkt`));
+  lines.push(statRow("TX", `${data.packets.txPackets} pkt`));
+  lines.push(statRow("Conns", `${data.packets.connections} TCP`));
+  if (data.packets.topProcesses && data.packets.topProcesses.length) {
+    lines.push(statRow("Top Proc", truncatePlain(data.packets.topProcesses[0].command, contentWidth - 10)));
+  }
+  if (data.packets.allProcesses && data.packets.allProcesses.length > 1) {
+    lines.push(statRow("Net Procs", `${data.packets.allProcesses.length} processes`));
+  }
+  if (data.packets.interfaces && data.packets.interfaces.length) {
+    lines.push(statRow("Ifaces", `${data.packets.interfaces.length} active`));
+  }
+  return lines;
+}
+function tasksCard(data, contentWidth) {
+  if (!data.tasks || !data.tasks.length) return null;
+  const lines = [];
+  for (const task of data.tasks.slice(0, 6)) {
+    const cmd = truncatePlain(task.command, Math.max(4, contentWidth - 28));
+    lines.push(statRow(`${task.pid}`, `${task.user.padEnd(8)} ${task.cpu.toFixed(1).padStart(5)}% ${task.mem.toFixed(1).padStart(5)}% ${task.state} ${cmd}`));
+  }
+  return lines;
+}
 function header(data, width, badges = [], borderAccent = THEMES.default.border) {
-  const left = `${chalk2.hex("#ff5500").bold(" PYRE ")} ${chalk2.bold(data.header.hostname)}  ${chalk2.dim(data.header.os)}  ${chalk2.dim("up " + data.header.uptime)}`;
-  const right = badges.join("   ");
+  const now = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  const left = `${chalk3.hex("#ff5500").bold(" PYRE ")} ${chalk3.bold(data.header.hostname)}  ${chalk3.dim(data.header.os)}  ${chalk3.dim("up " + data.header.uptime)}`;
+  const right = `${chalk3.dim(now)}  ${badges.join("  ")}`;
   const gap = Math.max(1, width - visLen(left) - visLen(right));
   const line = left + " ".repeat(gap) + right;
   return [line, borderAccent("\u2500".repeat(width))];
 }
+var TAB_DEFS = [
+  { id: "cpu", label: "CPU", key: "1" },
+  { id: "mem", label: "Memory", key: "2" },
+  { id: "gpu", label: "GPU", key: "3" },
+  { id: "power", label: "Power", key: "4" },
+  { id: "battery", label: "Battery", key: "5" },
+  { id: "thermal", label: "Thermal", key: "6" },
+  { id: "network", label: "Network", key: "7" },
+  { id: "packets", label: "Packets", key: "8" },
+  { id: "tasks", label: "Tasks", key: "9" },
+  { id: "disk", label: "Disk", key: "0" },
+  { id: "process", label: "Process", key: "p" }
+];
+var TAB_BAR_INDENT = 2;
+var TAB_SEPARATOR_WIDTH = 3;
+function getTabHitboxes() {
+  const boxes = [];
+  let col = TAB_BAR_INDENT;
+  TAB_DEFS.forEach((t, i) => {
+    const text = `[${t.key}]${t.label}`;
+    const start = col;
+    const end = col + text.length;
+    boxes.push({ id: t.id, start, end });
+    col = end;
+    if (i < TAB_DEFS.length - 1) col += TAB_SEPARATOR_WIDTH;
+  });
+  return boxes;
+}
+var TAB_BAR_ROW = 4;
+function tabBar(activePanel, width, theme) {
+  const rendered = TAB_DEFS.map((t) => {
+    const isActive = activePanel === t.id;
+    const label = isActive ? chalk3.bold(t.label) : chalk3.dim(t.label);
+    const keyHint = chalk3.dim(`[${t.key}]`);
+    return `${keyHint}${label}`;
+  });
+  const joined = rendered.join(chalk3.dim(" \u2502 "));
+  const padded = visLen(joined) < width ? joined + " ".repeat(width - visLen(joined)) : joined;
+  return chalk3.dim("  ") + padded;
+}
 function sortProcesses(processes, sortBy) {
   const copy = [...processes];
-  if (sortBy === "pid") return copy.sort((a, b) => a.pid - b.pid);
-  if (sortBy === "mem") return copy.sort((a, b) => b.mem - a.mem);
-  return copy.sort((a, b) => b.cpu - a.cpu);
+  switch (sortBy) {
+    case "pid":
+      return copy.sort((a, b) => a.pid - b.pid);
+    case "mem":
+      return copy.sort((a, b) => b.mem - a.mem);
+    case "user":
+      return copy.sort((a, b) => a.user.localeCompare(b.user));
+    case "command":
+      return copy.sort((a, b) => a.command.localeCompare(b.command));
+    case "state":
+      return copy.sort((a, b) => a.state.localeCompare(b.state));
+    case "threads":
+      return copy.sort((a, b) => b.threads - a.threads);
+    case "runtime":
+      return copy.sort((a, b) => b.runtime - a.runtime);
+    default:
+      return copy.sort((a, b) => b.cpu - a.cpu);
+  }
 }
 function pctColor(v) {
-  return v > 80 ? chalk2.red : v > 50 ? chalk2.yellow : chalk2.dim;
+  return v > 80 ? chalk3.red : v > 50 ? chalk3.yellow : chalk3.dim;
 }
 function processTableLines(processes, contentWidth, borderAccent = THEMES.default.border) {
-  const pidW = 7, userW = 10, cpuW = 7, memW = 7;
-  const cmdW = Math.max(10, contentWidth - pidW - userW - cpuW - memW - 4);
-  const head = chalk2.bold.dim("PID".padEnd(pidW)) + chalk2.bold.dim("USER".padEnd(userW)) + chalk2.bold.dim("CPU%".padEnd(cpuW)) + chalk2.bold.dim("MEM%".padEnd(memW)) + chalk2.bold.dim("COMMAND");
+  const pidW = 8, ppidW = 8, userW = 12, cpuW = 8, memW = 8, stateW = 8, thrW = 6, rtW = 10;
+  const cmdW = Math.max(10, contentWidth - pidW - ppidW - userW - cpuW - memW - stateW - thrW - rtW - 8);
+  const head = chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" PID    ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" PPID   ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" USER       ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" CPU%   ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" MEM%   ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" STATE   ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" THREADS") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" RUNTIME  ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" COMMAND".padEnd(cmdW + 1));
   const rows = processes.map((p) => {
     const cpuStr = pctColor(p.cpu)(`${p.cpu.toFixed(1)}`.padEnd(cpuW));
     const memStr = pctColor(p.mem)(`${p.mem.toFixed(1)}`.padEnd(memW));
-    return String(p.pid).padEnd(pidW) + truncatePlain(p.user, userW - 1).padEnd(userW) + cpuStr + memStr + truncatePlain(p.command, cmdW);
+    const stateStr = chalk3.dim(p.state.padEnd(stateW));
+    const thrStr = String(p.threads).padEnd(thrW);
+    const rtStr = formatRuntime(p.runtime).padEnd(rtW);
+    return String(p.pid).padEnd(pidW) + String(p.ppid).padEnd(ppidW) + truncatePlain(p.user, userW - 1).padEnd(userW) + cpuStr + memStr + stateStr + thrStr + rtStr + truncatePlain(p.command, cmdW);
   });
   return [head, borderAccent("\u2500".repeat(contentWidth)), ...rows];
 }
+function formatRuntime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const mins = Math.floor(seconds / 60);
+  if (mins < 60) return `${mins}m ${seconds % 60}s`;
+  const hrs = Math.floor(mins / 60);
+  return `${hrs}h ${mins % 60}m`;
+}
+function buildProcessTree(processes) {
+  const map = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const p of processes) map.set(p.pid, p);
+  for (const p of processes) {
+    if (p.ppid === 0 || !map.has(p.ppid)) roots.push(p);
+  }
+  const lines = [];
+  const visited = /* @__PURE__ */ new Set();
+  function renderNode(proc, prefix, isLast) {
+    if (visited.has(proc.pid)) return;
+    visited.add(proc.pid);
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const pidStr = String(proc.pid).padEnd(8);
+    const cpuStr = pctColor(proc.cpu)(`${proc.cpu.toFixed(1)}%`.padEnd(8));
+    const memStr = pctColor(proc.mem)(`${proc.mem.toFixed(1)}%`.padEnd(8));
+    const stateStr = chalk3.dim(proc.state.padEnd(8));
+    const thrStr = String(proc.threads).padEnd(6);
+    const cmd = truncatePlain(proc.command, Math.max(10, 100 - pidStr.length - cpuStr.length - memStr.length - stateStr.length - thrStr.length - 10));
+    lines.push(`${prefix}${connector}${pidStr}${cpuStr}${memStr}${stateStr}${thrStr} ${cmd}`);
+    const children = processes.filter((p) => p.ppid === proc.pid && !visited.has(p.pid));
+    children.sort((a, b) => b.cpu - a.cpu);
+    children.forEach((child, i) => {
+      const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+      renderNode(child, nextPrefix, i === children.length - 1);
+    });
+  }
+  roots.sort((a, b) => b.cpu - a.cpu);
+  roots.forEach((root, i) => renderNode(root, "", i === roots.length - 1));
+  return lines;
+}
 function diskTableLines(disks, contentWidth, borderAccent = THEMES.default.border) {
-  const fsW = 16, sizeW = 8, usedW = 8, availW = 8, capW = 7;
+  const fsW = 20, sizeW = 10, usedW = 10, availW = 10, capW = 8;
   const mountW = Math.max(8, contentWidth - fsW - sizeW - usedW - availW - capW - 5);
-  const head = chalk2.bold.dim("FILESYSTEM".padEnd(fsW)) + chalk2.bold.dim("SIZE".padEnd(sizeW)) + chalk2.bold.dim("USED".padEnd(usedW)) + chalk2.bold.dim("AVAIL".padEnd(availW)) + chalk2.bold.dim("CAP".padEnd(capW)) + chalk2.bold.dim("MOUNT");
-  const rows = disks.slice(0, 8).map((d) => {
+  const head = chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" FILESYSTEM          ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" SIZE      ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" USED      ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" AVAIL     ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" CAP     ") + chalk3.bold.hex("#f8f8f2").bgHex("#44475a")(" MOUNT".padEnd(mountW + 1));
+  const rows = disks.map((d) => {
     const capNum = parseInt(d.capacity, 10) || 0;
     const capStr = pctColor(capNum)(d.capacity.padEnd(capW));
     return truncatePlain(d.filesystem, fsW - 1).padEnd(fsW) + d.size.padEnd(sizeW) + d.used.padEnd(usedW) + d.available.padEnd(availW) + capStr + truncatePlain(d.mountpoint, mountW);
   });
   return [head, borderAccent("\u2500".repeat(contentWidth)), ...rows];
 }
+function detailPanelTitle(panel2) {
+  const map = {
+    cpu: "CPU",
+    mem: "Memory",
+    gpu: "GPU",
+    power: "Power",
+    battery: "Battery",
+    thermal: "Thermal",
+    network: "Network",
+    packets: "Packets",
+    tasks: "Tasks",
+    disk: "Disk",
+    process: "Processes"
+  };
+  return map[panel2] || panel2;
+}
+function activeDetailLines(data, activePanel, width) {
+  const contentWidth = width - 4;
+  switch (activePanel) {
+    case "cpu":
+      return cpuCard(data, contentWidth);
+    case "mem":
+      return memCard(data, contentWidth);
+    case "gpu": {
+      const gpu = gpuCard(data, contentWidth);
+      return gpu ?? ["No GPU data available"];
+    }
+    case "power": {
+      const power = powerCard(data);
+      if (!power && !data.battery) return ["No power data available"];
+      const lines = [];
+      if (power) lines.push(...power);
+      if (data.battery?.powerWatts !== void 0 && data.battery.powerWatts > 0) {
+        lines.push(statRow("Battery", `${data.battery.powerWatts.toFixed(2)} W`));
+      }
+      return lines.length ? lines : ["No power data available"];
+    }
+    case "battery":
+      return data.battery ? batteryCard(data, contentWidth) : ["No battery data available"];
+    case "thermal":
+      return thermalCard(data, contentWidth);
+    case "network":
+      return networkCard(data, contentWidth);
+    case "packets": {
+      if (!data.packets) return ["No packet data available"];
+      const lines = [];
+      lines.push(statRow("Total", `${data.packets.totalPackets} pkt`));
+      lines.push(statRow("RX", `${data.packets.rxPackets} pkt`));
+      lines.push(statRow("TX", `${data.packets.txPackets} pkt`));
+      lines.push(statRow("Conns", `${data.packets.connections} TCP`));
+      if (data.packets.interfaces && data.packets.interfaces.length) {
+        lines.push(statRow("Ifaces", `${data.packets.interfaces.length} active`));
+        for (const iface of data.packets.interfaces.slice(0, 8)) {
+          lines.push(statRow(`  ${iface.iface}`, `RX ${formatBytes(iface.rxBytes)} / TX ${formatBytes(iface.txBytes)}`));
+        }
+      }
+      if (data.packets.allProcesses && data.packets.allProcesses.length) {
+        lines.push(statRow("Net Procs", `${data.packets.allProcesses.length} total`));
+        for (const proc of data.packets.allProcesses.slice(0, 10)) {
+          lines.push(statRow(`  ${proc.pid}`, `${truncatePlain(proc.command, 20)}  TX ${formatBytes(proc.txBytes)}`));
+        }
+      }
+      return lines;
+    }
+    case "tasks":
+      return data.tasks?.length ? tasksCard(data, contentWidth) : ["No task data available"];
+    case "disk":
+      return data.disk.length ? diskTableLines(data.disk, width - 4, THEMES.default.border) : ["No disk data available"];
+    case "process": {
+      const sorted = sortProcesses([...data.processes], "cpu");
+      return processTableLines(sorted.slice(0, 50), width - 4, THEMES.default.border);
+    }
+    default:
+      return null;
+  }
+}
 function formatTable(data, opts2 = {}) {
   const width = clampWidth(opts2.width);
+  const activePanel = opts2.activePanel || "grid";
   const columns = gridColumns(width);
   const gap = 2;
   const cardWidth = Math.floor((width - gap * (columns - 1)) / columns);
@@ -630,6 +1064,15 @@ function formatTable(data, opts2 = {}) {
   const out = [];
   out.push(...header(data, width, [], theme.border));
   out.push("");
+  out.push(tabBar(activePanel, width, theme));
+  out.push("");
+  if (activePanel !== "grid") {
+    const lines = activeDetailLines(data, activePanel, width);
+    if (lines) {
+      out.push(...panel(detailPanelTitle(activePanel), lines, width, theme[activePanel] ?? theme.cpu, theme.border));
+    }
+    return out.join("\n");
+  }
   const cards = [];
   if (vis.cpu !== false) {
     cards.push({ title: "CPU", accent: theme.cpu, lines: cpuCard(data, contentWidth) });
@@ -637,6 +1080,10 @@ function formatTable(data, opts2 = {}) {
   if (vis.mem !== false) {
     cards.push({ title: "Memory", accent: theme.mem, lines: memCard(data, contentWidth) });
   }
+  if (vis.gpu !== false) {
+    const gpu = gpuCard(data, contentWidth);
+    if (gpu) cards.push({ title: "GPU", accent: theme.gpu, lines: gpu });
+  }
   if (vis.power !== false) {
     const power = powerCard(data);
     if (power) cards.push({ title: "Power", accent: theme.power, lines: power });
@@ -651,6 +1098,14 @@ function formatTable(data, opts2 = {}) {
   if (vis.network !== false) {
     cards.push({ title: "Network", accent: theme.network, lines: networkCard(data, contentWidth) });
   }
+  if (vis.packets !== false) {
+    const packets = packetCard(data, contentWidth);
+    if (packets) cards.push({ title: "Packets", accent: theme.network, lines: packets });
+  }
+  if (vis.tasks !== false) {
+    const tasks = tasksCard(data, contentWidth);
+    if (tasks) cards.push({ title: "Tasks", accent: theme.process, lines: tasks });
+  }
   for (let i = 0; i < cards.length; i += columns) {
     const row = cards.slice(i, i + columns);
     const rowHeight = Math.max(...row.map((c) => c.lines.length));
@@ -668,14 +1123,49 @@ function formatTable(data, opts2 = {}) {
     const sortedProcesses = sortProcesses(filteredProcesses, opts2.sortBy ?? "cpu");
     const limited = opts2.processLimit ? sortedProcesses.slice(0, opts2.processLimit) : sortedProcesses;
     const procTitle = opts2.filter ? `Processes \xB7 filter "${opts2.filter}" \xB7 sort ${opts2.sortBy ?? "cpu"}` : `Processes \xB7 sort ${opts2.sortBy ?? "cpu"}`;
-    if (limited.length) {
+    if (opts2.treeView) {
+      const treeLines = buildProcessTree(limited);
+      if (treeLines.length) {
+        out.push(...panel(procTitle + " \xB7 tree", treeLines, width, theme.process, theme.border));
+      } else if (opts2.filter) {
+        out.push(...panel(procTitle, [chalk3.dim(`No processes match "${opts2.filter}"`)], width, theme.process, theme.border));
+      }
+    } else if (limited.length) {
       out.push(...panel(procTitle, processTableLines(limited, width - 4, theme.border), width, theme.process, theme.border));
     } else if (opts2.filter) {
-      out.push(...panel(procTitle, [chalk2.dim(`No processes match "${opts2.filter}"`)], width, theme.process, theme.border));
+      out.push(...panel(procTitle, [chalk3.dim(`No processes match "${opts2.filter}"`)], width, theme.process, theme.border));
     }
   }
   return out.join("\n");
 }
+function clampWidth(width) {
+  if (!width || Number.isNaN(width)) return 80;
+  return Math.max(60, Math.min(width, 240));
+}
+function gridColumns(width) {
+  if (width >= 150) return 3;
+  if (width >= 96) return 2;
+  return 1;
+}
+
+// src/formatters/output.ts
+import chalk4 from "chalk";
+
+// src/sparkline.ts
+var BLOCKS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+function sparkline(values, opts2 = {}) {
+  if (!values.length) return "";
+  const min = opts2.min ?? Math.min(...values);
+  const max = opts2.max ?? Math.max(...values);
+  const range = max - min || 1;
+  return values.map((v) => {
+    const idx = Math.round((v - min) / range * (BLOCKS.length - 1));
+    const clamped = Math.min(BLOCKS.length - 1, Math.max(0, idx));
+    return BLOCKS[clamped];
+  }).join("");
+}
+
+// src/formatters/output.ts
 function formatJson(data) {
   return JSON.stringify(data, null, 2);
 }
@@ -697,15 +1187,21 @@ function formatCsv(data) {
     [
       "thermal",
       "cpuTempF",
-      data.thermal.temperatures?.cpu_die !== void 0 ? String(celsiusToFahrenheit(data.thermal.temperatures.cpu_die)) : ""
+      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)],
+    ["network", "txPackets", String(data.network.txPackets)],
+    ["network", "connections", data.network.connections ? String(data.network.connections) : ""],
     ["battery", "level", data.battery ? String(data.battery.level) : ""],
     ["battery", "powerSource", data.battery ? data.battery.powerSource : ""],
     ["battery", "condition", data.battery?.condition ?? ""],
     ["battery", "maxCapacityPercent", data.battery?.maxCapacityPercent !== void 0 ? String(data.battery.maxCapacityPercent) : ""],
     ["battery", "cycles", data.battery?.cycles !== void 0 ? String(data.battery.cycles) : ""],
+    ["battery", "estimatedTimeToEmpty", data.battery?.estimatedTimeToEmpty ?? ""],
+    ["battery", "dischargeRatePerHour", data.battery?.dischargeRatePerHour !== void 0 ? String(data.battery.dischargeRatePerHour) : ""],
+    ["battery", "powerWatts", data.battery?.powerWatts !== void 0 ? String(data.battery.powerWatts) : ""],
     ["power", "cpuWatts", data.power?.cpuWatts !== void 0 ? String(data.power.cpuWatts) : ""],
     ["power", "gpuWatts", data.power?.gpuWatts !== void 0 ? String(data.power.gpuWatts) : ""],
     ["power", "combinedWatts", data.power?.combinedWatts !== void 0 ? String(data.power.combinedWatts) : ""],
@@ -713,94 +1209,199 @@ function formatCsv(data) {
     ["system", "uptime", data.header.uptime],
     ["system", "timestamp", data.timestamp]
   ];
+  if (data.packets) {
+    rows.push(["packets", "totalPackets", String(data.packets.totalPackets)]);
+    rows.push(["packets", "rxPackets", String(data.packets.rxPackets)]);
+    rows.push(["packets", "txPackets", String(data.packets.txPackets)]);
+    rows.push(["packets", "connections", String(data.packets.connections)]);
+    for (const iface of data.packets.interfaces || []) {
+      rows.push(["packets_iface", iface.iface, `${iface.rxPackets},${iface.txPackets},${iface.rxBytes},${iface.txBytes}`]);
+    }
+    for (const proc of data.packets.allProcesses || []) {
+      rows.push(["packets_proc", `pid=${proc.pid}`, `${proc.command},${proc.rxBytes},${proc.txBytes}`]);
+    }
+  }
+  if (data.gpu) {
+    rows.push(["gpu", "model", data.gpu.model]);
+    rows.push(["gpu", "memory", String(data.gpu.memory)]);
+    rows.push(["gpu", "utilization", String(data.gpu.utilization)]);
+    if (data.gpu.temperature) rows.push(["gpu", "tempC", String(data.gpu.temperature)]);
+    rows.push(["gpu", "processes", String(data.gpu.processes)]);
+  }
+  for (const p of data.processes) {
+    rows.push(["process", `pid=${p.pid}`, `${p.pid}`]);
+    rows.push(["process", `ppid=${p.pid}`, String(p.ppid)]);
+    rows.push(["process", `user=${p.pid}`, p.user]);
+    rows.push(["process", `cpu=${p.pid}`, String(p.cpu)]);
+    rows.push(["process", `mem=${p.pid}`, String(p.mem)]);
+    rows.push(["process", `state=${p.pid}`, p.state]);
+    rows.push(["process", `threads=${p.pid}`, String(p.threads)]);
+    rows.push(["process", `runtime=${p.pid}`, String(p.runtime)]);
+    rows.push(["process", `command=${p.pid}`, p.command]);
+  }
   return rows.map((r) => r.map((item) => `"${String(item).replace(/"/g, '""')}"`).join(",")).join("\n");
 }
 function formatTsv(data) {
   return formatCsv(data).split("\n").map((r) => r.split(",").join("	")).join("\n");
 }
-function formatGraphs(history2, width = 80, themeName = "default") {
+function formatGraphs(history, width = 80, themeName = "default", graphMode = "spark") {
   const theme = THEMES[themeName] || THEMES.default;
   const contentWidth = width - 4;
-  const sampleCount = history2.cpuUsage.length;
+  const sampleCount = history.cpuUsage.length;
   const sparkWidth = Math.max(10, contentWidth - 28);
   const lines = [];
-  lines.push(graphRow("CPU %", history2.cpuUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth));
-  lines.push(graphRow("Mem %", history2.memUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth));
+  lines.push(graphRow("CPU %", history.cpuUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth, graphMode));
+  lines.push(graphRow("Mem %", history.memUsage, { min: 0, max: 100 }, (v) => `${v.toFixed(0)}%`, sparkWidth, graphMode));
   lines.push(
-    graphRow("Temp", history2.temp, {}, formatTemp, sparkWidth, "no sensor access (needs sudo powermetrics)")
+    graphRow("Temp", history.temp, {}, formatTemp, sparkWidth, "no sensor access (needs sudo powermetrics)", graphMode)
   );
-  lines.push(graphRow("Net RX/s", history2.netRxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth));
-  lines.push(graphRow("Net TX/s", history2.netTxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth));
-  const title = `Graphs \xB7 last ${sampleCount} sample${sampleCount === 1 ? "" : "s"}`;
+  lines.push(graphRow("Net RX/s", history.netRxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth, graphMode));
+  lines.push(graphRow("Net TX/s", history.netTxRate, {}, (v) => `${formatBytes(v)}/s`, sparkWidth, graphMode));
+  if (history.powerWatts.length) {
+    lines.push(graphRow("Power W", history.powerWatts, {}, (v) => `${v.toFixed(1)} W`, sparkWidth, graphMode));
+  }
+  if (history.rxPacketRate.length) {
+    lines.push(graphRow("RX pkt/s", history.rxPacketRate, {}, (v) => `${v.toFixed(0)} pkt/s`, sparkWidth, graphMode));
+  }
+  if (history.txPacketRate.length) {
+    lines.push(graphRow("TX pkt/s", history.txPacketRate, {}, (v) => `${v.toFixed(0)} pkt/s`, sparkWidth, graphMode));
+  }
+  const title = `Graphs \xB7 mode:${graphMode} \xB7 last ${sampleCount} sample${sampleCount === 1 ? "" : "s"}`;
   return panel(title, lines, width, theme.graphs, theme.border).join("\n");
 }
-function graphRow(label, values, bounds, fmt, sparkWidth = 40, emptyMessage = "collecting data...") {
+function graphRow(label, values, bounds, fmt, sparkWidth = 40, emptyMessage = "collecting data...", mode = "spark") {
   if (!values.length) {
-    return `${chalk2.dim(label.padEnd(10))} ${chalk2.dim(emptyMessage)}`;
+    return `${chalk4.dim(label.padEnd(10))} ${chalk4.dim(emptyMessage)}`;
   }
   const visible = values.slice(-sparkWidth);
-  const spark = sparkline(visible, bounds);
+  const spark = mode === "spark" ? sparkline(visible, bounds) : barGraph(visible, bounds, sparkWidth);
   const current = values[values.length - 1];
-  let color = chalk2.cyan;
+  let color = chalk4.cyan;
   if (bounds.min !== void 0 && bounds.max !== void 0) {
     const pct = (current - bounds.min) / (bounds.max - bounds.min || 1) * 100;
-    color = pct > 90 ? chalk2.red : pct > 70 ? chalk2.yellow : chalk2.green;
+    color = pct > 90 ? chalk4.red : pct > 70 ? chalk4.yellow : chalk4.green;
   }
-  return `${chalk2.dim(label.padEnd(10))}${color(spark)}  ${chalk2.bold(fmt(current))}`;
+  return `${chalk4.dim(label.padEnd(10))}${color(spark)}  ${chalk4.bold(fmt(current))}`;
+}
+function barGraph(values, bounds, width) {
+  const min = bounds.min ?? Math.min(...values);
+  const max = bounds.max ?? Math.max(...values);
+  const range = max - min || 1;
+  return values.map((v) => {
+    const pct = (v - min) / range;
+    if (pct > 0.8) return "\u2588";
+    if (pct > 0.6) return "\u2587";
+    if (pct > 0.4) return "\u2586";
+    if (pct > 0.2) return "\u2584";
+    return " ";
+  }).join("");
 }
 
-// src/live.ts
-import fs from "fs";
-import path from "path";
+// src/live/input.ts
 import readline from "readline";
-import chalk3 from "chalk";
 
 // src/history.ts
 var History = class {
+  /** Maximum number of samples retained in the rolling window. */
   maxLen;
+  /** Rolling window of CPU usage percentages (0–100). */
   cpuUsage = [];
+  /** Rolling window of memory usage percentages (0–100). */
   memUsage = [];
+  /** Rolling window of CPU die temperatures in °C. */
   temp = [];
+  /** Rolling window of network receive rates in bytes/sec. */
   netRxRate = [];
+  /** Rolling window of network transmit rates in bytes/sec. */
   netTxRate = [];
+  /** Rolling window of GPU utilization percentages (0–100). */
+  gpuUtil = [];
+  /** Rolling window of combined power draw in watts. */
+  powerWatts = [];
+  /** Rolling window of network receive packet rates in packets/sec. */
+  rxPacketRate = [];
+  /** Rolling window of network transmit packet rates in packets/sec. */
+  txPacketRate = [];
+  /** Rolling window of active TCP connections. */
+  connections = [];
   lastRxBytes = 0;
   lastTxBytes = 0;
+  lastRxPackets = 0;
+  lastTxPackets = 0;
   lastTs = 0;
+  /**
+   * Create a new History instance.
+   * @param maxLen - Maximum number of samples to retain. Defaults to 40.
+   */
   constructor(maxLen = 40) {
     this.maxLen = maxLen;
   }
+  /**
+   * Push a new sample into the rolling window.
+   *
+   * Network rates are computed as bytes/sec from the cumulative
+   * counters.  The first sample always reports 0 for rates
+   * because there is no prior sample to compute a delta from.
+   */
   push(sample) {
     const now = Date.now();
     let rxRate = 0;
     let txRate = 0;
+    let rxPktRate = 0;
+    let txPktRate = 0;
     if (this.lastTs > 0) {
       const dtSeconds = Math.max((now - this.lastTs) / 1e3, 1e-3);
       rxRate = Math.max(0, (sample.rxBytes - this.lastRxBytes) / dtSeconds);
       txRate = Math.max(0, (sample.txBytes - this.lastTxBytes) / dtSeconds);
+      if (sample.rxPackets !== void 0) {
+        rxPktRate = Math.max(0, (sample.rxPackets - this.lastRxPackets) / dtSeconds);
+      }
+      if (sample.txPackets !== void 0) {
+        txPktRate = Math.max(0, (sample.txPackets - this.lastTxPackets) / dtSeconds);
+      }
     }
     this.lastRxBytes = sample.rxBytes;
     this.lastTxBytes = sample.txBytes;
+    if (sample.rxPackets !== void 0) this.lastRxPackets = sample.rxPackets;
+    if (sample.txPackets !== void 0) this.lastTxPackets = sample.txPackets;
     this.lastTs = now;
     this.pushBounded(this.cpuUsage, sample.cpuUsage);
     this.pushBounded(this.memUsage, sample.memUsage);
     if (sample.temp !== null) this.pushBounded(this.temp, sample.temp);
     this.pushBounded(this.netRxRate, rxRate);
     this.pushBounded(this.netTxRate, txRate);
+    if (sample.gpuUtil !== void 0) this.pushBounded(this.gpuUtil, sample.gpuUtil);
+    if (sample.powerWatts !== void 0) this.pushBounded(this.powerWatts, sample.powerWatts);
+    if (sample.rxPackets !== void 0) this.pushBounded(this.rxPacketRate, rxPktRate);
+    if (sample.txPackets !== void 0) this.pushBounded(this.txPacketRate, txPktRate);
+    if (sample.connections !== void 0) this.pushBounded(this.connections, sample.connections);
   }
+  /** Clear all rolling windows and reset cumulative byte counters. */
   reset() {
     this.cpuUsage = [];
     this.memUsage = [];
     this.temp = [];
     this.netRxRate = [];
     this.netTxRate = [];
+    this.gpuUtil = [];
+    this.powerWatts = [];
+    this.rxPacketRate = [];
+    this.txPacketRate = [];
+    this.connections = [];
     this.lastRxBytes = 0;
     this.lastTxBytes = 0;
+    this.lastRxPackets = 0;
+    this.lastTxPackets = 0;
     this.lastTs = 0;
   }
-  /** Grow or shrink the rolling window (e.g. on terminal resize), trimming from the oldest samples. */
+  /**
+   * Grow or shrink the rolling window (e.g. on terminal resize),
+   * trimming from the oldest samples.
+   * @param n - New maximum length; clamped to at least 1.
+   */
   setMaxLen(n) {
     this.maxLen = Math.max(1, n);
-    for (const arr of [this.cpuUsage, this.memUsage, this.temp, this.netRxRate, this.netTxRate]) {
+    for (const arr of [this.cpuUsage, this.memUsage, this.temp, this.netRxRate, this.netTxRate, this.gpuUtil, this.powerWatts, this.rxPacketRate, this.txPacketRate, this.connections]) {
       while (arr.length > this.maxLen) arr.shift();
     }
   }
@@ -810,62 +1411,94 @@ var History = class {
   }
 };
 
-// src/live.ts
-var intervalHandle = null;
-var running = false;
-var paused = false;
-var detailed = false;
-var interval = 2;
-var showGraphs = true;
-var exportFormat = "json";
-var exportDir = "./pyre-exports";
-var currentTheme = "default";
-var visiblePanels = {
-  cpu: true,
-  mem: true,
-  power: true,
-  battery: true,
-  thermal: true,
-  network: true,
-  disk: true,
-  process: true
+// src/live/state.ts
+var SIGNAL_OPTIONS = ["SIGTERM", "SIGKILL", "SIGINT", "SIGHUP", "SIGSTOP", "SIGCONT"];
+var state = {
+  intervalHandle: null,
+  running: false,
+  paused: false,
+  detailed: false,
+  interval: 2,
+  showGraphs: true,
+  graphMode: "spark",
+  exportFormat: "json",
+  exportDir: "./pyre-exports",
+  currentTheme: "default",
+  visiblePanels: {
+    cpu: true,
+    mem: true,
+    gpu: true,
+    power: true,
+    battery: true,
+    thermal: true,
+    network: true,
+    packets: true,
+    tasks: true,
+    disk: true,
+    process: true
+  },
+  logging: false,
+  logStream: null,
+  statusMessage: "",
+  statusTimer: null,
+  lastData: null,
+  history: new History(40),
+  keypressHandler: null,
+  termWidth: process.stdout.columns || 80,
+  termHeight: process.stdout.rows || 24,
+  sortMode: "cpu",
+  processFilter: "",
+  inputMode: null,
+  inputBuffer: "",
+  treeView: false,
+  SIGNAL_OPTIONS,
+  customizerIndex: 0,
+  CUSTOMIZER_OPTIONS: [
+    "Theme",
+    "Graph Mode",
+    "Toggle CPU",
+    "Toggle Memory",
+    "Toggle GPU",
+    "Toggle Power",
+    "Toggle Battery",
+    "Toggle Thermal",
+    "Toggle Network",
+    "Toggle Packets",
+    "Toggle Tasks",
+    "Toggle Disk",
+    "Toggle Processes",
+    "Toggle Tree View"
+  ],
+  CPU_ALERT_PCT: 90,
+  TEMP_ALERT_C: 95,
+  alerted: false,
+  activePanel: "grid",
+  mouseEnabled: true,
+  PANEL_TABS: [
+    { id: "cpu", label: "CPU", key: "1" },
+    { id: "mem", label: "Memory", key: "2" },
+    { id: "gpu", label: "GPU", key: "3" },
+    { id: "power", label: "Power", key: "4" },
+    { id: "battery", label: "Battery", key: "5" },
+    { id: "thermal", label: "Thermal", key: "6" },
+    { id: "network", label: "Network", key: "7" },
+    { id: "packets", label: "Packets", key: "8" },
+    { id: "tasks", label: "Tasks", key: "9" },
+    { id: "disk", label: "Disk", key: "0" },
+    { id: "process", label: "Process", key: "P" }
+  ]
 };
-var logging = false;
-var logStream = null;
-var statusMessage = "";
-var statusTimer = null;
-var lastData = null;
-var history = new History(40);
-var keypressHandler = null;
-var termWidth = process.stdout.columns || 80;
-var termHeight = process.stdout.rows || 24;
-var sortMode = "cpu";
-var processFilter = "";
-var inputMode = null;
-var inputBuffer = "";
-var customizerIndex = 0;
-var CUSTOMIZER_OPTIONS = [
-  "Theme",
-  "Toggle CPU",
-  "Toggle Memory",
-  "Toggle Power",
-  "Toggle Battery",
-  "Toggle Thermal",
-  "Toggle Network",
-  "Toggle Disk",
-  "Toggle Processes"
-];
-var CPU_ALERT_PCT = 90;
-var TEMP_ALERT_C = 95;
-var alerted = false;
 function setStatus(msg, ms = 3e3) {
-  statusMessage = msg;
-  if (statusTimer) clearTimeout(statusTimer);
-  statusTimer = setTimeout(() => {
-    statusMessage = "";
-    render();
+  state.statusMessage = msg;
+  if (state.statusTimer) clearTimeout(state.statusTimer);
+  state.statusTimer = setTimeout(() => {
+    state.statusMessage = "";
   }, ms);
 }
+
+// src/live/export.ts
+import fs from "fs";
+import path from "path";
 function ensureDir(dir) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
@@ -873,14 +1506,14 @@ function timestampForFile() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 function exportSnapshot() {
-  if (!lastData) {
+  if (!state.lastData) {
     setStatus("No data yet \u2014 try again in a moment");
     return;
   }
   try {
-    ensureDir(exportDir);
-    const file = path.join(exportDir, `pyre-${timestampForFile()}.${exportFormat}`);
-    const content = exportFormat === "json" ? formatJson(lastData) : exportFormat === "csv" ? formatCsv(lastData) : formatTsv(lastData);
+    ensureDir(state.exportDir);
+    const file = path.join(state.exportDir, `pyre-${timestampForFile()}.${state.exportFormat}`);
+    const content = state.exportFormat === "json" ? formatJson(state.lastData) : state.exportFormat === "csv" ? formatCsv(state.lastData) : formatTsv(state.lastData);
     fs.writeFileSync(file, content);
     setStatus(`Exported snapshot -> ${file}`);
   } catch (err) {
@@ -889,86 +1522,106 @@ function exportSnapshot() {
 }
 function startLogging() {
   try {
-    ensureDir(exportDir);
-    const file = path.join(exportDir, `pyre-log-${timestampForFile()}.csv`);
-    logStream = fs.createWriteStream(file, { flags: "a" });
-    logStream.write("timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,thermal_state\n");
-    logging = true;
+    ensureDir(state.exportDir);
+    const file = path.join(state.exportDir, `pyre-log-${timestampForFile()}.csv`);
+    state.logStream = fs.createWriteStream(file, { flags: "a" });
+    state.logStream.write("timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,net_rx_packets,net_tx_packets,connections,thermal_state\n");
+    state.logging = true;
     setStatus(`Logging every tick -> ${file}`);
   } catch (err) {
     setStatus(`Logging failed to start: ${err.message}`);
   }
 }
 function stopLogging() {
-  logging = false;
-  logStream?.end();
-  logStream = null;
+  state.logging = false;
+  state.logStream?.end();
+  state.logStream = null;
   setStatus("Logging stopped");
 }
 function toggleLogging() {
-  if (logging) stopLogging();
+  if (state.logging) stopLogging();
   else startLogging();
 }
 function writeLogRow(data) {
-  if (!logging || !logStream) return;
+  if (!state.logging || !state.logStream) return;
   const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? "";
-  logStream.write(
-    `${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${data.thermal.state}
+  const rxPackets = data.network.rxPackets ?? 0;
+  const txPackets = data.network.txPackets ?? 0;
+  const connections = data.network.connections ?? 0;
+  state.logStream.write(
+    `${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${rxPackets},${txPackets},${connections},${data.thermal.state}
 `
   );
 }
+
+// src/live/render.ts
+import chalk5 from "chalk";
 function processRowBudget() {
-  const columns = gridColumns(termWidth);
-  const cardRows = Math.ceil(6 / columns);
-  const reserved = 2 + cardRows * 8 + 11 + (showGraphs ? 9 : 0) + 4;
-  return Math.max(3, Math.min(40, termHeight - reserved));
+  const columns = gridColumns(state.termWidth);
+  const visibleCards = Object.values(state.visiblePanels).filter((v) => v !== false).length;
+  const cardRows = Math.ceil(visibleCards / columns);
+  const reserved = 2 + cardRows * 8 + 11 + (state.showGraphs ? 9 : 0) + 4;
+  return Math.max(3, Math.min(40, state.termHeight - reserved));
 }
 function renderCustomizerOverlay() {
   const themesList = Object.keys(THEMES);
   const lines = [
-    chalk3.bgCyan.black.bold(" UI CUSTOMIZER (Use \u2191/\u2193 or J/K to navigate, Enter/Space to toggle, Esc to exit) ")
+    chalk5.bgCyan.black.bold(" UI CUSTOMIZER (Use \u2191/\u2193 or J/K to navigate, Enter/Space to toggle, Esc to exit) ")
   ];
-  CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
-    const isSelected = idx === customizerIndex;
-    const prefix = isSelected ? chalk3.yellow("\u25B6 ") : "  ";
+  state.CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
+    const isSelected = idx === state.customizerIndex;
+    const prefix = isSelected ? chalk5.yellow("\u25B6 ") : "  ";
     if (opt === "Theme") {
-      lines.push(`${prefix}${opt}: ${chalk3.bold.green(currentTheme)} [${themesList.join(", ")}]`);
+      lines.push(`${prefix}${opt}: ${chalk5.bold.green(state.currentTheme)} [${themesList.join(", ")}]`);
+    } else if (opt === "Graph Mode") {
+      lines.push(`${prefix}${opt}: ${chalk5.bold.green(state.graphMode)} [spark, bar]`);
+    } else if (opt === "Toggle Tree View") {
+      const status = state.treeView ? chalk5.green("[VISIBLE]") : chalk5.red("[HIDDEN]");
+      lines.push(`${prefix}${opt}: ${status}`);
     } else {
       const key = opt.replace("Toggle ", "").toLowerCase();
-      const isVisible = visiblePanels[key] !== false;
-      const status = isVisible ? chalk3.green("[VISIBLE]") : chalk3.red("[HIDDEN]");
+      const isVisible = state.visiblePanels[key] !== false;
+      const status = isVisible ? chalk5.green("[VISIBLE]") : chalk5.red("[HIDDEN]");
       lines.push(`${prefix}${opt}: ${status}`);
     }
   });
   return lines.map((l) => `  ${l}`).join("\n");
 }
 function render() {
-  if (!lastData) return;
+  if (!state.lastData) return;
   const lines = [];
   lines.push(
-    formatTable(lastData, {
-      width: termWidth,
-      sortBy: sortMode,
-      filter: processFilter || void 0,
+    formatTable(state.lastData, {
+      width: state.termWidth,
+      sortBy: state.sortMode,
+      filter: state.processFilter || void 0,
       processLimit: processRowBudget(),
-      theme: currentTheme,
-      visible: visiblePanels
+      theme: state.currentTheme,
+      visible: state.visiblePanels,
+      treeView: state.treeView,
+      activePanel: state.activePanel
     })
   );
-  if (showGraphs) {
+  if (state.showGraphs) {
     lines.push("");
-    lines.push(formatGraphs(history, termWidth, currentTheme));
+    lines.push(formatGraphs(state.history, state.termWidth, state.currentTheme, state.graphMode));
   }
   lines.push("");
   lines.push(footerLine());
-  if (inputMode === "customizer") {
+  if (state.inputMode === "customizer") {
     lines.push(renderCustomizerOverlay());
-  } else if (inputMode === "filter") {
-    lines.push(chalk3.cyan(`  Filter processes: ${inputBuffer}_`));
-  } else if (inputMode === "kill") {
-    lines.push(chalk3.cyan(`  Kill PID: ${inputBuffer}_  (enter to confirm, esc to cancel)`));
-  } else if (statusMessage) {
-    lines.push(`  ${statusMessage}`);
+  } else if (state.inputMode === "filter") {
+    lines.push(chalk5.cyan(`  Filter processes: ${state.inputBuffer}_`));
+  } else if (state.inputMode === "kill") {
+    lines.push(chalk5.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
+  } else if (state.inputMode === "signal") {
+    const sigIdx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer);
+    const sigList = state.SIGNAL_OPTIONS.map((s, i) => i === sigIdx ? chalk5.yellow(s) : chalk5.dim(s)).join("  ");
+    lines.push(chalk5.cyan(`  Signal: ${state.inputBuffer}_`));
+    lines.push(chalk5.dim(`  ${sigList}`));
+    lines.push(chalk5.dim("  \u2191/\u2193 to select, Enter to confirm, Esc to cancel"));
+  } else if (state.statusMessage) {
+    lines.push(`  ${state.statusMessage}`);
   }
   process.stdout.write("\x1B[2J\x1B[H");
   process.stdout.write(lines.join("\n"));
@@ -977,141 +1630,178 @@ function footerLine() {
   const keys = [
     ["q", "quit"],
     ["c", "customize UI"],
-    ["p", paused ? "resume" : "pause"],
-    ["g", showGraphs ? "hide graphs" : "show graphs"],
-    ["d", detailed ? "basic" : "detailed"],
-    ["s", `sort:${sortMode}`],
+    ["p", state.paused ? "resume" : "pause"],
+    ["g", state.showGraphs ? "hide graphs" : "show graphs"],
+    ["b", `graph:${state.graphMode}`],
+    ["d", state.detailed ? "basic" : "detailed"],
+    ["\u2190/\u2192", "tab"],
+    ["1-9", "panels"],
+    ["s", `sort:${state.sortMode}`],
     ["/", "filter"],
     ["k", "kill"],
+    ["S", "signal"],
+    ["t", state.treeView ? "flat" : "tree"],
     ["e", "export"],
-    ["l", logging ? "stop log" : "log"],
-    ["f", exportFormat],
-    ["+/-", `${interval}s`]
+    ["l", state.logging ? "stop log" : "log"],
+    ["f", state.exportFormat],
+    ["+/-", `${state.interval}s`]
   ];
-  const keyStr = keys.map(([k, label]) => `${chalk3.cyan.bold(k)} ${chalk3.dim(label)}`).join(chalk3.dim("  \xB7  "));
+  const keyStr = keys.map(([k, label]) => `${chalk5.hex("#50fa7b").bold(k)} ${chalk5.dim(label)}`).join(chalk5.dim("  |  "));
   const badges = [];
-  if (paused) badges.push(chalk3.yellow.bold("\u23F8 PAUSED"));
-  if (logging) badges.push(chalk3.red.bold("\u25CF REC"));
+  if (state.paused) badges.push(chalk5.yellow.bold("\u23F8 PAUSED"));
+  if (state.logging) badges.push(chalk5.red.bold("\u25CF REC"));
+  if (state.activePanel !== "grid") badges.push(chalk5.cyan.bold(`\u25C9 ${state.activePanel.toUpperCase()}`));
   const badgeStr = badges.join("  ");
   return badgeStr ? `${keyStr}    ${badgeStr}` : keyStr;
 }
 function checkAlerts(data) {
   const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
-  const hot = data.cpu.usage >= CPU_ALERT_PCT || temp !== null && temp >= TEMP_ALERT_C;
-  if (hot && !alerted) {
-    alerted = true;
+  const hot = data.cpu.usage >= state.CPU_ALERT_PCT || temp !== null && temp >= state.TEMP_ALERT_C;
+  if (hot && !state.alerted) {
+    state.alerted = true;
     process.stdout.write("\x07");
-    const reason = data.cpu.usage >= CPU_ALERT_PCT ? `CPU at ${data.cpu.usage}%` : `Temp at ${temp}\xB0C`;
-    setStatus(chalk3.red(`\u26A0 Alert: ${reason}`), 5e3);
+    const reason = data.cpu.usage >= state.CPU_ALERT_PCT ? `CPU at ${data.cpu.usage}%` : `Temp at ${temp}\xB0C`;
+    setStatus(chalk5.red(`\u26A0 Alert: ${reason}`), 5e3);
   } else if (!hot) {
-    alerted = false;
-  }
-}
-async function tick() {
-  if (paused) return;
-  try {
-    const data = await collectAll({ detailed, processLimit: processRowBudget() });
-    lastData = data;
-    const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
-    history.push({
-      cpuUsage: data.cpu.usage,
-      memUsage: data.memory.usagePercent,
-      temp,
-      rxBytes: data.network.rxBytes,
-      txBytes: data.network.txBytes
-    });
-    writeLogRow(data);
-    checkAlerts(data);
-    render();
-  } catch {
-  }
-}
-function killProcess(pidStr) {
-  const pid = parseInt(pidStr, 10);
-  if (!pid || pid <= 0) {
-    setStatus(`Invalid PID: ${pidStr}`);
-    return;
-  }
-  try {
-    process.kill(pid, "SIGTERM");
-    setStatus(`Sent SIGTERM to PID ${pid}`);
-  } catch (err) {
-    setStatus(`Failed to kill ${pid}: ${err.message}`);
+    state.alerted = false;
   }
 }
+
+// src/live/input.ts
 function handleInputModeKey(str, key) {
   if (key.name === "escape") {
-    inputMode = null;
-    inputBuffer = "";
+    state.inputMode = null;
+    state.inputBuffer = "";
     render();
     return;
   }
-  if (inputMode === "customizer") {
+  if (state.inputMode === "customizer") {
     const themesList = Object.keys(THEMES);
     if (key.name === "up" || str === "k") {
-      customizerIndex = (customizerIndex - 1 + CUSTOMIZER_OPTIONS.length) % CUSTOMIZER_OPTIONS.length;
+      state.customizerIndex = (state.customizerIndex - 1 + state.CUSTOMIZER_OPTIONS.length) % state.CUSTOMIZER_OPTIONS.length;
     } else if (key.name === "down" || str === "j") {
-      customizerIndex = (customizerIndex + 1) % CUSTOMIZER_OPTIONS.length;
+      state.customizerIndex = (state.customizerIndex + 1) % state.CUSTOMIZER_OPTIONS.length;
     } else if (key.name === "return" || str === " ") {
-      const selected = CUSTOMIZER_OPTIONS[customizerIndex];
+      const selected = state.CUSTOMIZER_OPTIONS[state.customizerIndex];
       if (selected === "Theme") {
-        const nextIdx = (themesList.indexOf(currentTheme) + 1) % themesList.length;
-        currentTheme = themesList[nextIdx];
+        const nextIdx = (themesList.indexOf(state.currentTheme) + 1) % themesList.length;
+        state.currentTheme = themesList[nextIdx];
+      } else if (selected === "Toggle Tree View") {
+        state.treeView = !state.treeView;
+      } else if (selected === "Graph Mode") {
+        state.graphMode = state.graphMode === "spark" ? "bar" : "spark";
       } else {
         const itemKey = selected.replace("Toggle ", "").toLowerCase();
-        visiblePanels[itemKey] = !visiblePanels[itemKey];
+        state.visiblePanels[itemKey] = !state.visiblePanels[itemKey];
       }
     }
     render();
     return;
   }
+  if (state.inputMode === "signal") {
+    if (key.name === "up" || str === "k") {
+      const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer);
+      state.inputBuffer = state.SIGNAL_OPTIONS[(idx - 1 + state.SIGNAL_OPTIONS.length) % state.SIGNAL_OPTIONS.length];
+    } else if (key.name === "down" || str === "j") {
+      const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer);
+      state.inputBuffer = state.SIGNAL_OPTIONS[(idx + 1) % state.SIGNAL_OPTIONS.length];
+    } else if (key.name === "return" || str === " ") {
+      killProcess(state.inputBuffer.trim(), state.inputBuffer.trim());
+      state.inputMode = null;
+      state.inputBuffer = "";
+      render();
+      return;
+    }
+    render();
+    return;
+  }
   if (key.name === "return") {
-    if (inputMode === "filter") {
-      processFilter = inputBuffer.trim();
-      setStatus(processFilter ? `Filtering: "${processFilter}"` : "Filter cleared");
-    } else if (inputMode === "kill") {
-      killProcess(inputBuffer.trim());
+    if (state.inputMode === "filter") {
+      state.processFilter = state.inputBuffer.trim();
+      setStatus(state.processFilter ? `Filtering: "${state.processFilter}"` : "Filter cleared");
+    } else if (state.inputMode === "kill") {
+      killProcess(state.inputBuffer.trim());
     }
-    inputMode = null;
-    inputBuffer = "";
+    state.inputMode = null;
+    state.inputBuffer = "";
     render();
     return;
   }
   if (key.name === "backspace") {
-    inputBuffer = inputBuffer.slice(0, -1);
+    state.inputBuffer = state.inputBuffer.slice(0, -1);
     render();
     return;
   }
   if (str && str.length === 1 && !key.ctrl && !key.meta) {
-    inputBuffer += str;
+    state.inputBuffer += str;
     render();
   }
 }
+function killProcess(pidStr, signal = "SIGTERM") {
+  const pid = parseInt(pidStr, 10);
+  if (!pid || pid <= 0) {
+    setStatus(`Invalid PID: ${pidStr}`);
+    return;
+  }
+  try {
+    process.kill(pid, signal);
+    setStatus(`Sent ${signal} to PID ${pid}`);
+  } catch (err) {
+    setStatus(`Failed to send ${signal} to ${pid}: ${err.message}`);
+  }
+}
 function onResize() {
-  termWidth = process.stdout.columns || 80;
-  termHeight = process.stdout.rows || 24;
-  history.setMaxLen(Math.max(20, Math.min(200, termWidth - 30)));
+  state.termWidth = process.stdout.columns || 80;
+  state.termHeight = process.stdout.rows || 24;
+  state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
   render();
 }
 function restartTicker() {
-  if (intervalHandle) clearInterval(intervalHandle);
-  intervalHandle = setInterval(tick, interval * 1e3);
+  if (state.intervalHandle) clearInterval(state.intervalHandle);
+  state.intervalHandle = setInterval(tick, state.interval * 1e3);
+}
+async function tick() {
+  if (state.paused) return;
+  try {
+    const data = await collectAll({ detailed: state.detailed, processLimit: processRowBudget() });
+    state.lastData = data;
+    const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
+    state.history.push({
+      cpuUsage: data.cpu.usage,
+      memUsage: data.memory.usagePercent,
+      temp,
+      rxBytes: data.network.rxBytes,
+      txBytes: data.network.txBytes,
+      gpuUtil: data.gpu?.utilization,
+      powerWatts: data.power?.combinedWatts ?? data.power?.cpuWatts ?? 0,
+      rxPackets: data.network.rxPackets,
+      txPackets: data.network.txPackets,
+      connections: data.network.connections ?? 0
+    });
+    writeLogRow(data);
+    checkAlerts(data);
+    render();
+  } catch {
+  }
 }
 async function startLive(opts2) {
-  if (running) return;
-  running = true;
-  paused = false;
-  detailed = !!opts2.detailed;
-  interval = opts2.interval;
-  if (opts2.exportDir) exportDir = opts2.exportDir;
-  termWidth = process.stdout.columns || 80;
-  termHeight = process.stdout.rows || 24;
-  history.reset();
-  history.setMaxLen(Math.max(20, Math.min(200, termWidth - 30)));
+  if (state.running) return;
+  state.running = true;
+  state.paused = false;
+  state.detailed = !!opts2.detailed;
+  state.interval = opts2.interval;
+  if (opts2.exportDir) state.exportDir = opts2.exportDir;
+  state.termWidth = process.stdout.columns || 80;
+  state.termHeight = process.stdout.rows || 24;
+  state.history.reset();
+  state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
   process.stdout.write("\x1B[?1049h");
   process.stdout.write("\x1B[?25l");
   process.stdout.write("\x1B[2J\x1B[H");
   process.title = "pyre";
+  if (state.mouseEnabled) {
+    process.stdout.write("\x1B[?1000h");
+  }
   await tick();
   restartTicker();
   if (opts2.autoLog) startLogging();
@@ -1119,63 +1809,150 @@ async function startLive(opts2) {
   if (process.stdin.isTTY) process.stdin.setRawMode(true);
   process.stdin.resume();
   process.stdout.on("resize", onResize);
-  keypressHandler = (str, key) => {
+  state.keypressHandler = (str, key) => {
     if (!key) return;
     if (key.ctrl && key.name === "c") {
       stopLive();
       return;
     }
-    if (inputMode) {
+    if (state.inputMode) {
       handleInputModeKey(str, key);
       return;
     }
+    if (key.mouse) {
+      handleMouseClick(key.mouse);
+      return;
+    }
+    if (key.sequence && key.sequence.startsWith("\x1B[M")) {
+      handleNormalMouse(key.sequence);
+      return;
+    }
+    if (key.sequence && key.sequence.startsWith("\x1B[<")) {
+      handleSGRMouse(key.sequence);
+      return;
+    }
     switch (key.sequence) {
       case "+":
-        interval += 1;
+        state.interval += 1;
         restartTicker();
-        setStatus(`Interval set to ${interval}s`);
+        setStatus(`Interval set to ${state.interval}s`);
         return;
       case "-":
-        interval = Math.max(1, interval - 1);
+        state.interval = Math.max(1, state.interval - 1);
         restartTicker();
-        setStatus(`Interval set to ${interval}s`);
+        setStatus(`Interval set to ${state.interval}s`);
         return;
       case "/":
-        inputMode = "filter";
-        inputBuffer = processFilter;
+        state.inputMode = "filter";
+        state.inputBuffer = state.processFilter;
+        render();
+        return;
+      case "0":
+      case "1":
+      case "2":
+      case "3":
+      case "4":
+      case "5":
+      case "6":
+      case "7":
+      case "8":
+      case "9": {
+        const tabMap = {
+          "0": "disk",
+          "1": "cpu",
+          "2": "mem",
+          "3": "gpu",
+          "4": "power",
+          "5": "battery",
+          "6": "thermal",
+          "7": "network",
+          "8": "packets",
+          "9": "tasks"
+        };
+        const panelId = tabMap[key.sequence];
+        if (panelId) {
+          state.activePanel = state.activePanel === panelId ? "grid" : panelId;
+          setStatus(state.activePanel === "grid" ? "Grid view" : `${panelId} panel`);
+          render();
+        }
+        return;
+      }
+      case "P": {
+        state.activePanel = state.activePanel === "process" ? "grid" : "process";
+        setStatus(state.activePanel === "grid" ? "Grid view" : "Process panel");
         render();
         return;
+      }
     }
     switch (key.name) {
       case "q":
         stopLive();
         break;
+      case "left": {
+        const currentIdx = state.PANEL_TABS.findIndex((t) => t.id === state.activePanel);
+        if (currentIdx > 0) {
+          state.activePanel = state.PANEL_TABS[currentIdx - 1].id;
+        } else if (currentIdx === -1) {
+          state.activePanel = state.PANEL_TABS[state.PANEL_TABS.length - 1].id;
+        }
+        setStatus(`Panel: ${state.activePanel}`);
+        render();
+        break;
+      }
+      case "right": {
+        const currentIdx = state.PANEL_TABS.findIndex((t) => t.id === state.activePanel);
+        if (currentIdx < state.PANEL_TABS.length - 1) {
+          state.activePanel = state.PANEL_TABS[currentIdx + 1].id;
+        } else if (currentIdx === -1) {
+          state.activePanel = state.PANEL_TABS[0].id;
+        }
+        setStatus(`Panel: ${state.activePanel}`);
+        render();
+        break;
+      }
       case "c":
-        inputMode = "customizer";
-        customizerIndex = 0;
+        state.inputMode = "customizer";
+        state.customizerIndex = 0;
         render();
         break;
       case "p":
-        paused = !paused;
-        setStatus(paused ? "Paused" : "Resumed");
+        state.paused = !state.paused;
+        setStatus(state.paused ? "Paused" : "Resumed");
         render();
         break;
       case "g":
-        showGraphs = !showGraphs;
+        state.showGraphs = !state.showGraphs;
+        render();
+        break;
+      case "b":
+        state.graphMode = state.graphMode === "spark" ? "bar" : "spark";
+        setStatus(`Graph mode: ${state.graphMode}`);
         render();
         break;
       case "d":
-        detailed = !detailed;
-        setStatus(`Detailed sensor mode: ${detailed ? "on" : "off"}`);
+        state.detailed = !state.detailed;
+        setStatus(`Detailed sensor mode: ${state.detailed ? "on" : "off"}`);
         break;
       case "s":
-        sortMode = sortMode === "cpu" ? "mem" : sortMode === "mem" ? "pid" : "cpu";
-        setStatus(`Sorting by ${sortMode}`);
+        const sortCycle = ["cpu", "mem", "pid", "user", "command", "state", "threads", "runtime"];
+        const curIdx = sortCycle.indexOf(state.sortMode);
+        state.sortMode = sortCycle[(curIdx + 1) % sortCycle.length];
+        setStatus(`Sorting by ${state.sortMode}`);
         render();
         break;
       case "k":
-        inputMode = "kill";
-        inputBuffer = "";
+        state.inputMode = "kill";
+        state.inputBuffer = "";
+        render();
+        break;
+      case "S":
+        state.inputMode = "signal";
+        state.inputBuffer = "SIGTERM";
+        render();
+        break;
+      case "t":
+        state.treeView = !state.treeView;
+        setStatus(state.treeView ? "Tree view enabled" : "Flat view enabled");
         render();
         break;
       case "e":
@@ -1187,46 +1964,585 @@ async function startLive(opts2) {
         render();
         break;
       case "f":
-        exportFormat = exportFormat === "json" ? "csv" : exportFormat === "csv" ? "tsv" : "json";
-        setStatus(`Export format: ${exportFormat}`);
+        state.exportFormat = state.exportFormat === "json" ? "csv" : state.exportFormat === "csv" ? "tsv" : "json";
+        setStatus(`Export format: ${state.exportFormat}`);
         render();
         break;
+      case "tab":
+        cycleTab(1);
+        break;
+      case "left":
+        cycleTab(-1);
+        break;
+      case "right":
+        cycleTab(1);
+        break;
+      default:
+        if (str && str.length === 1) {
+          const tabId = tabKeyToId(str);
+          if (tabId) {
+            state.activePanel = tabId;
+            setStatus(`Panel: ${tabId.toUpperCase()}`);
+            render();
+          }
+        }
     }
   };
-  process.stdin.on("keypress", keypressHandler);
+  process.stdin.on("keypress", state.keypressHandler);
   process.once("SIGINT", () => stopLive());
 }
+function tabKeyToId(str) {
+  const map = { "1": "cpu", "2": "mem", "3": "gpu", "4": "power", "5": "battery", "6": "thermal", "7": "network", "8": "packets", "9": "tasks", "0": "disk", "p": "process" };
+  return map[str] ?? null;
+}
+function cycleTab(direction) {
+  const tabs = state.PANEL_TABS.map((t) => t.id);
+  const current = state.activePanel === "grid" ? -1 : tabs.indexOf(state.activePanel);
+  const next = (current + direction + tabs.length) % tabs.length;
+  state.activePanel = tabs[next];
+  setStatus(`Panel: ${state.activePanel.toUpperCase()}`);
+  render();
+}
+function handleNormalMouse(seq) {
+  if (seq.length < 6) return;
+  const cb = seq.charCodeAt(3) - 32;
+  const cx = seq.charCodeAt(4) - 32;
+  const cy = seq.charCodeAt(5) - 32;
+  if (cb === 0 || cb === 1) {
+    handleMouseClick(cy, cx);
+  }
+}
+function handleSGRMouse(seq) {
+  const match = seq.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+  if (!match) return;
+  const button = parseInt(match[1]);
+  const cx = parseInt(match[2]);
+  const cy = parseInt(match[3]);
+  if (button === 0 || button === 1) {
+    handleMouseClick(cy, cx);
+  }
+}
+function handleMouseClick(y, x) {
+  if (y !== TAB_BAR_ROW) return;
+  const hitboxes = getTabHitboxes();
+  const hit = hitboxes.find((h) => x >= h.start && x < h.end);
+  if (hit) {
+    state.activePanel = state.activePanel === hit.id ? "grid" : hit.id;
+    setStatus(state.activePanel === "grid" ? "Grid view" : `Panel: ${hit.id.toUpperCase()}`);
+    render();
+  }
+}
 function stopLive() {
-  if (intervalHandle) {
-    clearInterval(intervalHandle);
-    intervalHandle = null;
+  if (state.intervalHandle) {
+    clearInterval(state.intervalHandle);
+    state.intervalHandle = null;
   }
-  if (statusTimer) {
-    clearTimeout(statusTimer);
-    statusTimer = null;
+  if (state.statusTimer) {
+    clearTimeout(state.statusTimer);
+    state.statusTimer = null;
   }
-  if (logStream) {
-    logStream.end();
-    logStream = null;
+  if (state.logStream) {
+    state.logStream.end();
+    state.logStream = null;
   }
-  if (keypressHandler) {
-    process.stdin.removeListener("keypress", keypressHandler);
-    keypressHandler = null;
+  if (state.keypressHandler) {
+    process.stdin.removeListener("keypress", state.keypressHandler);
+    state.keypressHandler = null;
   }
   process.stdout.removeListener("resize", onResize);
-  running = false;
-  logging = false;
+  state.running = false;
+  state.logging = false;
   if (process.stdin.isTTY) process.stdin.setRawMode(false);
   process.stdin.pause();
+  if (state.mouseEnabled) {
+    process.stdout.write("\x1B[?1000l");
+  }
   process.stdout.write("\x1B[?25h");
   process.stdout.write("\x1B[?1049l");
   process.stdout.write("\x1B[2J\x1B[H");
   process.exit(0);
 }
 
+// src/splash.ts
+import chalk6 from "chalk";
+var MAXV = 36;
+var CHAR_RAMP = [" ", ".", "`", ",", ":", ";", "+", "*", "?", "%", "#", "@"];
+var palette = [
+  "#0a0505",
+  "#1a0806",
+  "#2a0b06",
+  "#3f1004",
+  "#591404",
+  "#791804",
+  "#9e1c04",
+  "#c92004",
+  "#d63004",
+  "#e34004",
+  "#f05004",
+  "#fd6004",
+  "#ff7004",
+  "#ff8004",
+  "#ff9004",
+  "#ffa004",
+  "#ffb004",
+  "#ffc004",
+  "#ffd004",
+  "#ffe004",
+  "#fff004",
+  "#fff820",
+  "#ffff40",
+  "#ffff60",
+  "#ffff80",
+  "#ffffa0",
+  "#ffffc0",
+  "#ffffe0",
+  "#ffffff",
+  "#ffffff",
+  "#ffffff",
+  "#ffffff",
+  "#ffffff",
+  "#ffffff",
+  "#ffffff",
+  "#ffffff"
+];
+function getRgb(hex) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return { r, g, b };
+}
+var rgbPalette = palette.map(getRgb);
+function getChar(val) {
+  const idx = Math.min(CHAR_RAMP.length - 1, Math.floor(val / (MAXV + 1) * CHAR_RAMP.length));
+  return CHAR_RAMP[idx];
+}
+async function showSplash() {
+  const cols = 60;
+  const rows = 15;
+  let fire = new Uint8Array(cols * rows);
+  process.stdout.write("\x1B[2J");
+  const termRows = process.stdout.rows || 24;
+  const termCols = process.stdout.columns || 80;
+  const startRow = Math.max(0, Math.floor((termRows - rows) / 2));
+  const startCol = Math.max(0, Math.floor((termCols - cols) / 2));
+  return new Promise((resolve) => {
+    const interval = setInterval(() => {
+      for (let x = 0; x < cols; x++) {
+        fire[(rows - 1) * cols + x] = MAXV - Math.floor(Math.random() * 4);
+      }
+      for (let y = rows - 1; y >= 1; y--) {
+        for (let x = 0; x < cols; x++) {
+          const src = y * cols + x;
+          const val = fire[src];
+          if (val === 0) {
+            fire[(y - 1) * cols + x] = 0;
+            continue;
+          }
+          const decay = Math.floor(Math.random() * 3);
+          const drift = Math.floor(Math.random() * 3) - 1;
+          let nx = x + drift;
+          if (nx < 0) nx = 0;
+          else if (nx >= cols) nx = cols - 1;
+          fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
+        }
+      }
+      let output = "";
+      for (let i = 0; i < startRow; i++) output += "\n";
+      for (let y = 0; y < rows; y++) {
+        output += " ".repeat(startCol);
+        for (let x = 0; x < cols; x++) {
+          const v = fire[y * cols + x];
+          const color = rgbPalette[Math.min(v, rgbPalette.length - 1)];
+          output += chalk6.rgb(color.r, color.g, color.b)(getChar(v));
+        }
+        output += "\n";
+      }
+      output += " ".repeat(Math.max(0, startCol + (cols - 45) / 2)) + chalk6.bold.white("\u{1F525} pyre \u2014 system monitor (warming up sensors...)\n");
+      output += " ".repeat(Math.max(0, startCol + (cols - 25) / 2)) + chalk6.dim("[Press Enter to continue]");
+      process.stdout.write(`\x1B[H${output}`);
+    }, 65);
+    const onEnter = () => {
+      process.stdin.removeListener("data", onEnter);
+      clearInterval(interval);
+      process.stdout.write("\x1B[2J\x1B[H");
+      resolve();
+    };
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", onEnter);
+    setTimeout(onEnter, 5e3);
+  });
+}
+
+// src/p2p/server.ts
+import net from "net";
+import chalk7 from "chalk";
+
+// src/p2p/protocol.ts
+var HEADER_SIZE = 4;
+var MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+function buildMessage(kind, payload) {
+  const envelope = { kind, payload };
+  const body = Buffer.from(JSON.stringify(envelope), "utf-8");
+  const header2 = Buffer.alloc(HEADER_SIZE);
+  header2.writeUInt32BE(body.length, 0);
+  return Buffer.concat([header2, body]);
+}
+function encodeAuth(password) {
+  return buildMessage("auth", { password });
+}
+function encodeAuthOk() {
+  return buildMessage("auth-ok", { ok: true });
+}
+function encodeAuthFail(reason) {
+  return buildMessage("auth-fail", { ok: false, reason });
+}
+function encodeData(stats) {
+  return buildMessage("data", { stats });
+}
+function encodePing() {
+  return buildMessage("ping", { ts: Date.now() });
+}
+function encodePong(ts) {
+  return buildMessage("pong", { ts });
+}
+function encodeDisconnect(reason) {
+  return buildMessage("disconnect", { reason });
+}
+
+// src/p2p/server.ts
+var HEADER_SIZE2 = 4;
+function readMessageFromPeer(peer) {
+  while (peer.readBuffer.length > 0) {
+    if (peer.readExpectingHeader) {
+      if (peer.readBuffer.length >= HEADER_SIZE2) {
+        peer.readMessageLength = peer.readBuffer.readUInt32BE(0);
+        peer.readBuffer = peer.readBuffer.subarray(HEADER_SIZE2);
+        peer.readExpectingHeader = false;
+      } else {
+        break;
+      }
+    }
+    if (!peer.readExpectingHeader) {
+      if (peer.readBuffer.length >= peer.readMessageLength) {
+        const body = peer.readBuffer.subarray(0, peer.readMessageLength);
+        peer.readBuffer = peer.readBuffer.subarray(peer.readMessageLength);
+        peer.readExpectingHeader = true;
+        return body;
+      } else {
+        break;
+      }
+    }
+  }
+  return null;
+}
+var P2PServer = class {
+  server = null;
+  peers = /* @__PURE__ */ new Map();
+  options;
+  running = false;
+  constructor(options) {
+    this.options = options;
+  }
+  get info() {
+    return {
+      host: this.options.host,
+      port: this.options.port,
+      peersConnected: this.peers.size
+    };
+  }
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server = net.createServer((socket) => this.onConnection(socket));
+      this.server.on("error", (err) => reject(err));
+      this.server.listen(this.options.port, this.options.host, () => {
+        this.running = true;
+        const addr = this.server?.address();
+        const bound = addr ? typeof addr === "object" ? `${addr.address}:${addr.port}` : String(addr) : "unknown";
+        console.log(chalk7.green(`P2P server listening on ${bound}`));
+        console.log(chalk7.dim(`  Password: ${this.options.password}`));
+        console.log(chalk7.dim(`  Interval: ${this.options.intervalMs}ms`));
+        resolve();
+      });
+    });
+  }
+  stop() {
+    this.running = false;
+    for (const peer of this.peers.values()) {
+      this.disconnectPeer(peer, "Server shutting down");
+    }
+    this.peers.clear();
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+  }
+  onConnection(socket) {
+    const peer = {
+      socket,
+      authenticated: false,
+      intervalHandle: null,
+      pingHandle: null,
+      readBuffer: Buffer.alloc(0),
+      readExpectingHeader: true,
+      readMessageLength: 0
+    };
+    this.peers.set(socket, peer);
+    const remoteAddr = socket.remoteAddress ? `${socket.remoteAddress}:${socket.remotePort}` : "unknown";
+    console.log(chalk7.cyan(`Peer connected: ${remoteAddr}`));
+    socket.on("data", (data) => this.onData(peer, data));
+    socket.on("close", () => this.onPeerClose(peer));
+    socket.on("error", (err) => this.onPeerError(peer, err));
+    socket.setTimeout(3e4);
+    socket.on("timeout", () => {
+      if (!peer.authenticated) {
+        this.disconnectPeer(peer, "Authentication timeout");
+      }
+    });
+  }
+  onData(peer, data) {
+    peer.readBuffer = Buffer.concat([peer.readBuffer, data]);
+    if (!peer.authenticated) {
+      const body = readMessageFromPeer(peer);
+      if (body) {
+        this.handleAuthMessage(peer, body);
+      }
+      return;
+    }
+  }
+  handleAuthMessage(peer, body) {
+    try {
+      const msg = JSON.parse(body.toString("utf-8"));
+      if (msg.kind === "auth" && typeof msg.payload?.password === "string") {
+        if (msg.payload.password === this.options.password) {
+          peer.authenticated = true;
+          peer.socket.write(encodeAuthOk());
+          console.log(chalk7.green(`Peer authenticated: ${peer.socket.remoteAddress}`));
+          this.startDataStream(peer);
+          this.startPing(peer);
+        } else {
+          peer.socket.write(encodeAuthFail("Invalid password"));
+          this.disconnectPeer(peer, "Authentication failed");
+        }
+      } else {
+        peer.socket.write(encodeAuthFail("Expected auth message first"));
+        this.disconnectPeer(peer, "Expected auth message");
+      }
+    } catch {
+      peer.socket.write(encodeAuthFail("Invalid message format"));
+      this.disconnectPeer(peer, "Invalid message format");
+    }
+  }
+  startDataStream(peer) {
+    const send = async () => {
+      if (!peer.authenticated || peer.socket.destroyed) return;
+      try {
+        const data = await collectAll({ detailed: this.options.detailed });
+        peer.socket.write(encodeData(data));
+      } catch {
+      }
+    };
+    send();
+    peer.intervalHandle = setInterval(send, this.options.intervalMs);
+  }
+  startPing(peer) {
+    peer.pingHandle = setInterval(() => {
+      if (peer.socket.destroyed) return;
+      peer.socket.write(encodePing());
+    }, 5e3);
+  }
+  onPeerClose(peer) {
+    this.cleanupPeer(peer);
+    console.log(chalk7.yellow(`Peer disconnected: ${peer.socket.remoteAddress}`));
+  }
+  onPeerError(peer, err) {
+    const code = err.code;
+    if (code === "ECONNRESET") {
+      console.log(chalk7.yellow(`Peer connection reset: ${peer.socket.remoteAddress}`));
+    } else {
+      console.log(chalk7.red(`Peer error: ${err.message}`));
+    }
+    this.cleanupPeer(peer);
+  }
+  disconnectPeer(peer, reason) {
+    try {
+      peer.socket.write(encodeDisconnect(reason));
+    } catch {
+    }
+    peer.socket.destroy();
+  }
+  cleanupPeer(peer) {
+    if (peer.intervalHandle) {
+      clearInterval(peer.intervalHandle);
+      peer.intervalHandle = null;
+    }
+    if (peer.pingHandle) {
+      clearInterval(peer.pingHandle);
+      peer.pingHandle = null;
+    }
+    this.peers.delete(peer.socket);
+  }
+};
+
+// src/p2p/client.ts
+import net2 from "net";
+var P2PClient = class {
+  socket = null;
+  options;
+  running = false;
+  readState = { buffer: Buffer.alloc(0), expectingHeader: true, messageLength: 0 };
+  onDataCallback = null;
+  onStatusCallback = null;
+  reconnectTimer = null;
+  pingHandle = null;
+  constructor(options) {
+    this.options = options;
+  }
+  setOnData(cb) {
+    this.onDataCallback = cb;
+  }
+  setOnStatus(cb) {
+    this.onStatusCallback = cb;
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.socket = new net2.Socket();
+      this.socket.on("data", (data) => this.onData(data));
+      this.socket.on("close", () => this.onClose());
+      this.socket.on("error", (err) => this.onError(err));
+      this.socket.on("timeout", () => this.onTimeout());
+      this.socket.setTimeout(1e4);
+      this.socket.connect(this.options.port, this.options.host, () => {
+        this.running = true;
+        this.socket?.setTimeout(0);
+        this.socket?.write(encodeAuth(this.options.password));
+        this.status("Connecting...");
+        resolve();
+      });
+      this.socket.once("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  disconnect() {
+    this.running = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.pingHandle) {
+      clearInterval(this.pingHandle);
+      this.pingHandle = null;
+    }
+    if (this.socket) {
+      try {
+        this.socket.write(encodeDisconnect("Client closing"));
+      } catch {
+      }
+      this.socket.destroy();
+      this.socket = null;
+    }
+    this.status("Disconnected");
+  }
+  onData(data) {
+    this.readState.buffer = Buffer.concat([this.readState.buffer, data]);
+    while (this.readState.buffer.length > 0) {
+      if (this.readState.expectingHeader) {
+        if (this.readState.buffer.length >= 4) {
+          this.readState.messageLength = this.readState.buffer.readUInt32BE(0);
+          this.readState.buffer = this.readState.buffer.subarray(4);
+          this.readState.expectingHeader = false;
+        } else {
+          break;
+        }
+      }
+      if (!this.readState.expectingHeader) {
+        if (this.readState.buffer.length >= this.readState.messageLength) {
+          const body = this.readState.buffer.subarray(0, this.readState.messageLength);
+          this.readState.buffer = this.readState.buffer.subarray(this.readState.messageLength);
+          this.readState.expectingHeader = true;
+          this.handleMessage(body);
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  handleMessage(body) {
+    try {
+      const msg = JSON.parse(body.toString("utf-8"));
+      switch (msg.kind) {
+        case "auth-ok":
+          this.status("Authenticated \u2014 receiving live data");
+          this.startPing();
+          break;
+        case "auth-fail":
+          this.status(`Authentication failed: ${msg.payload.reason}`);
+          this.disconnect();
+          break;
+        case "data":
+          if (this.onDataCallback && msg.payload?.stats) {
+            this.onDataCallback(msg.payload.stats);
+          }
+          break;
+        case "ping":
+          if (this.socket && !this.socket.destroyed) {
+            const ts = msg.payload.ts;
+            this.socket.write(encodePong(ts));
+          }
+          break;
+        case "pong":
+          break;
+        case "disconnect":
+          this.status(`Server disconnected: ${msg.payload.reason}`);
+          this.disconnect();
+          break;
+        default:
+          break;
+      }
+    } catch {
+    }
+  }
+  startPing() {
+    this.pingHandle = setInterval(() => {
+      if (this.socket && !this.socket.destroyed) {
+        this.socket.write(encodePing());
+      }
+    }, 15e3);
+  }
+  onClose() {
+    if (this.running) {
+      this.status("Connection closed \u2014 reconnecting in 3s");
+      this.reconnectTimer = setTimeout(() => {
+        if (this.running) this.connect().catch(() => {
+        });
+      }, 3e3);
+    }
+  }
+  onError(err) {
+    const code = err.code;
+    if (code === "ECONNREFUSED") {
+      this.status("Connection refused \u2014 is the server running?");
+    } else if (code === "ETIMEDOUT") {
+      this.status("Connection timed out");
+    } else {
+      this.status(`Connection error: ${err.message}`);
+    }
+  }
+  onTimeout() {
+    this.status("Connection timed out");
+    this.disconnect();
+  }
+  status(msg) {
+    if (this.onStatusCallback) {
+      this.onStatusCallback(msg);
+    }
+  }
+};
+
 // src/index.ts
 var program = new Command();
-program.name("pyre").version("1.1.0").description("Mac system monitoring CLI: interactive live dashboard, stats, graphs, export").option("-j, --json", "Output as JSON").option("-c, --csv", "Output as CSV").option("-t, --tsv", "Output as TSV").option("--detailed", "Include detailed system info and sensor readings").option("--interval <seconds>", "Refresh interval for live mode", "2").option("--once", "Show a single static snapshot instead of live feed").option("--out <file>", "Also write the snapshot output to a file (--once/--json/--csv/--tsv modes)").option("--export-dir <dir>", "Directory used for live-mode snapshot exports and logs", "./pyre-exports").option("--log", "Start continuous CSV logging immediately when live mode starts");
+program.name("pyre").version("2.0.0").description("Mac system monitoring CLI: interactive live dashboard, stats, graphs, export, packet monitor, battery predictor").option("-j, --json", "Output as JSON").option("-c, --csv", "Output as CSV").option("-t, --tsv", "Output as TSV").option("--detailed", "Include detailed system info and sensor readings").option("--interval <seconds>", "Refresh interval for live mode", "2").option("--once", "Show a single static snapshot instead of live feed").option("--out <file>", "Also write the snapshot output to a file (--once/--json/--csv/--tsv modes)").option("--export-dir <dir>", "Directory used for live-mode snapshot exports and logs", "./pyre-exports").option("--log", "Start continuous CSV logging immediately when live mode starts").option("--tree", "Show process tree view instead of flat list").option("--sort <key>", "Sort processes by: cpu, mem, pid, user, command, state, threads, runtime", "cpu").option("--packets", "Include packet monitor panel in output").option("--limit <n>", "Max number of processes to include in --once/--json/--csv/--tsv snapshots (0 = all)", "10").option("--p2p-host <host>", "P2P host address (server: bind address, client: server address)", "0.0.0.0").option("--p2p-port <port>", "P2P port number", "9876").option("--p2p-password <password>", "Password for P2P authentication");
 program.parse(process.argv);
 var opts = program.opts();
 function isExportMode() {
@@ -1236,32 +2552,129 @@ function stripAnsi(s) {
   return s.replace(/\x1b\[[0-9;]*m/g, "");
 }
 async function main() {
-  const requestedLive = program.args[0] === "live" || !isExportMode() && !opts.once;
-  if (requestedLive) {
-    const interval2 = parseFloat(opts.interval) || 2;
+  const cmd = program.args[0];
+  if (cmd === "live" || !isExportMode() && !opts.once && cmd !== "p2p") {
+    if (cmd === "live") {
+      program.args.shift();
+    }
+    await showSplash();
+    const interval = parseFloat(opts.interval) || 2;
     await startLive({
-      interval: interval2,
+      interval,
       detailed: opts.detailed,
       exportDir: opts.exportDir,
       autoLog: opts.log
     });
     return;
   }
-  const data = await collectAll({ detailed: opts.detailed });
+  if (cmd === "p2p") {
+    const subcommand = program.args[1];
+    if (subcommand === "server") {
+      await runP2PServer();
+      return;
+    } else if (subcommand === "connect") {
+      await runP2PConnect();
+      return;
+    } else {
+      console.log(chalk8.red("Usage: pyre p2p <server|connect> [options]"));
+      process.exit(1);
+    }
+  }
+  const requestedLimit = parseInt(opts.limit, 10);
+  const processLimit = Number.isFinite(requestedLimit) && requestedLimit > 0 ? requestedLimit : void 0;
+  const data = await collectAll({ detailed: opts.detailed, processLimit });
   let output;
   if (opts.json) output = formatJson(data);
   else if (opts.csv) output = formatCsv(data);
   else if (opts.tsv) output = formatTsv(data);
-  else output = formatTable(data, { width: process.stdout.columns || 80 });
+  else output = formatTable(data, { width: process.stdout.columns || 80, sortBy: opts.sort, treeView: opts.tree, visible: { packets: opts.packets ? true : void 0 } });
   console.log(output);
   if (opts.out) {
     fs2.writeFileSync(opts.out, stripAnsi(output));
-    console.log(chalk4.dim(`
+    console.log(chalk8.dim(`
 Saved to ${opts.out}`));
   }
 }
 main().catch((err) => {
-  console.error(chalk4.red(`Error: ${err.message}`));
-  stopLive();
+  console.error(chalk8.red(`Error: ${err.message}`));
   process.exit(1);
 });
+async function runP2PServer() {
+  const host = opts.p2pHost || "0.0.0.0";
+  const port = parseInt(opts.p2pPort, 10) || 9876;
+  const password = opts.p2pPassword || "";
+  const interval = parseFloat(opts.interval) || 2;
+  const detailed = !!opts.detailed;
+  if (!password) {
+    console.log(chalk8.red("Error: a password is required for P2P server mode. Use --p2p-password <password>"));
+    process.exit(1);
+  }
+  const server = new P2PServer({ host, port, password, intervalMs: interval * 1e3, detailed });
+  console.log(chalk8.bold(`
+  pyre P2P Server`));
+  console.log(chalk8.dim(`  Host: ${host}`));
+  console.log(chalk8.dim(`  Port: ${port}`));
+  console.log(chalk8.dim(`  Password: ${password}`));
+  console.log(chalk8.dim(`  Interval: ${interval}s`));
+  console.log(chalk8.dim(`  Detailed: ${detailed ? "on" : "off"}`));
+  console.log(chalk8.dim(`  Waiting for peers...
+`));
+  await server.start();
+  const rl = readline2.createInterface({ input: process.stdin });
+  rl.on("line", (line) => {
+    const trimmed = line.trim().toLowerCase();
+    if (trimmed === "q" || trimmed === "quit" || trimmed === "exit") {
+      server.stop();
+      rl.close();
+      process.exit(0);
+    } else if (trimmed === "status") {
+      const info = server.info;
+      console.log(chalk8.dim(`  Peers connected: ${info.peersConnected}`));
+    }
+  });
+  process.once("SIGINT", () => {
+    server.stop();
+    rl.close();
+    process.exit(0);
+  });
+}
+async function runP2PConnect() {
+  const host = opts.p2pHost || "127.0.0.1";
+  const port = parseInt(opts.p2pPort, 10) || 9876;
+  const password = opts.p2pPassword || "";
+  if (!password) {
+    console.log(chalk8.red("Error: a password is required for P2P connect mode. Use --p2p-password <password>"));
+    process.exit(1);
+  }
+  const client = new P2PClient({ host, port, password });
+  client.setOnStatus((msg) => {
+    process.stdout.write(`\r${chalk8.dim(msg)}${" ".repeat(40)}\r`);
+  });
+  client.setOnData((data) => {
+    process.stdout.write("\x1B[2J\x1B[H");
+    console.log(chalk8.bold(`  pyre P2P Client \u2014 ${data.header.hostname}`));
+    console.log(chalk8.dim(`  ${data.timestamp}`));
+    console.log();
+    console.log(formatTable(data, {
+      width: process.stdout.columns || 80,
+      sortBy: "cpu",
+      treeView: false,
+      visible: { packets: true }
+    }));
+  });
+  console.log(chalk8.bold(`
+  pyre P2P Client`));
+  console.log(chalk8.dim(`  Connecting to ${host}:${port}...`));
+  console.log(chalk8.dim(`  Press Ctrl+C to disconnect
+`));
+  try {
+    await client.connect();
+  } catch (err) {
+    console.log(chalk8.red(`Connection failed: ${err.message}`));
+    process.exit(1);
+  }
+  process.once("SIGINT", () => {
+    client.disconnect();
+    process.exit(0);
+  });
+}