pyre-cli 9.5.1 → 10.0.0

package/src/live/render.ts

@@ -15,6 +15,9 @@ import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel,
 import { detectAnomalies } from '../anomalies.js';
 import { state, setStatus, SIGNAL_OPTIONS, getToggleKey, MENU_OPTIONS } from './state.js';
 import type { StatsData } from '../monitors/index.js';
+import { sendAlert, type AlertChannelConfig } from '../alertChannels.js';
+import { readConfig } from '../state/config.js';
+import { AVAILABLE_AI_MODELS } from '../ai/models.js';
 
 function formatTempForUnit(c: number): string {
   if (state.tempUnit === 'f') {
@@ -61,6 +64,7 @@ function tableCacheParams(): string {
     state.history.version,
     JSON.stringify(state.visiblePanels),
     JSON.stringify(state.panelLayout),
+    state.aiModel,
   ].join('|');
 }
 
@@ -142,6 +146,11 @@ function renderCustomizerOverlay(scrollOffset: number, maxVisibleItems: number):
          lines.push(`${prefix}${opt}: ${status}`);
        } else if (opt === 'Temperature Unit') {
          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.tempUnit.toUpperCase())} [C, F]`);
+       } else if (opt === 'AI Model') {
+         const curModel = AVAILABLE_AI_MODELS.find(m => m.id === state.aiModel) || AVAILABLE_AI_MODELS[0];
+         lines.push(`${prefix}${opt}: ${chalk.bold.cyan(curModel.name)} ${chalk.dim(`[${curModel.badge}]`)}`);
+       } else if (opt === 'Grid Panel Order') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.panelLayout.join(' → '))}`);
        } else {
          const toggleKey = getToggleKey(opt);
          const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
@@ -216,6 +225,14 @@ function render() {
     writeFrame(renderCredits(cols, rows));
     return;
   }
+  if (state.inputMode === 'docker-alert') {
+    writeFrame(renderDockerAlert(cols, rows));
+    return;
+  }
+  if (state.inputMode === 'ai-model') {
+    writeFrame(renderAiModelSelector(cols, rows));
+    return;
+  }
   const lines: string[] = [];
   const theme = THEMES[state.currentTheme] || THEMES.default;
 
@@ -258,6 +275,7 @@ function render() {
             selectedProcessIndex: state.processSelectionIndex,
             trackedPid: state.trackedPid,
             inspectProcess: state.inspectingProcess,
+            aiModel: state.aiModel,
           });
           _cachedTableData = state.lastData;
           _cachedTableParams = cacheParams;
@@ -373,6 +391,7 @@ function footerLine(): string[] {
      ['f', state.exportFormat],
      ['+/-', `${state.interval}s`],
      ['r', state.p2pServerRunning ? 'stop p2p' : 'start p2p'],
+     ['m', `ai:${state.aiModel.split('-')[0]}`],
    ];
    const fmt = (list: [string, string][]) => list.map(([k, label]) => `${chalk.hex('#50fa7b').bold(k)} ${chalk.dim(label)}`).join(chalk.dim('  |  '));
    const str1 = fmt(row1);
