pyre-cli 1.3.0 → 1.4.0

package/dist/index.js

@@ -3,10 +3,12 @@
 // src/index.ts
 import fs2 from "fs";
 import { Command } from "commander";
-import chalk4 from "chalk";
+import chalk7 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 +17,8 @@ async function run(cmd, fallback = "") {
     return fallback;
   }
 }
+
+// src/monitors/smc.ts
 var smcCache = null;
 async function getSmcMetrics() {
   const now = Date.now();
@@ -53,9 +57,12 @@ 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
 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] = await Promise.all([
     collectCpu(),
+    collectGpu(opts2.detailed),
     collectMemory(),
     collectDisk(),
     collectBattery(),
@@ -73,6 +80,7 @@ async function collectAll(opts2 = {}) {
       uptime: system.uptime
     },
     cpu,
+    gpu,
     memory,
     disk,
     battery,
@@ -92,6 +100,48 @@ async function collectPower() {
     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;
+  }
+}
 async function collectSystem() {
   const hostname = (await run("hostname", "Mac")).trim();
   const osRaw = (await run("sw_vers -productVersion", "Unknown")).trim();
@@ -113,7 +163,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 {
     }
   }
@@ -203,7 +255,7 @@ async function collectBattery() {
     const timeMatch = raw.match(/:\s*([\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;
@@ -235,7 +287,7 @@ async function collectBattery() {
     const health = healthParts.length ? healthParts.join(", ") : "unknown";
     return {
       level,
-      state,
+      state: state2,
       timeRemaining,
       health,
       powerSource: powerPlugged ? "AC" : "Battery",
@@ -247,36 +299,36 @@ async function collectBattery() {
     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 +337,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 +346,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 {
@@ -348,41 +400,30 @@ async function collectNetwork() {
 }
 async function collectProcesses(limit = 10) {
   try {
-    const raw = (await run(`ps -Ao pid,user,pcpu,pmem,comm -r | head -n ${limit + 1}`)).trim();
+    const raw = (await run(`ps -Ao pid,ppid,user,pcpu,pmem,state,threads,time,comm -r | 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+(.+)/);
+      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("");
-}
+// src/formatters/render.ts
+import chalk3 from "chalk";
 
-// src/formatters.ts
+// 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 +436,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 +449,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 +462,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 +470,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 +516,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 +543,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 +584,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,11 +593,22 @@ 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 = [];
@@ -553,7 +623,8 @@ 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}%`)));
@@ -576,42 +647,99 @@ 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 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))];
 }
 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);
@@ -637,6 +765,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 });
@@ -668,14 +800,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,7 +864,7 @@ 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)],
@@ -713,62 +880,109 @@ function formatCsv(data) {
     ["system", "uptime", data.header.uptime],
     ["system", "timestamp", data.timestamp]
   ];
+  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));
+  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 = [];
   lastRxBytes = 0;
   lastTxBytes = 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;
@@ -786,21 +1000,28 @@ var History = class {
     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);
   }
+  /** Clear all rolling windows and reset cumulative byte counters. */
   reset() {
     this.cpuUsage = [];
     this.memUsage = [];
     this.temp = [];
     this.netRxRate = [];
     this.netTxRate = [];
+    this.gpuUtil = [];
     this.lastRxBytes = 0;
     this.lastTxBytes = 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]) {
       while (arr.length > this.maxLen) arr.shift();
     }
   }
@@ -810,62 +1031,73 @@ 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,
+    power: true,
+    battery: true,
+    thermal: true,
+    network: 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 Power",
+    "Toggle Battery",
+    "Toggle Thermal",
+    "Toggle Network",
+    "Toggle Disk",
+    "Toggle Processes",
+    "Toggle Tree View"
+  ],
+  CPU_ALERT_PCT: 90,
+  TEMP_ALERT_C: 95,
+  alerted: false
 };
-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 +1105,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 +1121,101 @@ 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,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(
+  state.logStream.write(
     `${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${data.thermal.state}
 `
   );
 }
+
+// src/live/render.ts
+import chalk5 from "chalk";
 function processRowBudget() {
-  const columns = gridColumns(termWidth);
+  const columns = gridColumns(state.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 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
     })
   );
-  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,137 +1224,164 @@ 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"],
+    ["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"));
   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
+    });
+    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");
@@ -1119,30 +1393,30 @@ 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;
     }
     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;
     }
@@ -1151,31 +1425,48 @@ async function startLive(opts2) {
         stopLive();
         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,35 +1478,35 @@ 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;
     }
   };
-  process.stdin.on("keypress", keypressHandler);
+  process.stdin.on("keypress", state.keypressHandler);
   process.once("SIGINT", () => stopLive());
 }
 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();
   process.stdout.write("\x1B[?25h");
@@ -1224,9 +1515,120 @@ function stopLive() {
   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/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").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");
 program.parse(process.argv);
 var opts = program.opts();
 function isExportMode() {
@@ -1238,9 +1640,10 @@ function stripAnsi(s) {
 async function main() {
   const requestedLive = program.args[0] === "live" || !isExportMode() && !opts.once;
   if (requestedLive) {
-    const interval2 = parseFloat(opts.interval) || 2;
+    await showSplash();
+    const interval = parseFloat(opts.interval) || 2;
     await startLive({
-      interval: interval2,
+      interval,
       detailed: opts.detailed,
       exportDir: opts.exportDir,
       autoLog: opts.log
@@ -1252,16 +1655,16 @@ async function main() {
   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 });
   console.log(output);
   if (opts.out) {
     fs2.writeFileSync(opts.out, stripAnsi(output));
-    console.log(chalk4.dim(`
+    console.log(chalk7.dim(`
 Saved to ${opts.out}`));
   }
 }
 main().catch((err) => {
-  console.error(chalk4.red(`Error: ${err.message}`));
+  console.error(chalk7.red(`Error: ${err.message}`));
   stopLive();
   process.exit(1);
 });