pyre-cli 9.5.2 → 10.0.0

package/src/brewHealth.ts

@@ -7,76 +7,193 @@ export interface BrewHealthInfo {
   cellarSize: string;
   doctorWarnings: string[];
   brewAvailable: boolean;
+  managerName: string;
 }
 
 export async function getBrewHealth(): Promise<BrewHealthInfo> {
+  const isWindows = process.platform === 'win32';
+
+  // 1. Try Homebrew (macOS or Linuxbrew)
   try {
-    const brewPath = await run('which brew 2>&1', '');
-    if (!brewPath.trim() || brewPath.includes('not found')) {
-      return { installedCount: 0, outdatedCount: 0, cellarSize: 'N/A', doctorWarnings: [], brewAvailable: false };
+    const brewPath = await run(isWindows ? 'where brew 2>nul' : 'which brew 2>&1', '');
+    if (brewPath.trim() && !brewPath.includes('not found') && !brewPath.includes('Could not find')) {
+      const outdatedRaw = await run('brew outdated --quiet 2>&1', '');
+      const outdatedLines = outdatedRaw.trim().split('\n').filter(l => l.length > 0 && !l.startsWith('Homebrew') && !l.startsWith('==>'));
+
+      const listRaw = await run('brew list --formula -1 2>&1', '');
+      const listLines = listRaw.trim().split('\n').filter(l => l.length > 0);
+
+      let cellarSize = 'N/A';
+      try {
+        const cellarPath = await run('brew --cellar 2>&1', '');
+        if (cellarPath.trim()) {
+          const duRaw = await run(`du -sh "${cellarPath.trim()}" 2>&1`, '');
+          const duMatch = duRaw.match(/^([0-9.,]+[KMGTP]?i?B?)/i);
+          if (duMatch) cellarSize = duMatch[1];
+        }
+      } catch {
+        cellarSize = 'N/A';
+      }
+
+      const doctorRaw = await run('brew doctor 2>&1', '');
+      const doctorWarnings: string[] = [];
+      const docLines = doctorRaw.split('\n');
+      for (const line of docLines) {
+        if (line.startsWith('Warning:')) {
+          doctorWarnings.push(line.replace(/^Warning:\s*/, '').trim());
+        }
+      }
+
+      return {
+        installedCount: listLines.length,
+        outdatedCount: outdatedLines.length,
+        cellarSize,
+        doctorWarnings,
+        brewAvailable: true,
+        managerName: 'Homebrew',
+      };
     }
+  } catch {
+    // continue to alternative managers
+  }
 
-    // Outdated count without triggering brew update
-    const outdatedRaw = await run('brew outdated --quiet 2>&1', '');
-    const outdatedLines = outdatedRaw.trim().split('\n').filter(l => l.length > 0 && !l.startsWith('Homebrew') && !l.startsWith('==>'));
+  // 2. Linux Package Managers (APT, DNF, Pacman)
+  if (process.platform === 'linux') {
+    // Try APT
+    try {
+      const whichApt = (await run('which apt-get 2>/dev/null', '')).trim();
+      if (whichApt) {
+        const listRaw = (await run('dpkg-query -l 2>/dev/null', '')).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(l => l.startsWith('ii')).length : 0;
+        const upgradeRaw = (await run('apt list --upgradable 2>/dev/null', '')).trim();
+        const outdated = upgradeRaw ? upgradeRaw.split('\n').filter(l => l.includes('/') && !l.startsWith('Listing')).length : 0;
+        return {
+          installedCount: installed,
+          outdatedCount: outdated,
+          cellarSize: '/var/cache/apt',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'APT (Debian/Ubuntu)',
+        };
+      }
+    } catch {
+      // ignore
+    }
 
-    // Installed list count
-    const listRaw = await run('brew list --formula -1 2>&1', '');
-    const listLines = listRaw.trim().split('\n').filter(l => l.length > 0);
+    // Try Pacman
+    try {
+      const whichPacman = (await run('which pacman 2>/dev/null', '')).trim();
+      if (whichPacman) {
+        const listRaw = (await run('pacman -Q 2>/dev/null', '')).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(Boolean).length : 0;
+        const upgradeRaw = (await run('checkupdates 2>/dev/null || pacman -Qu 2>/dev/null', '')).trim();
+        const outdated = upgradeRaw ? upgradeRaw.split('\n').filter(Boolean).length : 0;
+        return {
+          installedCount: installed,
+          outdatedCount: outdated,
+          cellarSize: '/var/cache/pacman',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'Pacman (Arch)',
+        };
+      }
+    } catch {
+      // ignore
+    }
 
-    // Disk usage of cellar
-    let cellarSize = 'N/A';
+    // Try DNF
     try {
-      const cellarPath = await run('brew --cellar 2>&1', '');
-      if (cellarPath.trim()) {
-        const duRaw = await run(`du -sh "${cellarPath.trim()}" 2>&1`, '');
-        const duMatch = duRaw.match(/^([0-9\.\,]+[KMGTP]?i?B?)/i);
-        if (duMatch) cellarSize = duMatch[1];
+      const whichDnf = (await run('which dnf 2>/dev/null', '')).trim();
+      if (whichDnf) {
+        const listRaw = (await run('dnf list installed 2>/dev/null', '')).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(Boolean).length - 1 : 0;
+        return {
+          installedCount: Math.max(0, installed),
+          outdatedCount: 0,
+          cellarSize: '/var/cache/dnf',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'DNF (Fedora/RHEL)',
+        };
       }
     } catch {
-      cellarSize = 'N/A';
+      // ignore
     }
+  }
 
-    // Doctor warnings
-    const doctorRaw = await run('brew doctor 2>&1', '');
-    const doctorWarnings: string[] = [];
-    const docLines = doctorRaw.split('\n');
-    for (const line of docLines) {
-      if (line.startsWith('Warning:')) {
-        doctorWarnings.push(line.replace(/^Warning:\s*/, '').trim());
+  // 3. Windows Package Managers (winget, choco, scoop)
+  if (isWindows) {
+    // Try winget
+    try {
+      const whichWinget = (await run('where winget 2>nul', '')).trim();
+      if (whichWinget) {
+        const listRaw = (await run('winget list 2>nul', '', 4000)).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(Boolean).length - 2 : 0;
+        return {
+          installedCount: Math.max(0, installed),
+          outdatedCount: 0,
+          cellarSize: 'N/A',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'Windows Package Manager (winget)',
+        };
       }
+    } catch {
+      // ignore
     }
 
-    return {
-      installedCount: listLines.length,
-      outdatedCount: outdatedLines.length,
-      cellarSize,
-      doctorWarnings,
-      brewAvailable: true,
-    };
-  } catch (err) {
-    return { installedCount: 0, outdatedCount: 0, cellarSize: 'N/A', doctorWarnings: [], brewAvailable: false };
+    // Try scoop
+    try {
+      const whichScoop = (await run('where scoop 2>nul', '')).trim();
+      if (whichScoop) {
+        const listRaw = (await run('scoop list 2>nul', '')).trim();
+        const installed = listRaw ? listRaw.split('\n').filter(Boolean).length - 4 : 0;
+        return {
+          installedCount: Math.max(0, installed),
+          outdatedCount: 0,
+          cellarSize: 'N/A',
+          doctorWarnings: [],
+          brewAvailable: true,
+          managerName: 'Scoop',
+        };
+      }
+    } catch {
+      // ignore
+    }
   }
+
+  return {
+    installedCount: 0,
+    outdatedCount: 0,
+    cellarSize: 'N/A',
+    doctorWarnings: [],
+    brewAvailable: false,
+    managerName: 'None',
+  };
 }
 
 export async function printBrewHealthReport(): Promise<void> {
-  console.log(chalk.bold('\n  pyre brew — Homebrew Health Summary\n'));
   const health = await getBrewHealth();
+  const label = health.brewAvailable ? health.managerName : 'Package Manager';
+  console.log(chalk.bold(`\n  pyre brew — ${label} Health Summary\n`));
 
   if (!health.brewAvailable) {
-    console.log(chalk.yellow('  ⚠ Homebrew is not installed or not available on PATH.\n'));
+    console.log(chalk.yellow('  ⚠ No supported package manager detected on PATH.\n'));
     return;
   }
 
-  console.log(`  📦 Installed Formulae: ${chalk.bold(health.installedCount)}`);
-  console.log(`  ⏳ Outdated Packages:   ${health.outdatedCount > 0 ? chalk.yellow.bold(health.outdatedCount) : chalk.green('0 (Up to date)')}`);
-  console.log(`  💾 Cellar Disk Usage:  ${chalk.bold(health.cellarSize)}`);
+  console.log(`  📦 Package Manager:    ${chalk.cyan.bold(health.managerName)}`);
+  console.log(`  📦 Installed Packages: ${chalk.bold(health.installedCount)}`);
+  console.log(`  ⏳ Outdated Packages:  ${health.outdatedCount > 0 ? chalk.yellow.bold(health.outdatedCount) : chalk.green('0 (Up to date)')}`);
+  if (health.cellarSize !== 'N/A') {
+    console.log(`  💾 Cache / Cellar:     ${chalk.bold(health.cellarSize)}`);
+  }
 
   console.log();
   if (health.doctorWarnings.length === 0) {
-    console.log(chalk.green('  ✔ brew doctor: No warnings detected system-wide.'));
+    console.log(chalk.green(`  ✔ ${health.managerName}: Ready and healthy.`));
   } else {
-    console.log(chalk.yellow(`  ⚠ brew doctor warnings (${health.doctorWarnings.length}):`));
+    console.log(chalk.yellow(`  ⚠ Diagnostics warnings (${health.doctorWarnings.length}):`));
     for (const warn of health.doctorWarnings.slice(0, 5)) {
       console.log(chalk.dim(`     • ${warn}`));
     }

package/src/buildCmd.ts

@@ -0,0 +1,48 @@
+/**
+ * pyre build — Active Build System Tracker.
+ *
+ * Discovers running compilation and build tools (xcodebuild, cargo, swift,
+ * make, ninja, bazel, go), displaying real-time compiler workers, parallelism,
+ * and CPU/RAM footprints.
+ */
+import chalk from 'chalk';
+import { collectBuilds } from './monitors/buildTracker.js';
+
+export interface BuildOptions {
+  watch?: boolean;
+  json?: boolean;
+}
+
+export async function runBuildCommand(opts: BuildOptions = {}): Promise<void> {
+  const builds = await collectBuilds();
+
+  if (opts.json) {
+    console.log(JSON.stringify({ activeBuilds: builds }, null, 2));
+    return;
+  }
+
+  console.log(chalk.bold('\n  🔥 pyre build — Active Build System Tracker\n'));
+
+  if (builds.length === 0) {
+    console.log(chalk.dim('  No active build or compilation processes detected.'));
+    console.log(chalk.dim('  (Supports: xcodebuild, cargo, swift build, make, ninja, bazel, go build)\n'));
+    return;
+  }
+
+  for (const b of builds) {
+    const elapsedMins = Math.floor(b.elapsedSec / 60);
+    const elapsedSecs = b.elapsedSec % 60;
+    const timeStr = elapsedMins > 0 ? `${elapsedMins}m ${elapsedSecs}s` : `${elapsedSecs}s`;
+
+    console.log(`  ${chalk.bgCyan.black.bold(` ${b.tool.toUpperCase()} `)}  ${chalk.bold(`PID ${b.rootPid}`)}`);
+    console.log(`    Command:          ${chalk.white(b.command)}`);
+    if (b.target) {
+      console.log(`    Target:           ${chalk.cyan(b.target)}`);
+    }
+    console.log(`    Compiler Workers: ${chalk.green.bold(String(b.compilerProcesses))} active thread/processes`);
+    console.log(`    Combined CPU:     ${chalk.yellow.bold(b.totalCpu.toFixed(1) + '%')}`);
+    console.log(`    Combined RAM:     ${chalk.magenta(b.totalMem.toFixed(1) + '%')}`);
+    console.log(`    Elapsed Time:     ${chalk.dim(timeStr)}`);
+    console.log();
+  }
+}

package/src/checkCmd.ts

@@ -15,7 +15,7 @@ export async function runCheckCommand(opts: CheckOptions = {}): Promise<void> {
   const cpuUsage = data.cpu.usage;
   const tempC = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die;
   const memUsage = data.memory.usagePercent;
-  const disk = data.disk.mainVolume;
+  const disk = data.disk && data.disk.length > 0 ? data.disk[0] : null;
 
   const sentences: string[] = [];
   let isWarning = false;
@@ -61,10 +61,10 @@ export async function runCheckCommand(opts: CheckOptions = {}): Promise<void> {
 
   // Disk sentence
   if (disk) {
-    const freeBytes = disk.free;
-    const freeStr = formatBytes(freeBytes);
-    sentences.push(`${freeStr} free on ${disk.mount}.`);
-    if (disk.usePercent >= 90) {
+    const freeStr = disk.available;
+    sentences.push(`${freeStr} free on ${disk.mountpoint}.`);
+    const cap = parseInt(disk.capacity, 10);
+    if (!isNaN(cap) && cap >= 90) {
       isWarning = true;
     }
   }

package/src/completions.ts

@@ -116,3 +116,38 @@ complete -c pyre -l sort -x -a "cpu mem pid user command state threads runtime"
 complete -c pyre -l temp-unit -x -a "c f" -d "Temperature unit"
 `;
 }
+
+export function generatePowerShellCompletions(): string {
+  return `# PowerShell completion for pyre
+Register-ArgumentCompleter -Native -CommandName pyre -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+    $commands = @('live', 'check', 'pipe', 'stress', 'ui', 'web', 'ssh', 'fleet', 'bench', 'benchmark', 'anomalies', 'doctor', 'extensions', 'brew', 'update', 'profile', 'config', 'history', 'diff', 'info', 'completions', 'p2p', 'blender', 'prometheus', 'smart', 'replay', 'explain')
+    $options = @('--json', '--html', '--md', '--csv', '--tsv', '--detailed', '--theme', '--interval', '--once', '--out', '--export-dir', '--log', '--tree', '--sort', '--packets', '--limit', '--alert-cpu', '--alert-temp', '--temp-unit', '--plain', '--help', '--version')
+
+    $elements = $commandAst.CommandElements
+    if ($elements.Count -le 2) {
+        $commands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+        }
+    }
+    $options | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+    }
+}
+`;
+}
+
+export function printCompletions(shell: string): void {
+  const s = (shell || '').toLowerCase();
+  if (s === 'bash') {
+    console.log(generateBashCompletions());
+  } else if (s === 'fish') {
+    console.log(generateFishCompletions());
+  } else if (s === 'powershell' || s === 'pwsh') {
+    console.log(generatePowerShellCompletions());
+  } else {
+    console.log(generateZshCompletions());
+  }
+}
+
+

package/src/doctor.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import os from 'node:os';
 import chalk from 'chalk';
 import { run } from './monitors/run.js';
 import { readConfig, CONFIG_FILE } from './state/config.js';
@@ -10,6 +12,13 @@ export interface DoctorCheck {
 }
 
 export async function runDoctor(): Promise<DoctorCheck[]> {
+  const platform = process.platform;
+  if (platform === 'linux') return runLinuxDoctor();
+  if (platform === 'win32') return runWindowsDoctor();
+  return runMacDoctor();
+}
+
+async function runMacDoctor(): Promise<DoctorCheck[]> {
   const checks: DoctorCheck[] = [];
 
   // 1. Sudo / Powermetrics Access
@@ -163,27 +172,246 @@ export async function runDoctor(): Promise<DoctorCheck[]> {
   }
 
   // 7. Config file integrity
+  checks.push(checkConfigIntegrity());
+
+  return checks;
+}
+
+async function runLinuxDoctor(): Promise<DoctorCheck[]> {
+  const checks: DoctorCheck[] = [];
+
+  // 1. Process Visibility
+  try {
+    const psCheck = await run('ps -eo pid,user,comm', '');
+    if (psCheck.length > 0) {
+      checks.push({
+        name: 'Process Visibility',
+        status: 'ok',
+        message: 'Full process table access available.',
+      });
+    } else {
+      checks.push({
+        name: 'Process Visibility',
+        status: 'warn',
+        message: 'Restricted process table access.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Process Visibility',
+      status: 'error',
+      message: 'Unable to query process list.',
+    });
+  }
+
+  // 2. /proc and /sys Telemetry Access
+  try {
+    const statExists = fs.existsSync('/proc/stat');
+    const memExists = fs.existsSync('/proc/meminfo');
+    if (statExists && memExists) {
+      checks.push({
+        name: 'Kernel Telemetry (/proc)',
+        status: 'ok',
+        message: 'Kernel telemetry interfaces readable.',
+      });
+    } else {
+      checks.push({
+        name: 'Kernel Telemetry (/proc)',
+        status: 'error',
+        message: 'Core pseudo-filesystems (/proc) unavailable or restricted.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Kernel Telemetry (/proc)',
+      status: 'warn',
+      message: 'Could not check /proc readability.',
+    });
+  }
+
+  // 3. Thermal & Hardware Sensors
+  try {
+    const thermZones = fs.existsSync('/sys/class/thermal');
+    const hwmon = fs.existsSync('/sys/class/hwmon');
+    if (thermZones || hwmon) {
+      checks.push({
+        name: 'Hardware Sensors (/sys)',
+        status: 'ok',
+        message: 'Thermal and hardware monitoring sensors detected.',
+      });
+    } else {
+      checks.push({
+        name: 'Hardware Sensors (/sys)',
+        status: 'warn',
+        message: 'No hardware sensor paths detected in /sys/class.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Hardware Sensors (/sys)',
+      status: 'warn',
+      message: 'Unable to query sensor interfaces.',
+    });
+  }
+
+  // 4. Network Reachability
+  try {
+    const netCheck = await run('ip route 2>/dev/null || route -n 2>/dev/null', '');
+    if (netCheck.includes('default') || netCheck.includes('0.0.0.0')) {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'ok',
+        message: 'Active default route detected.',
+      });
+    } else {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'warn',
+        message: 'No default network gateway detected.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Network Reachability',
+      status: 'warn',
+      message: 'Could not verify network routes.',
+    });
+  }
+
+  // 5. Systemd User Service Capability
+  try {
+    const sysctlRes = await run('systemctl --user status 2>&1', '');
+    if (!sysctlRes.includes('Failed to connect to bus') && !sysctlRes.includes('not found')) {
+      checks.push({
+        name: 'Systemd User Daemon',
+        status: 'ok',
+        message: 'Systemd user session active (ready for pyre --install).',
+      });
+    } else {
+      checks.push({
+        name: 'Systemd User Daemon',
+        status: 'warn',
+        message: 'Systemd user session not available.',
+        details: 'Background services via pyre --install require an active user systemd session.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Systemd User Daemon',
+      status: 'warn',
+      message: 'Systemd check skipped.',
+    });
+  }
+
+  // 6. Config file integrity
+  checks.push(checkConfigIntegrity());
+
+  return checks;
+}
+
+async function runWindowsDoctor(): Promise<DoctorCheck[]> {
+  const checks: DoctorCheck[] = [];
+
+  // 1. Process Visibility
   try {
-    const cfg = readConfig();
+    const psCheck = await run('tasklist /nh 2>nul', '');
+    if (psCheck.length > 0) {
+      checks.push({
+        name: 'Process Visibility',
+        status: 'ok',
+        message: 'Windows process table access available.',
+      });
+    } else {
+      checks.push({
+        name: 'Process Visibility',
+        status: 'warn',
+        message: 'Tasklist query returned no output.',
+      });
+    }
+  } catch {
     checks.push({
+      name: 'Process Visibility',
+      status: 'error',
+      message: 'Unable to query Windows tasklist.',
+    });
+  }
+
+  // 2. PowerShell / WMI Interface
+  try {
+    const wmiCheck = await run('wmic os get Caption 2>nul || powershell -Command "(Get-CimInstance Win32_OperatingSystem).Caption"', '');
+    if (wmiCheck.toLowerCase().includes('windows')) {
+      checks.push({
+        name: 'WMI / CIM Subsystem',
+        status: 'ok',
+        message: 'WMI/CIM management queries responsive.',
+      });
+    } else {
+      checks.push({
+        name: 'WMI / CIM Subsystem',
+        status: 'warn',
+        message: 'WMI/CIM query did not return expected response.',
+        details: 'Some hardware metrics (disks, thermal) rely on WMI or PowerShell CIM.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'WMI / CIM Subsystem',
+      status: 'warn',
+      message: 'Could not execute WMI query.',
+    });
+  }
+
+  // 3. Network Reachability
+  try {
+    const netCheck = await run('netstat -rn 2>nul', '');
+    if (netCheck.includes('0.0.0.0')) {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'ok',
+        message: 'Active default IPv4 gateway detected.',
+      });
+    } else {
+      checks.push({
+        name: 'Network Reachability',
+        status: 'warn',
+        message: 'No default route detected in routing table.',
+      });
+    }
+  } catch {
+    checks.push({
+      name: 'Network Reachability',
+      status: 'warn',
+      message: 'Could not verify Windows network routes.',
+    });
+  }
+
+  // 4. Config file integrity
+  checks.push(checkConfigIntegrity());
+
+  return checks;
+}
+
+function checkConfigIntegrity(): DoctorCheck {
+  try {
+    readConfig();
+    return {
       name: 'Configuration File',
       status: 'ok',
       message: `Config file valid (${CONFIG_FILE}).`,
-    });
+    };
   } catch (err: any) {
-    checks.push({
+    return {
       name: 'Configuration File',
       status: 'error',
       message: 'Failed to parse config file.',
       details: err.message,
-    });
+    };
   }
-
-  return checks;
 }
 
 export function printDoctorReport(checks: DoctorCheck[]): void {
-  console.log(chalk.bold('\n  pyre doctor — System Diagnostics\n'));
+  const osLabel = process.platform === 'darwin' ? 'macOS' : (process.platform === 'win32' ? 'Windows' : 'Linux');
+  console.log(chalk.bold(`\n  pyre doctor — System Diagnostics (${osLabel})\n`));
 
   for (const check of checks) {
     let icon = chalk.green('✔');

package/src/easy_features.test.ts

@@ -1,5 +1,10 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
+import path from 'node:path';
+import fs from 'node:fs';
+
+process.env.PYRE_CONFIG_DIR = path.join(process.cwd(), 'node_modules', '.test-pyre-config');
+
 import { parseSystemExtensionsOutput } from './extensions.js';
 import { saveProfile, loadProfile, listProfiles } from './state/config.js';
 import { sparkline } from './sparkline.js';
@@ -41,3 +46,38 @@ describe('Plain text sparkline (Feature F3)', () => {
     assert.strictEqual(res, '[10.0 -> 30.0 (Δ:+20.0)]');
   });
 });
+
+describe('Cross-Platform Support', () => {
+  it('should generate valid PowerShell completions script', async () => {
+    const { generatePowerShellCompletions } = await import('./completions.js');
+    const ps = generatePowerShellCompletions();
+    assert.ok(ps.includes('Register-ArgumentCompleter'));
+    assert.ok(ps.includes('CommandName pyre'));
+    assert.ok(ps.includes('live'));
+    assert.ok(ps.includes('--json'));
+  });
+
+  it('should run doctor diagnostics without crashing on any platform', async () => {
+    const { runDoctor } = await import('./doctor.js');
+    const checks = await runDoctor();
+    assert.ok(Array.isArray(checks));
+    assert.ok(checks.length > 0);
+    for (const c of checks) {
+      assert.ok(['ok', 'warn', 'error'].includes(c.status));
+      assert.ok(typeof c.name === 'string');
+      assert.ok(typeof c.message === 'string');
+    }
+  });
+
+  it('should collect telemetry across subsystems without crashing', async () => {
+    const { collectAll } = await import('./monitors/index.js');
+    const data = await collectAll();
+    assert.ok(data.header.hostname.length > 0);
+    assert.ok(data.header.os.length > 0);
+    assert.ok(data.cpu.cores >= 1);
+    assert.ok(data.memory.total > 0);
+    assert.ok(Array.isArray(data.disk));
+    assert.ok(typeof data.network.interface === 'string');
+  });
+});
+