pyre-cli 9.5.1 → 10.0.0

package/src/formatters/index.ts

@@ -15,4 +15,4 @@ export { formatTable, clampWidth, gridColumns, thermalColor, capacityColor, getT
 export { formatJson, formatCsv, formatTsv, formatGraphs, formatHtml, formatMarkdown } from './output.js';
 export { getDashboardHtml } from './html_template.js';
 export type { ThemeName, ThemeColors, VisibleItems, TableOptions, AnomalyAlert } from './types.js';
-export { THEMES } from './themes.js';
+export { THEMES } from './themes.js';

package/src/formatters/output.ts

@@ -111,21 +111,38 @@ export function formatHtml(data: StatsData): string {
 <table>
   ${rows([
     { label: 'Interface', value: `${data.network.interface} (${data.network.ip})` },
-    { label: 'RX', value: `${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt` },
-    { label: 'TX', value: `${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt` },
+    { label: 'RX', value: `${formatBytes(data.network.rxBytes)} · ${formatBytes(data.network.rxRate)}/s` },
+    { label: 'TX', value: `${formatBytes(data.network.txBytes)} · ${formatBytes(data.network.txRate)}/s` },
+    ...(data.network.protocols ? [
+      { label: 'TCP', value: `${data.network.protocols.tcp.connections} conns` },
+      { label: 'UDP', value: `${data.network.protocols.udp.connections} conns` },
+    ] : []),
+    ...(data.network.connectionStates ? [
+      { label: 'Active', value: `${data.network.connectionStates.established} ESTABLISHED` },
+      { label: 'Listening', value: `${data.network.connectionStates.listening}` },
+    ] : []),
+    ...(data.network.listeningPorts && data.network.listeningPorts.length ? [
+      { label: 'Ports', value: data.network.listeningPorts.slice(0, 8).join(', ') },
+    ] : []),
   ]).trim()}
 </table>`);
 
   if (data.packets) {
-    sections.push(`<h2>Packets</h2>
-<table>
-  ${rows([
-    { label: 'Total', value: `${data.packets.totalPackets} pkt` },
-    { label: 'RX', value: `${data.packets.rxPackets} pkt` },
-    { label: 'TX', value: `${data.packets.txPackets} pkt` },
-    { label: 'Connections', value: `${data.packets.connections} TCP` },
-  ]).trim()}
-</table>`);
+    const packetRows: { label: string; value: string }[] = [
+      { label: 'Total', value: `${data.packets.totalPackets} pkt` },
+      { label: 'RX', value: `${data.packets.rxPackets} pkt` },
+      { label: 'TX', value: `${data.packets.txPackets} pkt` },
+      { label: 'Connections', value: `${data.packets.connections} TCP` },
+    ];
+    if (data.packets.protocolStats) {
+      packetRows.push({ label: 'TCP', value: `${data.packets.protocolStats.tcp.connections} conns` });
+      packetRows.push({ label: 'UDP', value: `${data.packets.protocolStats.udp.connections} conns` });
+    }
+    if (data.packets.connectionStates) {
+      packetRows.push({ label: 'ESTABLISHED', value: `${data.packets.connectionStates.established}` });
+      packetRows.push({ label: 'LISTENING', value: `${data.packets.connectionStates.listening}` });
+    }
+    sections.push(`<h2>Packets</h2>\n<table>\n  ${rows(packetRows).trim()}\n</table>`);
   }
 
   if (data.tasks.length) {
@@ -152,6 +169,14 @@ export function formatHtml(data: StatsData): string {
     sections.push(`<h2>Processes</h2>\n<table>\n  ${rows(procRows).trim()}\n</table>`);
   }
 
+  if (data.blenderRenders && data.blenderRenders.length) {
+    const blenderRows = data.blenderRenders.map(r => ({
+      label: `PID ${r.pid}`,
+      value: `${r.blendFile} · ${r.renderEngine} · ${r.currentFrame}/${r.totalFrames} frames · ${r.completionPercent}% · ${r.status} · ${r.elapsedSec}s`,
+    }));
+    sections.push(`<h2>Blender Renders</h2>\n<table>\n  ${rows(blenderRows).trim()}\n</table>`);
+  }
+
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -380,8 +405,19 @@ export function formatMarkdown(data: StatsData): string {
   lines.push('| Property | Value |');
   lines.push('|---|---|');
   lines.push(`| Interface | ${mdCell(`${data.network.interface} (${data.network.ip})`)} |`);
-  lines.push(`| RX | ${mdCell(`${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt`)} |`);
-  lines.push(`| TX | ${mdCell(`${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt`)} |`);
+  lines.push(`| RX | ${mdCell(`${formatBytes(data.network.rxBytes)} · ${formatBytes(data.network.rxRate)}/s`)} |`);
+  lines.push(`| TX | ${mdCell(`${formatBytes(data.network.txBytes)} · ${formatBytes(data.network.txRate)}/s`)} |`);
+  if (data.network.protocols) {
+    lines.push(`| TCP | ${mdCell(`${data.network.protocols.tcp.connections} conns`)} |`);
+    lines.push(`| UDP | ${mdCell(`${data.network.protocols.udp.connections} conns`)} |`);
+  }
+  if (data.network.connectionStates) {
+    lines.push(`| Active | ${mdCell(`${data.network.connectionStates.established} ESTABLISHED`)} |`);
+    lines.push(`| Listening | ${mdCell(`${data.network.connectionStates.listening}`)} |`);
+  }
+  if (data.network.listeningPorts && data.network.listeningPorts.length) {
+    lines.push(`| Ports | ${mdCell(data.network.listeningPorts.slice(0, 8).join(', '))} |`);
+  }
   lines.push('');
 
   if (data.packets) {
@@ -393,6 +429,14 @@ export function formatMarkdown(data: StatsData): string {
     lines.push(`| RX | ${mdCell(`${data.packets.rxPackets} pkt`)} |`);
     lines.push(`| TX | ${mdCell(`${data.packets.txPackets} pkt`)} |`);
     lines.push(`| Connections | ${mdCell(`${data.packets.connections} TCP`)} |`);
+    if (data.packets.protocolStats) {
+      lines.push(`| TCP | ${mdCell(`${data.packets.protocolStats.tcp.connections} conns`)} |`);
+      lines.push(`| UDP | ${mdCell(`${data.packets.protocolStats.udp.connections} conns`)} |`);
+    }
+    if (data.packets.connectionStates) {
+      lines.push(`| ESTABLISHED | ${mdCell(`${data.packets.connectionStates.established}`)} |`);
+      lines.push(`| LISTENING | ${mdCell(`${data.packets.connectionStates.listening}`)} |`);
+    }
     lines.push('');
   }
 
@@ -429,6 +473,17 @@ export function formatMarkdown(data: StatsData): string {
     lines.push('');
   }
 
+  if (data.blenderRenders && data.blenderRenders.length) {
+    lines.push('## Blender Renders');
+    lines.push('');
+    lines.push('| PID | Blend File | Engine | Frames | Completion | Status | Elapsed |');
+    lines.push('|---|---|---|---|---|---|---|');
+    for (const r of data.blenderRenders) {
+      lines.push(`| ${r.pid} | ${mdCell(r.blendFile)} | ${mdCell(r.renderEngine)} | ${r.currentFrame}/${r.totalFrames} | ${r.completionPercent}% | ${r.status} | ${r.elapsedSec}s |`);
+    }
+    lines.push('');
+  }
+
   return lines.join('\n');
 }
 
@@ -465,9 +520,16 @@ export function formatCsv(data: StatsData): string {
     ['thermal', 'cpuTempF', data.thermal.temperatures?.cpu_die != null ? String(celsiusToFahrenheit(data.thermal.temperatures.cpu_die)) : ''],
     ['network', 'rxBytes', String(data.network.rxBytes)],
     ['network', 'txBytes', String(data.network.txBytes)],
+    ['network', 'rxRate', String(data.network.rxRate)],
+    ['network', 'txRate', String(data.network.txRate)],
     ['network', 'rxPackets', String(data.network.rxPackets)],
     ['network', 'txPackets', String(data.network.txPackets)],
     ['network', 'connections', data.network.connections ? String(data.network.connections) : ''],
+    ['network', 'tcpConns', data.network.protocols ? String(data.network.protocols.tcp.connections) : ''],
+    ['network', 'udpConns', data.network.protocols ? String(data.network.protocols.udp.connections) : ''],
+    ['network', 'established', data.network.connectionStates ? String(data.network.connectionStates.established) : ''],
+    ['network', 'listening', data.network.connectionStates ? String(data.network.connectionStates.listening) : ''],
+    ['network', 'listeningPorts', data.network.listeningPorts ? data.network.listeningPorts.slice(0, 10).join(';') : ''],
     ['battery', 'level', data.battery ? String(data.battery.level) : ''],
     ['battery', 'powerSource', data.battery ? data.battery.powerSource : ''],
     ['battery', 'condition', data.battery?.condition ?? ''],
@@ -492,6 +554,16 @@ export function formatCsv(data: StatsData): string {
     rows.push(['packets', 'rxPackets', String(data.packets.rxPackets)]);
     rows.push(['packets', 'txPackets', String(data.packets.txPackets)]);
     rows.push(['packets', 'connections', String(data.packets.connections)]);
+    if (data.packets.protocolStats) {
+      rows.push(['packets', 'tcpConns', String(data.packets.protocolStats.tcp.connections)]);
+      rows.push(['packets', 'udpConns', String(data.packets.protocolStats.udp.connections)]);
+    }
+    if (data.packets.connectionStates) {
+      rows.push(['packets', 'established', String(data.packets.connectionStates.established)]);
+      rows.push(['packets', 'listening', String(data.packets.connectionStates.listening)]);
+      rows.push(['packets', 'timeWait', String(data.packets.connectionStates.timeWait)]);
+      rows.push(['packets', 'closeWait', String(data.packets.connectionStates.closeWait)]);
+    }
     for (const iface of data.packets.interfaces || []) {
       rows.push(['packets_iface', iface.iface, `${iface.rxPackets},${iface.txPackets},${iface.rxBytes},${iface.txBytes}`]);
     }
@@ -519,6 +591,21 @@ export function formatCsv(data: StatsData): string {
    rows.push(['process', `runtime=${p.pid}`, String(p.runtime)]);
    rows.push(['process', `command=${p.pid}`, p.command]);
  }
+
+ for (const r of data.blenderRenders || []) {
+   rows.push(['blender', `pid=${r.pid}`, `${r.pid}`]);
+   rows.push(['blender', `blend_file=${r.pid}`, r.blendFile]);
+   rows.push(['blender', `engine=${r.pid}`, r.renderEngine]);
+   rows.push(['blender', `frame_start=${r.pid}`, String(r.frameStart)]);
+   rows.push(['blender', `frame_end=${r.pid}`, String(r.frameEnd)]);
+   rows.push(['blender', `current_frame=${r.pid}`, String(r.currentFrame)]);
+   rows.push(['blender', `total_frames=${r.pid}`, String(r.totalFrames)]);
+   rows.push(['blender', `completion_pct=${r.pid}`, String(r.completionPercent)]);
+   rows.push(['blender', `status=${r.pid}`, r.status]);
+   rows.push(['blender', `elapsed_sec=${r.pid}`, String(r.elapsedSec)]);
+   rows.push(['blender', `output_path=${r.pid}`, r.outputPath]);
+   if (r.sampleCount !== undefined) rows.push(['blender', `samples=${r.pid}`, String(r.sampleCount)]);
+ }
  return rows.map(r => r.map(item => `"${String(item).replace(/"/g, '""')}"`).join(',')).join('\n');
 }
 