@@ -383,6 +402,7 @@ function footerLine(): string[] {
    if (state.logging) badges.push(chalk.red.bold('● REC'));
    if (state.activePanel !== 'grid') badges.push(chalk.cyan.bold(`◉ ${state.activePanel.toUpperCase()}`));
    if (state.p2pServerRunning) badges.push(chalk.green.bold(`P2P ${state.p2pBind || '0.0.0.0'}:${state.p2pPort}`));
+   badges.push(chalk.magenta.bold(`AI:${state.aiModel}`));
    const badgeStr = badges.join('  ') || ' ';
 
    return [str1, str2, badgeStr];
@@ -454,6 +474,29 @@ function checkAlerts(data: StatsData) {
       if (state.alertCmd) {
         exec(state.alertCmd, { env: { ...process.env, PYRE_ALERT: alertMsg } }, () => {});
       }
+
+      // Multi-channel alert fan-out (Slack, Discord, Pushover, ntfy)
+      const cfg = readConfig();
+      const channelConfig: AlertChannelConfig = {
+        slackUrl: cfg.slackAlertUrl || undefined,
+        discordUrl: cfg.discordAlertUrl || undefined,
+        pushoverToken: cfg.pushoverToken || undefined,
+        pushoverUser: cfg.pushoverUser || undefined,
+        ntfyUrl: cfg.ntfyUrl || undefined,
+      };
+      const hasChannels = Object.values(channelConfig).some(v => !!v);
+      if (hasChannels) {
+        const severity = hasCriticalAnomaly ? 'critical' : 'warning';
+        sendAlert({
+          metric: reasons[0]?.split(' ')[0] ?? 'System',
+          value: data.cpu.usage,
+          threshold: state.CPU_ALERT_PCT,
+          unit: '%',
+          host: data.header.hostname,
+          timestamp: new Date().toISOString(),
+          severity,
+        }, channelConfig).catch(() => {});
+      }
     } else if (!hot && !anomalyTriggered && !watchdogTriggered) {
      state.alerted = false;
    }
@@ -564,4 +607,59 @@ function renderCredits(cols: number, rows: number): string[] {
   return out;
 }
 
+function renderDockerAlert(cols: number, rows: number): string[] {
+  const out: string[] = [];
+  const content = [
+    chalk.bold.red('Docker Container Detected'),
+    '',
+    'Pyre is running inside a container. Some hardware sensors',
+    '(battery, thermal, power) may not be available or relevant.',
+    '',
+    chalk.cyan('Do you wish to continue in Docker mode?'),
+    ''
+  ];
+  
+  const options = ['Yes, use Docker mode (hide hardware sensors)', 'No, launch regular TUI with all features'];
+  for (let i = 0; i < options.length; i++) {
+    const isSelected = i === state.dockerSelectionIndex;
+    const prefix = isSelected ? chalk.cyan.bold('  ▶ ') : '    ';
+    const text = isSelected ? chalk.bgCyan.black(` ${options[i]} `) : chalk.dim(` ${options[i]} `);
+    content.push(prefix + text);
+  }
+  
+  content.push('');
+  content.push(chalk.dim('Press ↑/↓ to select, Enter to confirm, Esc to skip.'));
+
+  out.push(...panel('DOCKER DETECTED', content, cols, chalk.red, chalk.dim, rows - 2));
+  return out;
+}
+
+function renderAiModelSelector(cols: number, rows: number): string[] {
+  const out: string[] = [];
+  const content: string[] = [
+    chalk.bold.hex('#ff6004')('Choose AI Anomaly Explanation Model'),
+    chalk.dim('Select your preferred diagnosis engine. Offline models run entirely in-process.'),
+    '',
+  ];
+
+  for (let i = 0; i < AVAILABLE_AI_MODELS.length; i++) {
+    const m = AVAILABLE_AI_MODELS[i];
+    const isSelected = i === state.modelSelectionIndex;
+    const isCurrent = m.id === state.aiModel;
+    const prefix = isSelected ? chalk.cyan.bold(' ▶ ') : '   ';
+    const curBadge = isCurrent ? chalk.bgGreen.black.bold(' ACTIVE ') : '';
+    const badgeStr = m.offline ? chalk.green(`[${m.badge}]`) : chalk.yellow(`[${m.badge}]`);
+
+    const nameStr = isSelected ? chalk.bgCyan.black.bold(` ${m.name} `) : chalk.bold.white(m.name);
+    content.push(`${prefix}${nameStr} ${badgeStr} ${curBadge}`);
+    content.push(chalk.dim(`     ${m.description}`));
+    content.push('');
+  }
+
+  content.push(chalk.dim('Use ↑/↓ or J/K to navigate · Enter/Space to select · Esc to cancel'));
+
+  out.push(...panel('AI MODEL SELECTOR', content, cols, chalk.cyan, chalk.dim, Math.max(1, rows - 2)));
+  return out;
+}
+
 export { render, footerLine, renderCustomizerOverlay, checkAlerts, processRowBudget, invalidateTableCache, invalidateFrame };

package/src/live/state.ts

@@ -23,6 +23,8 @@ export const MENU_OPTIONS = ['Resume Dashboard', 'Settings (Customizer)', 'Readm
 
 const config = readConfig();
 
+const isDockerEnv = fs.existsSync('/.dockerenv') || fs.existsSync('/run/.containerenv');
+
 const state = {
    intervalHandle: null as NodeJS.Timeout | null,
    uiIntervalHandle: null as NodeJS.Timeout | null,
@@ -37,19 +39,21 @@ const state = {
 
     exportDir: config.exportDir,
     currentTheme: config.theme as ThemeName,
-     visiblePanels: {
-       cpu: config.visiblePanels.cpu,
-       mem: config.visiblePanels.mem,
-       gpu: config.visiblePanels.gpu,
-       power: config.visiblePanels.power,
-       battery: config.visiblePanels.battery,
-       thermal: config.visiblePanels.thermal,
-       network: config.visiblePanels.network,
-       packets: config.visiblePanels.packets,
-       tasks: config.visiblePanels.tasks,
-       disk: config.visiblePanels.disk,
-       process: config.visiblePanels.process,
-     } as VisibleItems,
+      visiblePanels: {
+        cpu: config.visiblePanels.cpu,
+        mem: config.visiblePanels.mem,
+        gpu: config.visiblePanels.gpu,
+        power: config.visiblePanels.power,
+        battery: config.visiblePanels.battery,
+        thermal: config.visiblePanels.thermal,
+        network: config.visiblePanels.network,
+        packets: config.visiblePanels.packets,
+        tasks: config.visiblePanels.tasks,
+        disk: config.visiblePanels.disk,
+        process: config.visiblePanels.process,
+        containers: config.visiblePanels.containers,
+        blender: config.visiblePanels.blender,
+      } as VisibleItems,
      panelLayout: config.panelLayout || ['mem', 'disk', 'net'],
     logging: false,
     logStream: null as fs.WriteStream | null,
@@ -66,34 +70,38 @@ const state = {
     processScrollOffset: 0,
     trackedPid: null as number | null,
     inspectingProcess: null as any | null,
-    inputMode: null as InputMode,
+    inputMode: (isDockerEnv && !config.dockerModeConfirmed) ? 'docker-alert' as InputMode : null as InputMode,
     inputBuffer: '',
     targetPid: '',
     selectedSignal: 'SIGTERM' as typeof SIGNAL_OPTIONS[number],
     treeView: config.treeView,
     SIGNAL_OPTIONS,
      customizerIndex: 0,
-     CUSTOMIZER_OPTIONS: [
-       'Theme',
-       'Graph Mode',
-       'Splash Screen',
-       'Splash Color',
-       'Splash Animation',
-       'Notifications',
-       'Temperature Unit',
-       'Toggle CPU',
-       'Toggle Memory',
-       'Toggle GPU',
-       'Toggle Power',
-       'Toggle Battery',
-       'Toggle Thermal',
-       'Toggle Network',
-       'Toggle Packets',
-       'Toggle Tasks',
-       'Toggle Disk',
-       'Toggle Processes',
-       'Toggle Tree View',
-     ],
+      CUSTOMIZER_OPTIONS: [
+        'Theme',
+        'Graph Mode',
+        'Splash Screen',
+        'Splash Color',
+        'Splash Animation',
+        'Notifications',
+        'Temperature Unit',
+        'AI Model',
+        'Grid Panel Order',
+        'Toggle CPU',
+        'Toggle Memory',
+        'Toggle GPU',
+        'Toggle Power',
+        'Toggle Battery',
+        'Toggle Thermal',
+        'Toggle Network',
+        'Toggle Conns',
+        'Toggle Tasks',
+        'Toggle Disk',
+        'Toggle Processes',
+        'Toggle Containers',
+        'Toggle Blender',
+        'Toggle Tree View',
+      ],
      CPU_ALERT_PCT: config.cpuAlertPct,
      TEMP_ALERT_C: config.tempAlertC,
      watchdogProcess: config.watchdogProcess || '',
@@ -103,23 +111,25 @@ const state = {
      webhookUrl: config.webhookUrl || '',
      alertCmd: config.alertCmd || '',
       alerted: false,
-      activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies',
+       activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies' | 'containers' | 'blender',
        mouseEnabled: config.mouseEnabled,
-         PANEL_TABS: [
-           { id: 'cpu', label: 'CPU', key: '1' },
-           { id: 'mem', label: 'Memory', key: '2' },
-           { id: 'gpu', label: 'GPU', key: '3' },
-           { id: 'power', label: 'Power', key: '4' },
-           { id: 'battery', label: 'Battery', key: '5' },
-           { id: 'thermal', label: 'Thermal', key: '6' },
-           { id: 'network', label: 'Network', key: '7' },
-           { id: 'packets', label: 'Packets', key: '8' },
-           { id: 'tasks', label: 'Tasks', key: '9' },
-           { id: 'disk', label: 'Disk', key: '0' },
-           { id: 'process', label: 'Process', key: 'P' },
-           { id: 'p2p', label: 'P2P', key: 'R' },
-           { id: 'anomalies', label: 'Anomalies', key: 'A' },
-         ],
+          PANEL_TABS: [
+            { id: 'cpu', label: 'CPU', key: '1' },
+            { id: 'mem', label: 'Memory', key: '2' },
+            { id: 'gpu', label: 'GPU', key: '3' },
+            { id: 'power', label: 'Power', key: '4' },
+            { id: 'battery', label: 'Battery', key: '5' },
+            { id: 'thermal', label: 'Thermal', key: '6' },
+            { id: 'network', label: 'Network', key: '7' },
+            { id: 'packets', label: 'Conns', key: '8' },
+            { id: 'tasks', label: 'Tasks', key: '9' },
+            { id: 'disk', label: 'Disk', key: '0' },
+            { id: 'process', label: 'Process', key: 'P' },
+            { id: 'containers', label: 'Containers', key: 'C' },
+            { id: 'p2p', label: 'P2P', key: 'R' },
+            { id: 'anomalies', label: 'Anomalies', key: 'A' },
+            { id: 'blender', label: 'Blender', key: 'B' },
+          ],
          p2pServer: null as import('../p2p/server.js').P2PServer | null,
          p2pClient: null as import('../p2p/client.js').P2PClient | null,
          p2pServerRunning: false,
@@ -134,6 +144,12 @@ const state = {
         splashAnimation: config.splashAnimation as SplashAnimation,
         menuSelectionIndex: 0,
         readmeScrollOffset: 0,
+        isDocker: isDockerEnv,
+        dockerModeConfirmed: config.dockerModeConfirmed || false,
+        dockerSelectionIndex: 0,
+        aiModel: config.aiModel || 'expert-rules-v1',
+        aiBackend: config.aiBackend || 'builtin',
+        modelSelectionIndex: 0,
     };
 
 function setStatus(msg: string, ms = 3000) {
@@ -153,10 +169,12 @@ function getToggleKey(opt: string): keyof VisibleItems | null {
     'Toggle Battery': 'battery',
     'Toggle Thermal': 'thermal',
     'Toggle Network': 'network',
-    'Toggle Packets': 'packets',
+    'Toggle Conns': 'packets',
     'Toggle Tasks': 'tasks',
     'Toggle Disk': 'disk',
     'Toggle Processes': 'process',
+    'Toggle Containers': 'containers',
+    'Toggle Blender': 'blender',
     'Toggle Tree View': 'tree',
   };
   return map[opt] ?? null;

package/src/live/types.ts

@@ -20,13 +20,13 @@ export interface LiveOptions {
 
 export type ExportFormat = 'json' | 'csv' | 'tsv' | 'html' | 'md';
 
-type InputMode = null | 'filter' | 'kill' | 'signal' | 'customizer' | 'p2p' | 'menu' | 'readme' | 'credits';
+type InputMode = null | 'filter' | 'kill' | 'signal' | 'customizer' | 'p2p' | 'menu' | 'readme' | 'credits' | 'docker-alert' | 'ai-model';
 
 type SortMode = 'cpu' | 'mem' | 'pid' | 'user' | 'command' | 'state' | 'threads' | 'runtime';
 
 type GraphMode = 'spark' | 'bar';
 
-type ActivePanel = 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p';
+type ActivePanel = 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'containers' | 'anomalies' | 'blender';
 
 export type { InputMode, SortMode, GraphMode, ActivePanel, ThemeName };
 

package/src/monitors/batteryPredictor.ts

@@ -0,0 +1,143 @@
+/**
+ * Smart Battery Predictor.
+ *
+ * Predicts multi-scenario battery longevity by synthesizing:
+ * 1. Current instantaneous discharge rate and state of charge.
+ * 2. Historical discharge profiles parsed from local CSV log exports.
+ * 3. Machine load heuristics (idle vs. current compute vs. sustained high-power).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import type { BatteryData, PowerData } from './types.js';
+
+export interface BatteryPredictionScenario {
+  label: string;
+  ratePerHour: number;
+  timeRemaining: string;
+  hours: number;
+}
+
+export interface SmartBatteryPrediction {
+  currentLevel: number;
+  healthPercentage?: number;
+  cycleCount?: number;
+  powerWatts?: number;
+  scenarios: {
+    idle: BatteryPredictionScenario;
+    current: BatteryPredictionScenario;
+    heavy: BatteryPredictionScenario;
+  };
+  recommendation: string;
+  confidence: 'low' | 'medium' | 'high';
+}
+
+function formatHours(h: number): string {
+  if (!isFinite(h) || h <= 0) return 'calculating';
+  const hours = Math.floor(h);
+  const mins = Math.round((h - hours) * 60);
+  if (hours === 0 && mins === 0) return '< 1m';
+  if (hours === 0) return `${mins}m`;
+  return `${hours}h ${mins}m`;
+}
+
+export function computeSmartBatteryPrediction(
+  battery: BatteryData | null,
+  power: PowerData | null,
+  logDir: string = './pyre-exports'
+): SmartBatteryPrediction | null {
+  if (!battery) return null;
+
+  const level = battery.level;
+  const isCharging = battery.state.toLowerCase().includes('charg');
+
+  // Baseline assumption for typical MacBook battery Wh capacity
+  const assumedCapacityWh = 58;
+
+  // 1. Current discharge rate in %/hour
+  let currentRate = battery.dischargeRatePerHour || 12; // default fallback 12%/h
+  if (battery.dischargeRatePerHour === undefined && power && power.combinedWatts) {
+    currentRate = (power.combinedWatts / assumedCapacityWh) * 100;
+  }
+  currentRate = Math.max(2, Math.min(60, currentRate));
+
+  // 2. Scan historical logs for typical average discharge rate if available
+  let historicalSamples: number[] = [];
+  try {
+    if (fs.existsSync(logDir)) {
+      const files = fs.readdirSync(logDir).filter(f => f.startsWith('pyre-') && f.endsWith('.csv')).slice(-3);
+      for (const file of files) {
+        const content = fs.readFileSync(path.join(logDir, file), 'utf-8');
+        const lines = content.split('\n').slice(1);
+        for (const line of lines) {
+          const parts = line.split(',');
+          if (parts.length >= 4) {
+            const cpu = parseFloat(parts[1]);
+            if (!isNaN(cpu)) {
+              // Estimate power based on CPU history
+              const estRate = 5 + (cpu / 100) * 20;
+              historicalSamples.push(estRate);
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    // fallback
+  }
+
+  const confidence: 'low' | 'medium' | 'high' = isCharging
+    ? 'low'
+    : historicalSamples.length > 50
+    ? 'high'
+    : battery.dischargeRatePerHour ? 'medium' : 'low';
+
+  // Compute scenarios
+  // Idle load scenario (light browser/reading, ~5-7% per hour)
+  const idleRate = 6.0;
+  const idleHours = level / idleRate;
+
+  // Current load scenario
+  const currentHours = level / currentRate;
+
+  // Heavy load scenario (compiling, 3D render, gaming: ~25-35% per hour)
+  const heavyRate = Math.max(28.0, currentRate * 1.5);
+  const heavyHours = level / heavyRate;
+
+  let recommendation = 'Power consumption is normal.';
+  if (isCharging) {
+    recommendation = `Device is currently ${battery.state}. Full capacity health: ${battery.health || 'Good'}.`;
+  } else if (currentRate > 25) {
+    recommendation = 'High power drain detected. Reducing display brightness and closing heavy background processes can extend battery significantly.';
+  } else if (currentRate < 10) {
+    recommendation = 'Excellent power efficiency. Machine is running under low-drain conditions.';
+  }
+
+  return {
+    currentLevel: level,
+    healthPercentage: battery.maxCapacityPercent,
+    cycleCount: battery.cycles,
+    powerWatts: battery.powerWatts || power?.combinedWatts,
+    scenarios: {
+      idle: {
+        label: 'Light / Reading Load',
+        ratePerHour: idleRate,
+        timeRemaining: formatHours(idleHours),
+        hours: idleHours,
+      },
+      current: {
+        label: 'Current Activity',
+        ratePerHour: Math.round(currentRate * 10) / 10,
+        timeRemaining: isCharging ? 'Charging' : formatHours(currentHours),
+        hours: currentHours,
+      },
+      heavy: {
+        label: 'Sustained Heavy Compute',
+        ratePerHour: Math.round(heavyRate * 10) / 10,
+        timeRemaining: formatHours(heavyHours),
+        hours: heavyHours,
+      },
+    },
+    recommendation,
+    confidence,
+  };
+}

package/src/monitors/blender.ts

@@ -0,0 +1,144 @@
+import { run } from './run.js';
+import type { BlenderRenderData } from './types.js';
+
+const RENDER_LOG_DIR = '/tmp/blender_render_logs';
+
+function blendFileFromArgs(args: string[]): string {
+  const nonFlag = args.filter(a => !a.startsWith('-'));
+  for (const a of nonFlag) {
+    if (a.endsWith('.blend') || a.includes('.blend')) {
+      return a.split('/').pop() || a;
+    }
+  }
+  return 'unknown.blend';
+}
+
+function engineFromArgs(args: string[]): string {
+  const idx = args.indexOf('-E');
+  if (idx !== -1 && args[idx + 1]) return args[idx + 1];
+  const flag = args.find(a => a.startsWith('-E='));
+  if (flag) return flag.slice(3);
+  return 'unknown';
+}
+
+function outputPathFromArgs(args: string[]): string {
+  const oIdx = args.indexOf('-o');
+  if (oIdx !== -1 && args[oIdx + 1]) {
+    let p = args[oIdx + 1];
+    if (p.endsWith('/')) p = p.slice(0, -1);
+    return p.split('/').slice(0, -1).join('/') || '/tmp';
+  }
+  const fFlag = args.find(a => a.startsWith('-o='));
+  if (fFlag) {
+    const p = fFlag.slice(3);
+    return p.endsWith('/') ? p.slice(0, -1).split('/').slice(0, -1).join('/') || '/tmp' : p.split('/').slice(0, -1).join('/') || '/tmp';
+  }
+  return '/tmp';
+}
+
+function frameRangeFromArgs(args: string[]): { start: number; end: number } {
+  const fIdx = args.indexOf('-f');
+  if (fIdx !== -1 && args[fIdx + 1]) {
+    const raw = args[fIdx + 1];
+    if (raw.includes('..')) {
+      const [s, e] = raw.split('..').map(Number);
+      if (!isNaN(s) && !isNaN(e)) return { start: s, end: e };
+    }
+    const n = parseInt(raw, 10);
+    if (!isNaN(n)) return { start: n, end: n };
+  }
+  const sFlag = args.find(a => a.startsWith('-s='));
+  const eFlag = args.find(a => a.startsWith('-e='));
+  const start = sFlag ? parseInt(sFlag.slice(3), 10) : 1;
+  const end = eFlag ? parseInt(eFlag.slice(3), 10) : 250;
+  return { start: isNaN(start) ? 1 : start, end: isNaN(end) ? 250 : end };
+}
+
+async function parseRenderLog(blendName: string): Promise<{ framesRendered: number; totalFrames: number; startTime: number; samples?: number } | null> {
+  const baseName = blendName.replace(/\.blend$/i, '');
+  try {
+    const entries = (await run(`ls -t "${RENDER_LOG_DIR}" 2>/dev/null | grep "^${baseName}_" | head -5`, '')).trim().split('\n').filter(Boolean);
+    for (const entry of entries) {
+      const logPath = `${RENDER_LOG_DIR}/${entry}`;
+      try {
+        const content = await run(`cat "${logPath}" 2>/dev/null`, '', 500);
+        if (!content) continue;
+        const lines = content.split('\n');
+        const rendered = lines.filter(l => /Fra:(\d+)/i.test(l)).length;
+        const totalMatch = content.match(/Fra:\s*\d+\s*\/\s*(\d+)/);
+        const totalFrames = totalMatch ? parseInt(totalMatch[1], 10) : 0;
+        const startMatch = content.match(/^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/m);
+        const startTime = startMatch ? new Date(startMatch[1]).getTime() : Date.now() - 60000;
+        const sampleMatch = content.match(/Sample\s*(\d+)/i);
+        if (rendered > 0) {
+          return { framesRendered: rendered, totalFrames: totalFrames || rendered, startTime, samples: sampleMatch ? parseInt(sampleMatch[1], 10) : undefined };
+        }
+      } catch {
+        // try next log file
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+export async function collectBlenderRenders(): Promise<BlenderRenderData[]> {
+  const renders: BlenderRenderData[] = [];
+  try {
+    const psRaw = await run("ps -eo pid,pcpu,pmem,state,command 2>/dev/null | grep -iE '[b]lender'", '', 2000);
+    if (!psRaw) return renders;
+
+    const lines = psRaw.split('\n');
+    for (const line of lines) {
+      const parts = line.trim().match(/\s*(\d+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+(.+)/);
+      if (!parts) continue;
+
+      const pid = parseInt(parts[1], 10);
+      const cpuPct = parseFloat(parts[2]);
+      const command = parts[5];
+      const args = command.split(/\s+/);
+
+      const isRender = /-b|--background|-f\s/.test(command) || /render/i.test(command);
+      if (!isRender && !command.includes('blender')) continue;
+
+      const blendFile = blendFileFromArgs(args);
+      const engine = engineFromArgs(args);
+      const outputPath = outputPathFromArgs(args);
+      const { start: frameStart, end: frameEnd } = frameRangeFromArgs(args);
+      const totalFrames = Math.max(1, frameEnd - frameStart + 1);
+
+      const logData = await parseRenderLog(blendFile);
+      const startTime = logData?.startTime ?? Date.now() - 60000;
+      const elapsedSec = Math.max(0, Math.round((Date.now() - startTime) / 1000));
+      let currentFrame = logData?.framesRendered ?? 0;
+      if (currentFrame === 0 && cpuPct > 0) currentFrame = 1;
+
+      let status: BlenderRenderData['status'] = 'unknown';
+      if (cpuPct > 0 && currentFrame > 0 && currentFrame < totalFrames) status = 'rendering';
+      else if (cpuPct > 0 && currentFrame >= totalFrames) status = 'finalizing';
+      else if (currentFrame === 0 && cpuPct > 0) status = 'loading';
+      else if (cpuPct === 0) status = 'idle';
+
+      const completionPercent = totalFrames > 0 ? Math.min(100, Math.round((currentFrame / totalFrames) * 100)) : 0;
+
+      renders.push({
+        pid,
+        blendFile,
+        renderEngine: engine,
+        frameStart,
+        frameEnd,
+        currentFrame,
+        totalFrames,
+        elapsedSec,
+        completionPercent,
+        status,
+        outputPath,
+        sampleCount: logData?.samples,
+      });
+    }
+  } catch {
+    // ignore
+  }
+  return renders;
+}