pyre-cli 10.4.0 → 10.6.0

package/src/monitors/platform/windows.ts

@@ -10,7 +10,28 @@
 import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs';
-import { run, runPowerShell } from '../run.js';
+import { run, runPowerShell as rawRunPowerShell } from '../run.js';
+
+/**
+ * Cache policy per query (stale-while-revalidate, see run.ts). Each powershell.exe launch is
+ * expensive, so static facts are cached for minutes and volatile ones for a few seconds.
+ * Order matters: the first matching rule wins.
+ */
+const PS_TTL_RULES: Array<[RegExp, number]> = [
+  [/Win32_Battery|BatteryCycleCount|BatteryStatus/, 10_000],
+  [/Win32_Processor|Win32_VideoController|HardwareInformation|Win32_OperatingSystem/, 10 * 60_000],
+  [/GPUEngine/, 3_000],
+  [/LibreHardwareMonitor|OpenHardwareMonitor|MSAcpi_ThermalZone|Thermal Zone Information/, 20_000],
+  [/Win32_PageFileUsage|Win32_LogicalDisk/, 30_000],
+  [/Get-NetIPConfiguration/, 60_000],
+  [/Get-NetTCPConnection/, 5_000],
+  [/Get-Process\b/, 5_000],
+];
+
+function runPowerShell(script: string, fallback = '', timeout = 10000): Promise<string> {
+  const rule = PS_TTL_RULES.find(([re]) => re.test(script));
+  return rawRunPowerShell(script, fallback, timeout, rule ? rule[1] : 0);
+}
 import type {
   CpuData,
   MemoryData,
@@ -226,48 +247,24 @@ export async function collectWindowsCpu(prevCpuTimesRef: { current: { total: num
 }
 
 export async function getWindowsCpuTemperature(): Promise<number | undefined> {
-  // 1. Try LibreHardwareMonitor or OpenHardwareMonitor WMI (widely supported on AMD Ryzen and Intel desktops)
-  try {
-    const lhmRaw = await runPowerShell(
-      `Get-CimInstance -Namespace root/LibreHardwareMonitor -ClassName Sensor -Filter "SensorType = 'Temperature' and Name like '%CPU%'" -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty Value`,
-      ''
-    );
-    const lhmVal = safeParseFloat(lhmRaw);
-    if (lhmVal >= 15 && lhmVal <= 115) return Math.round(lhmVal * 10) / 10;
-  } catch {}
-
-  try {
-    const ohmRaw = await runPowerShell(
-      `Get-CimInstance -Namespace root/OpenHardwareMonitor -ClassName Sensor -Filter "SensorType = 'Temperature' and Name like '%CPU%'" -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty Value`,
-      ''
-    );
-    const ohmVal = safeParseFloat(ohmRaw);
-    if (ohmVal >= 15 && ohmVal <= 115) return Math.round(ohmVal * 10) / 10;
-  } catch {}
-
-  // 2. Try PowerShell CIM MSAcpi_ThermalZoneTemperature (modern Windows 10/11 replacement for wmic)
-  try {
-    const cimRaw = await runPowerShell(
-      `(Get-CimInstance -Namespace root/wmi -ClassName MSAcpi_ThermalZoneTemperature -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty CurrentTemperature)`,
-      ''
-    );
-    const kelvinTenths = safeParseInt(cimRaw);
-    if (kelvinTenths > 2732 && kelvinTenths < 4200) {
-      const c = Math.round(((kelvinTenths - 2732) / 10) * 10) / 10;
-      if (c >= 15 && c <= 115) return c;
-    }
-  } catch {}
+  // One PowerShell launch that tries, in order: LibreHardwareMonitor / OpenHardwareMonitor WMI
+  // (AMD Ryzen + Intel desktops), ACPI thermal zone (needs admin on many machines), then the
+  // locale-independent thermal zone performance class. Outputs Celsius or nothing.
+  const script = [
+    `$t = $null`,
+    `foreach ($ns in 'root/LibreHardwareMonitor','root/OpenHardwareMonitor') {`,
+    `  if ($t) { break }`,
+    `  try { $v = Get-CimInstance -Namespace $ns -ClassName Sensor -Filter "SensorType = 'Temperature' and Name like '%CPU%'" -ErrorAction Stop | Select-Object -First 1 -ExpandProperty Value; if ($v) { $t = [double]$v } } catch {}`,
+    `}`,
+    `if (-not $t) { try { $k = Get-CimInstance -Namespace root/wmi -ClassName MSAcpi_ThermalZoneTemperature -ErrorAction Stop | Select-Object -First 1 -ExpandProperty CurrentTemperature; if ($k -gt 2732) { $t = ($k - 2732) / 10 } } catch {} }`,
+    `if (-not $t) { try { $k = Get-CimInstance -ClassName Win32_PerfFormattedData_Counters_ThermalZoneInformation -ErrorAction Stop | Where-Object { $_.Temperature -gt 273 -and $_.Temperature -lt 400 } | Select-Object -First 1 -ExpandProperty Temperature; if ($k) { $t = $k - 273.15 } } catch {} }`,
+    `if ($t) { [string]([math]::Round($t, 1)) }`,
+  ].join('\n');
 
-  // 3. Try Windows Performance Counter
   try {
-    const raw = await runPowerShell(
-      `(Get-Counter '\\Thermal Zone Information(*)\\*' -ErrorAction SilentlyContinue).CounterSamples | Where-Object { $_.CookedValue -gt 200 -and $_.CookedValue -lt 400 } | Select-Object -First 1 -ExpandProperty CookedValue`,
-      ''
-    );
-    const tempK = safeParseFloat(raw);
-    if (tempK > 200 && tempK < 400) {
-      return Math.round((tempK - 273.15) * 10) / 10;
-    }
+    const raw = await runPowerShell(script, '');
+    const val = safeParseFloat(raw.replace(',', '.'));
+    if (val >= 15 && val <= 115) return Math.round(val * 10) / 10;
   } catch {}
 
   return undefined;
@@ -358,18 +355,54 @@ export async function collectWindowsDisk(): Promise<DiskData[]> {
     // fallback
   }
 
-  return [
-    {
-      filesystem: 'C:',
-      size: '500G',
-      used: '150G',
-      available: '350G',
-      capacity: '30%',
-      mountpoint: 'C:',
-      readBytesSec: 0,
-      writeBytesSec: 0,
-    },
-  ];
+  // Fallback: real numbers from the filesystem API (no PowerShell needed)
+  const fallback: DiskData[] = [];
+  for (let code = 67; code <= 90; code++) { // C..Z
+    const drive = `${String.fromCharCode(code)}:`;
+    try {
+      const st = (fs as any).statfsSync?.(`${drive}\\`);
+      if (!st) break;
+      const totalBytes = Number(st.blocks) * Number(st.bsize);
+      const freeBytes = Number(st.bavail) * Number(st.bsize);
+      if (totalBytes > 0) {
+        const usedBytes = Math.max(0, totalBytes - freeBytes);
+        fallback.push({
+          filesystem: drive,
+          size: formatBytesStr(totalBytes),
+          used: formatBytesStr(usedBytes),
+          available: formatBytesStr(freeBytes),
+          capacity: `${Math.round((usedBytes / totalBytes) * 100)}%`,
+          mountpoint: drive,
+          readBytesSec: 0,
+          writeBytesSec: 0,
+        });
+      }
+    } catch {
+      // drive letter not present
+    }
+  }
+  if (fallback.length === 0) {
+    try {
+      const st = (fs as any).statfsSync?.(os.homedir());
+      const totalBytes = st ? Number(st.blocks) * Number(st.bsize) : 0;
+      const freeBytes = st ? Number(st.bavail) * Number(st.bsize) : 0;
+      if (totalBytes > 0) {
+        const usedBytes = Math.max(0, totalBytes - freeBytes);
+        const drive = path.parse(os.homedir()).root.replace(/[\\/]+$/, '') || 'C:';
+        fallback.push({
+          filesystem: drive,
+          size: formatBytesStr(totalBytes),
+          used: formatBytesStr(usedBytes),
+          available: formatBytesStr(freeBytes),
+          capacity: `${Math.round((usedBytes / totalBytes) * 100)}%`,
+          mountpoint: drive,
+          readBytesSec: 0,
+          writeBytesSec: 0,
+        });
+      }
+    } catch {}
+  }
+  return fallback;
 }
 
 function formatBytesStr(bytes: number): string {
@@ -381,39 +414,96 @@ function formatBytesStr(bytes: number): string {
 
 // ─── Battery ───────────────────────────────────────────────────────────────────
 
+export interface WindowsBatteryRaw {
+  level: number;
+  statusCode: number;
+  runTimeMinutes: number;
+  winDischargeRate: number;
+  cycles: number;
+  fullChargeMWh: number;
+  designMWh: number;
+  rateMilliwatts: number;
+}
+
+export function parseWindowsBatteryOutput(raw: string): WindowsBatteryRaw | null {
+  const line = raw.split('\n').map(l => l.trim()).find(l => l.includes('|'));
+  if (!line) return null;
+  const p = line.split('|');
+  return {
+    level: safeParseInt(p[0], 0),
+    statusCode: safeParseInt(p[1], 1),
+    runTimeMinutes: safeParseInt(p[2], 0),
+    winDischargeRate: safeParseInt(p[3], 0),
+    cycles: safeParseInt(p[4], 0),
+    fullChargeMWh: safeParseInt(p[5], 0),
+    designMWh: safeParseInt(p[6], 0),
+    rateMilliwatts: safeParseInt(p[7], 0),
+  };
+}
+
 export async function collectWindowsBattery(): Promise<BatteryData | null> {
   try {
-    const raw = await runPowerShell(
-      `$bat = Get-CimInstance Win32_Battery -ErrorAction SilentlyContinue; if ($bat) { "$($bat.EstimatedChargeRemaining)|$($bat.BatteryStatus)|$($bat.EstimatedRunTime)|$($bat.DischargeRate)" } else { '' }`,
-      ''
-    );
-    if (!raw) return null;
-
-    const parts = raw.split('|');
-    const level = safeParseInt(parts[0], 0);
-    const statusCode = safeParseInt(parts[1], 1);
-    const runTimeMinutes = safeParseInt(parts[2], 0);
-    const dischargeRate = safeParseInt(parts[3], 0);
+    // Win32_Battery gives level/status; the root/wmi classes (supported by most modern laptops)
+    // give cycle count, design vs. full-charge capacity and instantaneous charge/discharge rate.
+    // Everything is fetched in ONE PowerShell launch. Output: level|status|runtime|discharge|cycles|full|design|rate
+    const script = [
+      `$b = Get-CimInstance Win32_Battery -ErrorAction SilentlyContinue | Select-Object -First 1`,
+      `if ($b) {`,
+      `  $cyc = (Get-CimInstance -Namespace root/wmi -ClassName BatteryCycleCount -ErrorAction SilentlyContinue | Select-Object -First 1).CycleCount`,
+      `  $full = (Get-CimInstance -Namespace root/wmi -ClassName BatteryFullChargedCapacity -ErrorAction SilentlyContinue | Select-Object -First 1).FullChargedCapacity`,
+      `  $des = (Get-CimInstance -Namespace root/wmi -ClassName BatteryStaticData -ErrorAction SilentlyContinue | Select-Object -First 1).DesignedCapacity`,
+      `  $st = Get-CimInstance -Namespace root/wmi -ClassName BatteryStatus -ErrorAction SilentlyContinue | Select-Object -First 1`,
+      `  $rate = 0; if ($st) { if ($st.Charging) { $rate = $st.ChargeRate } elseif ($st.Discharging) { $rate = $st.DischargeRate } }`,
+      `  "$($b.EstimatedChargeRemaining)|$($b.BatteryStatus)|$($b.EstimatedRunTime)|$($b.DischargeRate)|$cyc|$full|$des|$rate"`,
+      `}`,
+    ].join('\n');
+
+    const raw = await runPowerShell(script, '');
+    const b = parseWindowsBatteryOutput(raw);
+    if (!b) return null;
+
+    // BatteryStatus: 1 discharging, 2 on AC, 3 fully charged, 4 low, 5 critical, 6-9 charging, 11 partially charged
+    const charging = [2, 6, 7, 8, 9].includes(b.statusCode);
+    const onAc = [2, 3, 6, 7, 8, 9, 11].includes(b.statusCode);
+    const powerSource = onAc ? 'AC' : 'Battery';
+    const state = b.statusCode === 3 || (onAc && b.level >= 100) ? 'charged' : charging ? 'charging' : 'discharging';
 
-    const powerSource = statusCode === 2 || statusCode === 3 || statusCode === 6 ? 'AC' : 'Battery';
-    const state = statusCode === 3 ? 'charged' : statusCode === 6 || statusCode === 2 ? 'charging' : 'discharging';
     let timeRemaining = 'calculating';
     if (state === 'charged') timeRemaining = '∞';
-    else if (runTimeMinutes && runTimeMinutes > 0 && runTimeMinutes < 70000) {
-      const h = Math.floor(runTimeMinutes / 60);
-      const m = runTimeMinutes % 60;
+    else if (state === 'discharging' && b.runTimeMinutes > 0 && b.runTimeMinutes < 70000) {
+      const h = Math.floor(b.runTimeMinutes / 60);
+      const m = b.runTimeMinutes % 60;
       timeRemaining = `${h}:${m.toString().padStart(2, '0')}`;
     }
 
-    const powerWatts = dischargeRate > 0 ? Math.round((dischargeRate / 1000) * 100) / 100 : undefined;
+    // Wattage: prefer instantaneous rate from root/wmi (mW), fall back to Win32_Battery.DischargeRate
+    const rateMw = Math.abs(b.rateMilliwatts) > 0 && Math.abs(b.rateMilliwatts) < 400_000 ? Math.abs(b.rateMilliwatts) : b.winDischargeRate;
+    const powerWatts = rateMw > 0 ? Math.round((rateMw / 1000) * 100) / 100 : undefined;
+
+    // Health = full-charge capacity / design capacity. Cycle count of 0 means "not reported".
+    let maxCapacityPercent: number | undefined;
+    if (b.designMWh > 0 && b.fullChargeMWh > 0) {
+      maxCapacityPercent = Math.min(100, Math.round((b.fullChargeMWh / b.designMWh) * 100));
+    }
+    const cycles = b.cycles > 0 && b.cycles < 100_000 ? b.cycles : undefined;
+
+    let health = 'Good';
+    let condition = 'Normal';
+    if (maxCapacityPercent !== undefined) {
+      if (maxCapacityPercent < 60) { health = 'Poor'; condition = 'Service Recommended'; }
+      else if (maxCapacityPercent < 80) { health = 'Fair'; condition = 'Reduced Capacity'; }
+    }
 
     return {
-      level,
+      level: b.level,
       state,
       timeRemaining,
-      health: 'Good',
+      health,
       powerSource,
       powerWatts,
+      cycles,
+      condition,
+      maxCapacityPercent,
     };
   } catch {
     return null;
@@ -562,7 +652,15 @@ export async function collectWindowsPower(): Promise<PowerData | null> {
 
 // ─── GPU Telemetry Across Intel, AMD, NVIDIA ─────────────────────────────────
 
+let nvidiaSmiPathCache: { path: string | null; checkedAt: number } | null = null;
+const NVIDIA_SMI_NEGATIVE_TTL_MS = 5 * 60 * 1000;
+
 async function findNvidiaSmiPath(): Promise<string> {
+  if (nvidiaSmiPathCache) {
+    if (nvidiaSmiPathCache.path) return nvidiaSmiPathCache.path;
+    // Not found previously: only re-probe occasionally (e.g. driver installed while running)
+    if (Date.now() - nvidiaSmiPathCache.checkedAt < NVIDIA_SMI_NEGATIVE_TTL_MS) return 'nvidia-smi';
+  }
   const commonPaths = [
     'nvidia-smi',
     path.join(process.env.ProgramFiles || 'C:\\Program Files', 'NVIDIA Corporation', 'NVSMI', 'nvidia-smi.exe'),
@@ -571,14 +669,19 @@ async function findNvidiaSmiPath(): Promise<string> {
   for (const p of commonPaths) {
     try {
       const test = await run(`"${p}" -L 2>nul`, '');
-      if (test.includes('GPU 0:')) return p;
+      if (test.includes('GPU 0:')) {
+        nvidiaSmiPathCache = { path: p, checkedAt: Date.now() };
+        return p;
+      }
     } catch {}
   }
+  nvidiaSmiPathCache = { path: null, checkedAt: Date.now() };
   return 'nvidia-smi';
 }
 
 async function runNvidiaSmiQuery(query: string): Promise<string> {
   const smiPath = await findNvidiaSmiPath();
+  if (nvidiaSmiPathCache && nvidiaSmiPathCache.path === null) return '';
   return (await run(`"${smiPath}" --query-gpu=${query} --format=csv,noheader,nounits 2>nul`, '')).trim();
 }
 
@@ -656,50 +759,60 @@ export function parseWindowsVideoControllers(csvRaw: string): WindowsVideoContro
   return controllers;
 }
 
+function isVirtualGpuName(name: string): boolean {
+  return /microsoft basic|remote display|hyper-v|virtual|vmware|virtualbox|parsec|citrix|indirect display|displaylink/i.test(name);
+}
+
+function isDiscreteGpuName(name: string): boolean {
+  const n = name.toLowerCase();
+  if (isVirtualGpuName(n)) return false;
+  return (
+    /\b(rtx|gtx|geforce|quadro|titan|tesla)\b/.test(n) ||
+    /\bnvidia\b/.test(n) ||
+    /radeon\s+(rx|pro|vii|r[5-9]|hd)\b/.test(n) ||
+    /\bfirepro\b/.test(n) ||
+    (/\barc\b/.test(n) && /\b(a\d{3}|b\d{3}|pro)\b/.test(n))
+  );
+}
+
 export function prioritizeGpuControllers(controllers: WindowsVideoControllerInfo[]): WindowsVideoControllerInfo[] {
-  // Sort discrete cards (NVIDIA, AMD Radeon RX, Intel Arc) before integrated adapters (Intel UHD, AMD Radeon(TM) Graphics)
+  // Order: discrete (NVIDIA, AMD Radeon RX/Pro, Intel Arc) > integrated (Intel UHD/Iris/Xe, AMD Radeon(TM) Graphics) > virtual/basic adapters
+  const rank = (c: WindowsVideoControllerInfo) =>
+    isVirtualGpuName(c.name) ? 2 : isDiscreteGpuName(c.name) ? 0 : 1;
   return [...controllers].sort((a, b) => {
-    const aName = a.name.toLowerCase();
-    const bName = b.name.toLowerCase();
-    const aIsDiscrete = aName.includes('rtx') || aName.includes('gtx') || aName.includes('geforce') ||
-      aName.includes('radeon rx') || aName.includes('arc');
-    const bIsDiscrete = bName.includes('rtx') || bName.includes('gtx') || bName.includes('geforce') ||
-      bName.includes('radeon rx') || bName.includes('arc');
-    if (aIsDiscrete && !bIsDiscrete) return -1;
-    if (!aIsDiscrete && bIsDiscrete) return 1;
+    const ra = rank(a);
+    const rb = rank(b);
+    if (ra !== rb) return ra - rb;
     return b.adapterRam - a.adapterRam;
   });
 }
 
-export async function getWindowsGpu64BitVram(): Promise<number> {
+export async function getWindowsGpu64BitVram(adapterName?: string): Promise<number> {
   // Win32_VideoController clamps AdapterRAM to 4GB (UInt32).
-  // Read exact 64-bit VRAM from Registry Display Class hardware information:
+  // Read exact 64-bit VRAM from the Display Class registry keys. The value is literally named
+  // 'HardwareInformation.qwMemorySize' (dot is part of the name), so it must be quoted.
+  // Match by DriverDesc so hybrid systems report the VRAM of the selected adapter.
   try {
+    const safeName = (adapterName || '').replace(/'/g, "''");
     const raw = await runPowerShell(
-      `Get-ItemProperty -Path 'HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Class\\{4d36e968-e325-11ce-bfc1-08002be10318}\\0*' -ErrorAction SilentlyContinue | Where-Object { $_.HardwareInformation.qwMemorySize -gt 0 } | Select-Object -First 1 -ExpandProperty HardwareInformation.qwMemorySize`,
-      ''
-    );
-    const bytes = safeParseInt(raw, 0);
-    if (bytes > 0) return bytes;
-  } catch {}
-
-  // Fallback to Performance Counters Dedicated Usage + Free
-  try {
-    const rawDedicated = await runPowerShell(
-      `(Get-Counter '\\GPU Adapter Memory(*)\\Dedicated Usage' -ErrorAction SilentlyContinue).CounterSamples | Measure-Object -Property CookedValue -Sum | Select-Object -ExpandProperty Sum`,
+      `$name = '${safeName}'; $items = Get-ItemProperty -Path 'HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Class\\{4d36e968-e325-11ce-bfc1-08002be10318}\\0*' -ErrorAction SilentlyContinue | Where-Object { $_.'HardwareInformation.qwMemorySize' -gt 0 }; $pick = $items | Where-Object { $name -and $_.DriverDesc -eq $name } | Select-Object -First 1; if (-not $pick) { $pick = $items | Sort-Object -Property 'HardwareInformation.qwMemorySize' -Descending | Select-Object -First 1 }; if ($pick) { [string][uint64]$pick.'HardwareInformation.qwMemorySize' }`,
       ''
     );
-    const bytes = safeParseFloat(rawDedicated);
+    const bytes = safeParseFloat(raw.trim());
     if (bytes > 0) return bytes;
   } catch {}
 
   return 0;
 }
 
+/**
+ * 3D engine utilization via CIM performance classes. Unlike Get-Counter paths these class/property
+ * names are not localized, so this works on non-English Windows. Works for NVIDIA, AMD and Intel (WDDM 2.0+).
+ */
 export async function getWindowsGpu3dUtilization(): Promise<{ utilization: number; processCount: number }> {
   try {
     const raw = await runPowerShell(
-      `$samples = (Get-Counter '\\GPU Engine(*engtype_3D*)\\Utilization Percentage' -ErrorAction SilentlyContinue).CounterSamples; if ($samples) { $activePids = $samples | Where-Object { $_.CookedValue -gt 0 } | ForEach-Object { if ($_.InstanceName -match 'pid_(\\d+)') { $matches[1] } } | Select-Object -Unique; $total = ($samples | Measure-Object -Property CookedValue -Sum).Sum; "$total|$($activePids.Count)" } else { '0|0' }`,
+      `$samples = Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine -ErrorAction SilentlyContinue | Where-Object { $_.Name -like '*engtype_3D*' }; if ($samples) { $activePids = $samples | Where-Object { $_.UtilizationPercentage -gt 0 } | ForEach-Object { if ($_.Name -match 'pid_(\\d+)') { $matches[1] } } | Select-Object -Unique; $total = ($samples | Measure-Object -Property UtilizationPercentage -Sum).Sum; "$total|$(@($activePids).Count)" } else { '0|0' }`,
       '0|0'
     );
     const [utilStr, procCountStr] = raw.split('|');
@@ -729,7 +842,7 @@ export async function collectWindowsGpu(): Promise<GpuData | null> {
     const bestController = prioritized[0];
 
     // Read 64-bit VRAM (avoids 4GB uint32 clamp on RX 7900, Arc A770, etc.)
-    let vramBytes = await getWindowsGpu64BitVram();
+    let vramBytes = await getWindowsGpu64BitVram(bestController.name);
     if (vramBytes === 0 && bestController.adapterRam > 0) {
       vramBytes = bestController.adapterRam;
     }
@@ -1090,7 +1203,20 @@ export function parseWindowsProcessCsv(
   return procs;
 }
 
+let procListMemo: { ts: number; promise: Promise<ProcessData[]> } | null = null;
+const PROC_MEMO_MS = 1500;
+
 export async function collectWindowsProcesses(limit?: number): Promise<ProcessData[]> {
+  const now0 = Date.now();
+  if (!procListMemo || now0 - procListMemo.ts > PROC_MEMO_MS) {
+    procListMemo = { ts: now0, promise: queryWindowsProcesses() };
+  }
+  const procs = await procListMemo.promise;
+  if (limit && limit > 0) return procs.slice(0, limit);
+  return procs;
+}
+
+async function queryWindowsProcesses(): Promise<ProcessData[]> {
   try {
     // Explicitly query ParentProcessId for process tree view (`pyre --tree`)
     const raw = await runPowerShell(
@@ -1099,10 +1225,7 @@ export async function collectWindowsProcesses(limit?: number): Promise<ProcessDa
     );
     const now = Date.now();
     const totalMem = os.totalmem();
-    const procs = parseWindowsProcessCsv(raw, totalMem, winProcCache, now);
-
-    if (limit && limit > 0) return procs.slice(0, limit);
-    return procs;
+    return parseWindowsProcessCsv(raw, totalMem, winProcCache, now);
   } catch {
     return [];
   }

package/src/monitors/run.ts

@@ -29,18 +29,94 @@ async function run(cmd: string, fallback: string = '', timeout = 3000): Promise<
   }
 }
 
+// ─── PowerShell execution (Windows) ──────────────────────────────────────────
+// Every powershell.exe launch costs 0.3–1.5s of cold start. A single collection tick used to
+// spawn ~15 of them at once; under that contention the 4s timeouts fired and results silently
+// became empty (no battery, no GPU, ...). So we: (1) cap concurrent processes, (2) start the
+// timeout when the process actually starts, (3) dedupe identical in-flight scripts and
+// (4) allow stale-while-revalidate caching for data that does not change every tick.
+
+const MAX_CONCURRENT_PS = 3;
+let activePs = 0;
+const psWaiters: Array<() => void> = [];
+
+async function acquirePsSlot(): Promise<void> {
+  if (activePs < MAX_CONCURRENT_PS) {
+    activePs++;
+    return;
+  }
+  await new Promise<void>(resolve => psWaiters.push(resolve));
+}
+
+function releasePsSlot(): void {
+  const next = psWaiters.shift();
+  if (next) next(); // hand the slot over directly
+  else activePs--;
+}
+
+interface PsCacheEntry {
+  value: string;
+  ts: number;
+  inflight?: Promise<string | null>;
+}
+const psCache = new Map<string, PsCacheEntry>();
+const psInflight = new Map<string, Promise<string | null>>();
+
+/** Returns stdout on success (possibly ''), or null when the process failed / timed out. */
+async function execPowerShell(script: string, timeout: number): Promise<string | null> {
+  const existing = psInflight.get(script);
+  if (existing) return existing;
+
+  const p = (async () => {
+    await acquirePsSlot();
+    try {
+      const encoded = Buffer.from(script, 'utf16le').toString('base64');
+      const cmd = `powershell.exe -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encoded}`;
+      return (await execAsync(cmd, { encoding: 'utf8', timeout, windowsHide: true, maxBuffer: 16 * 1024 * 1024 })).stdout.trim();
+    } catch {
+      return null;
+    } finally {
+      releasePsSlot();
+    }
+  })();
+  psInflight.set(script, p);
+  p.finally(() => psInflight.delete(script)).catch(() => {});
+  return p;
+}
+
 /**
  * Execute a PowerShell snippet safely on Windows, returning trimmed stdout or fallback.
+ *
+ * @param cacheTtlMs when > 0 the result is cached; stale values are returned immediately while
+ *                   a refresh runs in the background (failures never overwrite good data).
  */
-async function runPowerShell(script: string, fallback: string = '', timeout = 4000): Promise<string> {
+async function runPowerShell(script: string, fallback: string = '', timeout = 10000, cacheTtlMs = 0): Promise<string> {
   if (!isWindows) return fallback;
-  try {
-    const encoded = Buffer.from(script, 'utf16le').toString('base64');
-    const cmd = `powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encoded}`;
-    return (await execAsync(cmd, { encoding: 'utf8', timeout, windowsHide: true })).stdout.trim();
-  } catch {
-    return fallback;
+
+  if (cacheTtlMs > 0) {
+    const now = Date.now();
+    const entry = psCache.get(script);
+    if (entry) {
+      if (now - entry.ts >= cacheTtlMs && !entry.inflight) {
+        entry.inflight = execPowerShell(script, timeout).then(v => {
+          if (v !== null) {
+            entry.value = v;
+            entry.ts = Date.now();
+          }
+          return v;
+        }).finally(() => { entry.inflight = undefined; });
+        entry.inflight.catch(() => {});
+      }
+      return entry.value;
+    }
+    const value = await execPowerShell(script, timeout);
+    if (value === null) return fallback;
+    psCache.set(script, { value, ts: Date.now() });
+    return value;
   }
+
+  const value = await execPowerShell(script, timeout);
+  return value === null ? fallback : value;
 }
 
 export { run, runPowerShell };

package/src/platform.test.ts

@@ -119,6 +119,30 @@ describe('Intel, AMD & NVIDIA Hardware Telemetry', () => {
     assert.strictEqual(prioritized[0].name, 'Intel(R) Arc(TM) A770 Graphics');
   });
 
+  it('should parse Windows battery cycles, capacity and rate output', async () => {
+    const { parseWindowsBatteryOutput } = await import('./monitors/platform/windows.js');
+    const b = parseWindowsBatteryOutput('87|1|312||214|41200|50000|11500\r\n');
+    assert.ok(b);
+    assert.strictEqual(b.level, 87);
+    assert.strictEqual(b.cycles, 214);
+    assert.strictEqual(b.fullChargeMWh, 41200);
+    assert.strictEqual(b.designMWh, 50000);
+    assert.strictEqual(b.rateMilliwatts, 11500);
+    assert.strictEqual(parseWindowsBatteryOutput(''), null);
+  });
+
+
+  it('should rank hybrid laptop adapters: discrete > integrated > virtual', async () => {
+    const { prioritizeGpuControllers } = await import('./monitors/platform/windows.js');
+    const mk = (name: string, adapterRam = 0) => ({ name, adapterRam, driverVersion: '', videoProcessor: '', pnpDeviceId: '' });
+    const order = (names: string[]) => prioritizeGpuControllers(names.map(n => mk(n))).map(c => c.name);
+
+    assert.strictEqual(order(['Microsoft Basic Display Adapter', 'Intel(R) Iris(R) Xe Graphics', 'NVIDIA GeForce RTX 4060 Laptop GPU'])[0], 'NVIDIA GeForce RTX 4060 Laptop GPU');
+    assert.strictEqual(order(['Intel(R) UHD Graphics', 'Microsoft Remote Display Adapter'])[0], 'Intel(R) UHD Graphics');
+    assert.strictEqual(order(['AMD Radeon(TM) Graphics', 'AMD Radeon Pro W7800'])[0], 'AMD Radeon Pro W7800');
+  });
+
+
   it('should detect CPU vendors and estimate architecture TDP accurately', async () => {
     const { detectProcessorVendor, estimateCpuTdp } = await import('./monitors/platform/windows.js');
     // AMD tests

package/dist/chunk-MZO5QKUR.js

@@ -1,32 +0,0 @@
-// src/monitors/run.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-var isWindows = process.platform === "win32";
-async function run(cmd, fallback = "", timeout = 3e3) {
-  try {
-    let sanitizedCmd = cmd;
-    if (isWindows) {
-      sanitizedCmd = sanitizedCmd.replace(/2>\s*\/dev\/null/g, "2>nul");
-      sanitizedCmd = sanitizedCmd.replace(/\/dev\/null/g, "nul");
-    }
-    return (await execAsync(sanitizedCmd, { encoding: "utf8", timeout, windowsHide: true })).stdout.trim();
-  } catch {
-    return fallback;
-  }
-}
-async function runPowerShell(script, fallback = "", timeout = 4e3) {
-  if (!isWindows) return fallback;
-  try {
-    const encoded = Buffer.from(script, "utf16le").toString("base64");
-    const cmd = `powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encoded}`;
-    return (await execAsync(cmd, { encoding: "utf8", timeout, windowsHide: true })).stdout.trim();
-  } catch {
-    return fallback;
-  }
-}
-
-export {
-  run,
-  runPowerShell
-};