package/src/formatters/render.ts

@@ -13,7 +13,9 @@ import chalk from 'chalk';
 import { sparkline, multiRowSparkline, brailleGraph, multiRowBrailleGraph } from '../sparkline.js';
 import type { History } from '../history.js';
 import type { StatsData, VisibleItems, TableOptions, AnomalyAlert } from './types.js';
+import type { BlenderRenderData } from '../monitors/types.js';
 import { THEMES, type ThemeName, type ThemeColors } from './themes.js';
+import { explainAnomaliesLocally } from '../ai/models.js';
 
 
 // --- low-level box drawing ---------------------------------------------------
@@ -313,8 +315,17 @@ function batteryCard(data: StatsData, contentWidth: number): string[] | null {
   if (data.battery.estimatedTimeToEmpty && data.battery.state !== 'charged') {
     lines.push(statRow('Est. Empty', data.battery.estimatedTimeToEmpty));
   }
-  if (data.battery.dischargeRatePerHour !== undefined && data.battery.state !== 'charged') {
-    lines.push(statRow('Disch. Rate', `${data.battery.dischargeRatePerHour}%/h`));
+  if (data.battery.powerWatts !== undefined && data.battery.powerWatts > 0 && data.battery.state !== 'charged') {
+    lines.push(statRow('Power Draw', `${data.battery.powerWatts.toFixed(2)} W`));
+  }
+  if (data.battery.smartPrediction) {
+    const sp = data.battery.smartPrediction;
+    lines.push('');
+    lines.push(chalk.bold('SMART RUNTIME FORECAST:'));
+    lines.push(statRow('Light Load', `${chalk.green(sp.scenarios.idle.timeRemaining)}  (~${sp.scenarios.idle.ratePerHour}%/h)`));
+    lines.push(statRow('Current Load', `${chalk.yellow(sp.scenarios.current.timeRemaining)}  (~${sp.scenarios.current.ratePerHour}%/h)`));
+    lines.push(statRow('Heavy Load', `${chalk.red(sp.scenarios.heavy.timeRemaining)}  (~${sp.scenarios.heavy.ratePerHour}%/h)`));
+    lines.push(chalk.dim(`Advice: ${sp.recommendation}`));
   }
   return lines;
 }
@@ -333,11 +344,102 @@ function thermalCard(data: StatsData, contentWidth: number): string[] {
 
 function networkCard(data: StatsData, contentWidth: number): string[] {
   const valW = Math.max(6, contentWidth - 8);
-  return [
-    statRow('Iface', truncatePlain(`${data.network.interface} (${data.network.ip})`, valW)),
-    statRow('RX', `${formatBytes(data.network.rxBytes)} / ${data.network.rxPackets} pkt`),
-    statRow('TX', `${formatBytes(data.network.txBytes)} / ${data.network.txPackets} pkt`),
-  ];
+  const lines: string[] = [];
+  lines.push(statRow('Iface', truncatePlain(`${data.network.interface} (${data.network.ip})`, valW)));
+  const rxTotal = formatBytes(data.network.rxBytes);
+  const txTotal = formatBytes(data.network.txBytes);
+  const rxRateStr = formatBytes(data.network.rxRate);
+  const txRateStr = formatBytes(data.network.txRate);
+  lines.push(statRow('RX', `${rxTotal} · ${rxRateStr}/s`));
+  lines.push(statRow('TX', `${txTotal} · ${txRateStr}/s`));
+  
+  const totalBytes = data.network.rxBytes + data.network.txBytes;
+  if (totalBytes > 0) {
+    const rxPct = Math.round((data.network.rxBytes / totalBytes) * 100);
+    const barW = Math.max(4, contentWidth - 20);
+    const rxBar = gaugeBar(rxPct, barW);
+    lines.push(statRow('RX/TX', `${rxBar} ${rxPct}%`));
+  }
+  
+  if (data.network.protocols) {
+    const p = data.network.protocols;
+    const totalConns = (p.tcp.connections || 0) + (p.udp.connections || 0);
+    if (totalConns > 0) {
+      const tcpPct = Math.round((p.tcp.connections / totalConns) * 100);
+      lines.push(statRow('TCP', `${p.tcp.connections} conns · ${gaugeBar(tcpPct, Math.max(4, contentWidth - 20))} ${tcpPct}%`));
+      lines.push(statRow('UDP', `${p.udp.connections} conns`));
+    }
+  }
+  if (data.network.connectionStates) {
+    const cs = data.network.connectionStates;
+    const total = cs.established + cs.listening + cs.timeWait + cs.closeWait + cs.other;
+    if (total > 0) {
+      const estPct = Math.round((cs.established / total) * 100);
+      lines.push(statRow('Active', `${cs.established} ESTABLISHED · ${estPct}%`));
+      lines.push(statRow('Listen', `${cs.listening} LISTEN`));
+      if (cs.timeWait > 0) lines.push(statRow('TimeWait', `${cs.timeWait}`));
+      if (cs.closeWait > 0) lines.push(statRow('CloseWait', `${cs.closeWait}`));
+    }
+  }
+  if (data.network.listeningPorts && data.network.listeningPorts.length > 0) {
+    const ports = data.network.listeningPorts.slice(0, 8).join(', ');
+    lines.push(statRow('Ports', truncatePlain(ports, valW)));
+  }
+  if (data.network.topRemoteHosts && data.network.topRemoteHosts.length > 0) {
+    for (const host of data.network.topRemoteHosts.slice(0, 3)) {
+      lines.push(statRow('Host', truncatePlain(`${host.host} (${host.connectionCount})`, valW)));
+    }
+  }
+  return lines;
+}
+
+function networkDetailCard(data: StatsData, width: number, theme: ThemeColors): string[] {
+  const contentWidth = width - 4;
+  const lines = networkCard(data, contentWidth);
+  
+  if (data.packets && data.packets.allProcesses && data.packets.allProcesses.length > 0) {
+    lines.push('');
+    lines.push(chalk.bold('PROCESSES & BANDWIDTH USAGE:'));
+    lines.push(chalk.dim('─'.repeat(contentWidth)));
+    
+    const pWidth = 8;
+    const rxWidth = 12;
+    const txWidth = 12;
+    const totalWidth = 12;
+    const cmdWidth = Math.max(15, contentWidth - (pWidth + rxWidth + txWidth + totalWidth + 4 * 2));
+    
+    lines.push(
+      chalk.bold('PID'.padEnd(pWidth)) + '  ' +
+      chalk.bold('COMMAND'.padEnd(cmdWidth)) + '  ' +
+      chalk.bold('RX'.padStart(rxWidth)) + '  ' +
+      chalk.bold('TX'.padStart(txWidth)) + '  ' +
+      chalk.bold('TOTAL'.padStart(totalWidth))
+    );
+    
+    const sorted = [...data.packets.allProcesses]
+      .sort((a, b) => (b.rxBytes + b.txBytes) - (a.rxBytes + a.txBytes));
+      
+    for (const proc of sorted) {
+      if (proc.rxBytes + proc.txBytes === 0) continue;
+      const rxStr = formatBytes(proc.rxBytes).padStart(rxWidth);
+      const txStr = formatBytes(proc.txBytes).padStart(txWidth);
+      const totalStr = formatBytes(proc.rxBytes + proc.txBytes).padStart(totalWidth);
+      const cmdStr = truncatePlain(proc.command, cmdWidth).padEnd(cmdWidth);
+      
+      lines.push(
+        chalk.cyan(proc.pid.toString().padEnd(pWidth)) + '  ' +
+        cmdStr + '  ' +
+        chalk.yellow(rxStr) + '  ' +
+        chalk.yellow(txStr) + '  ' +
+        chalk.bold(totalStr)
+      );
+    }
+  } else {
+    lines.push('');
+    lines.push(chalk.dim('No active network process data available.'));
+  }
+  
+  return lines;
 }
 
 function packetCard(data: StatsData, contentWidth: number): string[] | null {
@@ -347,8 +449,19 @@ function packetCard(data: StatsData, contentWidth: number): string[] | null {
   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.protocolStats) {
+    const ps = data.packets.protocolStats;
+    lines.push(statRow('TCP', `${ps.tcp.connections} conns`));
+    lines.push(statRow('UDP', `${ps.udp.connections} conns`));
+  }
+  if (data.packets.connectionStates) {
+    const cs = data.packets.connectionStates;
+    lines.push(statRow('ESTAB', `${cs.established}`));
+    lines.push(statRow('LISTEN', `${cs.listening}`));
+  }
   if (data.packets.topProcesses && data.packets.topProcesses.length) {
-    lines.push(statRow('Top Proc', truncatePlain(data.packets.topProcesses[0].command, contentWidth - 10)));
+    const topProc = data.packets.topProcesses[0];
+    lines.push(statRow('Top Proc', `${truncatePlain(topProc.command, contentWidth - 25)} (${formatBytes(topProc.rxBytes + topProc.txBytes)})`));
   }
   if (data.packets.allProcesses && data.packets.allProcesses.length > 1) {
     lines.push(statRow('Net Procs', `${data.packets.allProcesses.length} processes`));
@@ -392,13 +505,14 @@ export const TAB_DEFS: { id: string; label: string; key: string }[] = [
   { 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' },
+  { id: 'packets', label: 'Conns', key: '7' },
+  { id: 'tasks', label: 'Tasks', key: '8' },
+  { id: 'disk', label: 'Disk', key: '9' },
+  { id: 'process', label: 'Process', key: '0' },
   { id: 'p2p', label: 'P2P', key: 'R' },
   { id: 'anomalies', label: 'Anomalies', key: 'A' },
+  { id: 'containers', label: 'Containers', key: 'C' },
+  { id: 'blender', label: 'Blender', key: 'B' },
 ];
 
 /** The number of leading columns of indent before the tab bar's first character (see `tabBar`). */
@@ -620,6 +734,58 @@ function diskTableLines(
   return [head, borderAccent('─'.repeat(contentWidth)), ...rows];
 }
 
+function containersTableLines(
+  containers: { id: string; name: string; cpuPercent: number; memUsage: string; memPercent: number; netIO: string; blockIO: string; pids: number }[],
+  contentWidth: number,
+  borderAccent = THEMES.default.border
+): string[] {
+   const idW = 14, cpuW = 8, memW = 8, memUsgW = 20, netW = 20, blockW = 20, pidsW = 6;
+   const nameW = Math.max(10, contentWidth - idW - cpuW - memW - memUsgW - netW - blockW - pidsW - 7);
+   
+   const head =
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' CONTAINER ID ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' CPU%   ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' MEM%   ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' MEM USAGE          ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' NET I/O            ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' BLOCK I/O          ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' PIDS ') +
+     chalk.bold.hex('#f8f8f2').bgHex('#44475a')(' NAME'.padEnd(nameW + 1));
+     
+   const rows = containers.map(c => {
+     const cpuStr = pctColor(c.cpuPercent)(`${c.cpuPercent.toFixed(1)}`.padEnd(cpuW));
+     const memStr = pctColor(c.memPercent)(`${c.memPercent.toFixed(1)}`.padEnd(memW));
+     
+     return (
+       truncatePlain(c.id, idW - 1).padEnd(idW) +
+       cpuStr +
+       memStr +
+       c.memUsage.padEnd(memUsgW) +
+       c.netIO.padEnd(netW) +
+       c.blockIO.padEnd(blockW) +
+       String(c.pids).padEnd(pidsW) +
+       truncatePlain(c.name, nameW)
+     );
+   });
+   
+   return [head, borderAccent('─'.repeat(contentWidth)), ...rows];
+ }
+
+function blenderCard(renders: BlenderRenderData[], contentWidth: number, theme: ThemeColors): string[] {
+  if (!renders.length) return ['No active Blender renders detected'];
+  const lines: string[] = [];
+  for (const r of renders.slice(0, 8)) {
+    const statusColor = r.status === 'rendering' ? chalk.green : r.status === 'finalizing' ? chalk.yellow : r.status === 'loading' ? chalk.cyan : chalk.dim;
+    const pctStr = `${r.completionPercent}%`;
+    const barW = Math.max(4, contentWidth - 28);
+    const bar = gaugeBar(r.completionPercent, barW);
+    lines.push(`${theme.blender(`PID ${r.pid}`)} ${truncatePlain(r.blendFile, 18)} ${r.renderEngine}`);
+    lines.push(`  Fra ${String(r.currentFrame).padStart(4)}/${r.totalFrames}  ${bar}  ${pctStr}`);
+    lines.push(`  ${r.elapsedSec}s elapsed · ${statusColor(r.status)}${r.sampleCount !== undefined ? ` · ${r.sampleCount} spp` : ''}`);
+  }
+  return lines;
+}
+
 // --- main dashboard ------------------------------------------------------------
 
 function detailPanelTitle(panel: string, trackedPid?: number | null): string {
@@ -635,6 +801,8 @@ function detailPanelTitle(panel: string, trackedPid?: number | null): string {
     tasks: 'Tasks',
     disk: 'Disk',
     process: trackedPid !== undefined && trackedPid !== null ? `Processes (Following PID ${trackedPid})` : 'Processes',
+    containers: 'Containers',
+    blender: 'Blender Renders',
   };
   return map[panel] || panel;
 }
@@ -654,39 +822,81 @@ function activeDetailLines(data: StatsData, activePanel: string, width: number,
     }
     case 'power': {
       const power = powerCard(data);
-      if (!power && !data.battery) return ['No power data available'];
-      const lines: string[] = [];
-      if (power) lines.push(...power);
-      if (data.battery?.powerWatts !== undefined && data.battery.powerWatts > 0) {
-        lines.push(statRow('Battery', `${data.battery.powerWatts.toFixed(2)} W`));
-      }
-      return lines.length ? lines : ['No power data available'];
+      if (!power) return ['No power data available'];
+      return power;
     }
     case 'battery':
       return data.battery ? batteryCard(data, contentWidth) : ['No battery data available'];
     case 'thermal':
       return thermalCard(data, contentWidth);
     case 'network':
-      return networkCard(data, contentWidth);
+      return networkDetailCard(data, width, theme);
     case 'packets': {
-      if (!data.packets) return ['No packet data available'];
-      const lines: string[] = [];
-      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 || !data.packets.allProcesses || !data.packets.allProcesses.length) {
+        return ['No advanced network tracking data available.'];
       }
-      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)}`));
+    
+      const lines: string[] = [];
+      const pWidth = 8;
+      const cmdWidth = 15;
+      const protoWidth = 5;
+      const stateWidth = 11;
+      const rxWidth = 10;
+      const txWidth = 10;
+      
+      const remaining = Math.max(20, width - (pWidth + cmdWidth + protoWidth + stateWidth + rxWidth + txWidth + 7 * 2));
+      const localWidth = Math.floor(remaining * 0.4);
+      const remoteWidth = remaining - localWidth;
+    
+      const header = 
+        chalk.bold('PID'.padEnd(pWidth)) + '  ' +
+        chalk.bold('COMMAND'.padEnd(cmdWidth)) + '  ' +
+        chalk.bold('PROTO'.padEnd(protoWidth)) + '  ' +
+        chalk.bold('LOCAL'.padEnd(localWidth)) + '  ' +
+        chalk.bold('REMOTE'.padEnd(remoteWidth)) + '  ' +
+        chalk.bold('STATE'.padEnd(stateWidth)) + '  ' +
+        chalk.bold('RX'.padStart(rxWidth)) + '  ' +
+        chalk.bold('TX'.padStart(txWidth));
+        
+      lines.push(header);
+      lines.push(chalk.dim('─'.repeat(width)));
+    
+      for (const proc of data.packets.allProcesses) {
+        if (!proc.connections || proc.connections.length === 0) continue;
+        
+        const summaryCmd = truncatePlain(proc.command, cmdWidth + protoWidth + localWidth + remoteWidth + stateWidth + 8);
+        const summaryRx = formatBytes(proc.rxBytes).padStart(rxWidth);
+        const summaryTx = formatBytes(proc.txBytes).padStart(txWidth);
+        
+        lines.push(
+          chalk.cyan(proc.pid.toString().padEnd(pWidth)) + '  ' +
+          chalk.cyan(summaryCmd.padEnd(width - pWidth - rxWidth - txWidth - 6)) + '  ' +
+          chalk.yellow(summaryRx) + '  ' +
+          chalk.yellow(summaryTx)
+        );
+        
+        for (const conn of proc.connections) {
+          const cProto = chalk.dim(truncatePlain(conn.protocol, protoWidth).padEnd(protoWidth));
+          const cLocal = chalk.dim(truncatePlain(conn.local, localWidth).padEnd(localWidth));
+          const cRemote = truncatePlain(conn.remote, remoteWidth).padEnd(remoteWidth);
+          
+          const cStateStr = conn.state === 'Established' ? chalk.green('ESTABLISHED'.padEnd(stateWidth)) : chalk.dim(truncatePlain(conn.state, stateWidth).padEnd(stateWidth));
+          const cRx = chalk.dim(formatBytes(conn.rxBytes).padStart(rxWidth));
+          const cTx = chalk.dim(formatBytes(conn.txBytes).padStart(txWidth));
+          
+          lines.push(
+            ' '.repeat(pWidth) + '  ' +
+            ' '.repeat(cmdWidth) + '  ' +
+            cProto + '  ' +
+            cLocal + '  ' +
+            cRemote + '  ' +
+            cStateStr + '  ' +
+            cRx + '  ' +
+            cTx
+          );
         }
       }
+    
       return lines;
     }
     case 'tasks':
@@ -749,15 +959,41 @@ function activeDetailLines(data: StatsData, activePanel: string, width: number,
       const lines: string[] = [];
       // Sort by timestamp descending
       const sorted = [...opts.anomalyHistory].sort((a, b) => (b.timestamp?.getTime() || 0) - (a.timestamp?.getTime() || 0));
-      for (const a of sorted) {
+      for (const a of sorted.slice(0, 10)) {
         const color = a.severity === 'critical' ? chalk.red.bold : chalk.yellow;
         const direction = a.zScore > 0 ? '↑ spike' : '↓ drop';
         const valStr = a.metric.toLowerCase().includes('net') ? `${formatBytes(a.value)}/s` : `${a.value.toFixed(1)}%`;
         const timeStr = a.timestamp ? a.timestamp.toLocaleTimeString() : '';
         lines.push(color(` ${timeStr.padEnd(10)} ⚠ ${a.metric.padEnd(8)}: ${valStr.padEnd(12)} (${direction}, σ=${a.zScore.toFixed(1)})`));
       }
+      lines.push('');
+      // In-TUI AI Model Diagnosis section (offline, zero external server needed)
+      const modelId = opts.aiModel || 'expert-rules-v1';
+      const aiAnalysis = explainAnomaliesLocally(sorted, modelId);
+      for (const al of aiAnalysis.split('\n')) {
+        if (al.startsWith('Diagnosis Engine:')) {
+          lines.push(chalk.bold.magenta(al));
+        } else if (al.startsWith('Tip:')) {
+          lines.push(chalk.cyan.bold(al));
+        } else if (al.startsWith('  • Recommendation:')) {
+          lines.push(chalk.green(al));
+        } else if (al.startsWith('  • Cause:')) {
+          lines.push(chalk.yellow(al));
+        } else if (al.startsWith('  • Verdict:')) {
+          lines.push(chalk.dim(al));
+        } else {
+          lines.push(chalk.dim(al));
+        }
+      }
       return lines;
     }
+    case 'containers': {
+      return data.containers && data.containers.length ? containersTableLines(data.containers, width - 4, theme.border) : ['No container data available'];
+    }
+    case 'blender': {
+      const renders = data.blenderRenders && data.blenderRenders.length ? data.blenderRenders : [];
+      return blenderCard(renders, contentWidth, theme);
+    }
     default:
       return null;
   }
@@ -1034,7 +1270,7 @@ export function formatTable(data: StatsData, opts: TableOptions = {}): string {
       lines.push(gaugeRow('GPU', data.gpu.utilization, contentWidth));
     }
     const tempC = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die;
-    if (tempC !== undefined) {
+    if (tempC != null) {
       const tempStr = formatTempUnit(tempC, opts.tempUnit);
       lines.push(statRow('Temp', thermalColor(data.thermal.pressureLevel)(tempStr)));
     }

package/src/formatters/themes.ts

@@ -26,6 +26,7 @@ export interface ThemeColors {
    disk: (s: string) => string;
    graphs: (s: string) => string;
    process: (s: string) => string;
+   blender: (s: string) => string;
 }
 
 export const BUILTIN_THEMES: Record<string, ThemeColors> = {
@@ -41,6 +42,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
      disk: chalk.hex('#f472b6'),
      graphs: chalk.hex('#22d3ee'),
      process: chalk.hex('#e5e7eb'),
+     blender: chalk.hex('#f97316'),
    },
    dracula: {
      border: chalk.hex('#6272a4'),
@@ -54,6 +56,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
      disk: chalk.hex('#ff5555'),
      graphs: chalk.hex('#8be9fd'),
      process: chalk.hex('#f8f8f2'),
+     blender: chalk.hex('#ffb86c'),
    },
    cyberpunk: {
      border: chalk.hex('#ff0055'),
@@ -67,6 +70,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
      disk: chalk.hex('#ff007f'),
      graphs: chalk.hex('#00ffcc'),
      process: chalk.hex('#ffffff'),
+     blender: chalk.hex('#ff6600'),
    },
     monochrome: {
       border: chalk.gray,
@@ -80,6 +84,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
       disk: chalk.white.bold,
       graphs: chalk.white.bold,
       process: chalk.white.bold,
+      blender: chalk.white.bold,
     },
     nord: {
       border: chalk.hex('#4c566a'),
@@ -93,6 +98,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
       disk: chalk.hex('#b48ead'),
       graphs: chalk.hex('#88c0d0'),
       process: chalk.hex('#eceff4'),
+      blender: chalk.hex('#d08770'),
     },
     gruvbox: {
       border: chalk.hex('#928374'),
@@ -106,6 +112,7 @@ export const BUILTIN_THEMES: Record<string, ThemeColors> = {
       disk: chalk.hex('#d3869b'),
       graphs: chalk.hex('#fb4934'),
       process: chalk.hex('#ebdbb2'),
+      blender: chalk.hex('#fe8019'),
     },
   };
 
@@ -134,6 +141,7 @@ export function loadCustomThemes(): Record<string, ThemeColors> {
               disk: buildColor(data.disk),
               graphs: buildColor(data.graphs),
               process: buildColor(data.process),
+              blender: buildColor(data.blender),
             };
           } catch {
             // ignore bad theme file