pyre-cli 10.3.0 → 10.4.0

package/dist/{syncCmd-42IRF633.js → syncCmd-MIBFKX24.js}

@@ -3,7 +3,8 @@ import {
   getProfilesDir,
   readConfig,
   writeConfig
-} from "./chunk-QM5L43EK.js";
+} from "./chunk-LDJB5V4N.js";
+import "./chunk-3RG5ZIWI.js";
 
 // src/syncCmd.ts
 import fs from "fs";
@@ -13,6 +14,16 @@ import crypto from "crypto";
 import chalk from "chalk";
 function getDefaultSyncDir() {
   if (process.env.PYRE_SYNC_DIR) return process.env.PYRE_SYNC_DIR;
+  if (process.platform === "win32") {
+    const oneDriveEnv = process.env.OneDrive || process.env.OneDriveConsumer;
+    if (oneDriveEnv && fs.existsSync(oneDriveEnv)) {
+      return path.join(oneDriveEnv, "PyreSync");
+    }
+    const userOneDrive = path.join(os.homedir(), "OneDrive");
+    if (fs.existsSync(userOneDrive)) {
+      return path.join(userOneDrive, "PyreSync");
+    }
+  }
   const icloudPath = path.join(os.homedir(), "Library", "Mobile Documents", "com~apple~CloudDocs", "PyreSync");
   if (fs.existsSync(path.dirname(icloudPath))) {
     return icloudPath;
@@ -71,7 +82,7 @@ async function runFirebaseSubcommand(action) {
       console.log(chalk.dim('  Run "pyre sync firebase enable" to activate.\n'));
       return;
     }
-    const { firebaseStatus } = await import("./firebaseSync-ON3RZ6KX.js");
+    const { firebaseStatus } = await import("./firebaseSync-LRN67UTV.js");
     const hosts = await firebaseStatus();
     if (hosts.length === 0) {
       console.log(chalk.dim('  No remote hosts found in Firestore. Run "pyre sync push" to upload.\n'));
@@ -102,7 +113,7 @@ async function runSyncCommand(subcommand = "status", opts = {}) {
     console.log(`  Backend: ${chalk.cyan("Firebase Firestore")} (${chalk.dim("dearborn-internal-tool")})`);
     const hostId = config.firebaseHostId || void 0;
     if (subcommand === "status") {
-      const { firebaseStatus } = await import("./firebaseSync-ON3RZ6KX.js");
+      const { firebaseStatus } = await import("./firebaseSync-LRN67UTV.js");
       const hosts = await firebaseStatus();
       if (hosts.length === 0) {
         console.log(chalk.dim('  No remote hosts found. Run "pyre sync push" to upload your config.\n'));
@@ -119,7 +130,7 @@ async function runSyncCommand(subcommand = "status", opts = {}) {
       return;
     }
     if (subcommand === "push") {
-      const { firebasePush } = await import("./firebaseSync-ON3RZ6KX.js");
+      const { firebasePush } = await import("./firebaseSync-LRN67UTV.js");
       const profiles = loadLocalProfiles();
       const result = await firebasePush(config, profiles, hostId);
       const profileCount = Object.keys(profiles).length;
@@ -132,7 +143,7 @@ async function runSyncCommand(subcommand = "status", opts = {}) {
     if (subcommand === "pull") {
       const targetHost = process.argv[process.argv.indexOf("pull") + 1];
       const resolvedTarget = targetHost && !targetHost.startsWith("-") ? targetHost : void 0;
-      const { firebasePull } = await import("./firebaseSync-ON3RZ6KX.js");
+      const { firebasePull } = await import("./firebaseSync-LRN67UTV.js");
       const result = await firebasePull(resolvedTarget);
       if (!result) {
         const hint = resolvedTarget ? `host "${resolvedTarget}"` : "any host";

package/dist/topoCmd-RTXQJ6XA.js

@@ -0,0 +1,189 @@
+import {
+  collectNetwork
+} from "./chunk-QEH4LR6P.js";
+import "./chunk-NMGQVRCA.js";
+import "./chunk-FYCBGUTW.js";
+import "./chunk-OCL7P7N7.js";
+import {
+  run,
+  runPowerShell
+} from "./chunk-MZO5QKUR.js";
+import "./chunk-3RG5ZIWI.js";
+
+// src/topoCmd.ts
+import net from "net";
+import os from "os";
+import chalk from "chalk";
+async function probePort(ip, port, timeoutMs = 400) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.connect(port, ip);
+  });
+}
+async function getDefaultGateway() {
+  if (process.platform === "win32") {
+    try {
+      const raw = await runPowerShell(
+        `(Get-NetRoute -DestinationPrefix '0.0.0.0/0' -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty NextHop)`,
+        ""
+      );
+      if (raw.trim() && raw.trim() !== "0.0.0.0") return raw.trim();
+    } catch {
+    }
+    try {
+      const rawCim = await runPowerShell(
+        `(Get-CimInstance Win32_NetworkAdapterConfiguration -Filter "IPEnabled = TRUE" -ErrorAction SilentlyContinue | Select-Object -First 1 -ExpandProperty DefaultIPGateway) -join ''`,
+        ""
+      );
+      if (rawCim.trim()) return rawCim.trim();
+    } catch {
+    }
+  }
+  try {
+    const raw = await run("route -n get default 2>/dev/null | grep gateway | awk '{print $2}'", "");
+    if (raw.trim()) return raw.trim();
+  } catch {
+  }
+  try {
+    const raw = await run("netstat -nr 2>/dev/null | grep default | awk '{print $2}' | head -n1", "");
+    if (raw.trim()) return raw.trim();
+  } catch {
+  }
+  return "192.168.1.1";
+}
+function parseWindowsArpOutput(raw, gatewayIp) {
+  const peers = [];
+  let currentIface = "Ethernet";
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    const ifaceMatch = trimmed.match(/Interface:\s*([\d.]+)/i);
+    if (ifaceMatch) {
+      currentIface = ifaceMatch[1];
+      continue;
+    }
+    const match = trimmed.match(/^([\d.]+)\s+([0-9a-fA-F-]+)\s+(\w+)/);
+    if (match) {
+      const ip = match[1];
+      const mac = match[2].replace(/-/g, ":");
+      if (ip === "255.255.255.255" || ip.startsWith("224.") || mac.includes("ff:ff:ff")) continue;
+      peers.push({
+        ip,
+        mac,
+        interface: currentIface,
+        isGateway: ip === gatewayIp
+      });
+    }
+  }
+  return peers;
+}
+async function getArpNeighbors(gatewayIp) {
+  const peers = [];
+  try {
+    if (process.platform === "win32") {
+      const raw2 = await run("arp -a 2>nul", "");
+      return parseWindowsArpOutput(raw2, gatewayIp);
+    }
+    const raw = await run("arp -a -n 2>/dev/null", "");
+    const lines = raw.split("\n");
+    for (const line of lines) {
+      const match = line.match(/\(([\d.]+)\)\s+at\s+([0-9a-fA-F:]+)\s+on\s+(\S+)/);
+      if (match) {
+        const ip = match[1];
+        const mac = match[2];
+        const iface = match[3];
+        if (ip === "255.255.255.255" || ip.startsWith("224.") || mac.includes("incomplete")) continue;
+        peers.push({
+          ip,
+          mac,
+          interface: iface,
+          isGateway: ip === gatewayIp
+        });
+      }
+    }
+  } catch {
+  }
+  return peers;
+}
+async function runTopoCommand(opts = {}) {
+  const localNet = await collectNetwork();
+  const gatewayIp = await getDefaultGateway();
+  const lanPeers = await getArpNeighbors(gatewayIp);
+  const hostname = os.hostname();
+  if (opts.scan || lanPeers.length <= 15) {
+    await Promise.all(
+      lanPeers.map(async (peer) => {
+        const [hasP2P, hasRest] = await Promise.all([
+          probePort(peer.ip, 9876, 250),
+          probePort(peer.ip, 8080, 250)
+        ]);
+        peer.pyreP2P = hasP2P;
+        peer.pyreRest = hasRest;
+      })
+    );
+  }
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          local: {
+            hostname,
+            ip: localNet.ip,
+            interface: localNet.interface,
+            gateway: gatewayIp
+          },
+          lanPeers
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(chalk.bold("\n  \u{1F5FA}  pyre topo \u2014 Network Topology Map\n"));
+  console.log(chalk.bold("  Local Node:"));
+  console.log(`    Hostname:  ${chalk.cyan(hostname)}`);
+  console.log(`    IP:        ${chalk.green(localNet.ip)}`);
+  console.log(`    Interface: ${localNet.interface}`);
+  console.log(`    Gateway:   ${chalk.yellow(gatewayIp)}`);
+  console.log();
+  console.log(chalk.bold(`  LAN Neighbors & Nodes (${lanPeers.length} discovered via ARP):`));
+  console.log(chalk.dim("  " + "\u2500".repeat(74)));
+  if (lanPeers.length === 0) {
+    console.log(chalk.dim("    No active ARP neighbors found in cache.\n"));
+    return;
+  }
+  for (const peer of lanPeers) {
+    const isGw = peer.isGateway ? chalk.yellow(" [Default Gateway]") : "";
+    const pyreBadge = peer.pyreP2P ? chalk.green.bold(" \u{1F525} PYRE PEER") : "";
+    const restBadge = peer.pyreRest ? chalk.blue(" (REST API)") : "";
+    console.log(`    \u2022 ${chalk.bold(peer.ip.padEnd(16))} ${chalk.dim(peer.mac.padEnd(20))} [${peer.interface}]${isGw}${pyreBadge}${restBadge}`);
+  }
+  console.log();
+  const pyrePeers = lanPeers.filter((p) => p.pyreP2P);
+  if (pyrePeers.length > 0) {
+    console.log(chalk.green(`  \u2714 Found ${pyrePeers.length} active Pyre node(s) on your LAN!`));
+    console.log(chalk.dim(`  Connect using: pyre p2p connect --p2p-host ${pyrePeers[0].ip}
+`));
+  } else {
+    console.log(chalk.dim("  Tip: Pass --scan to sweep and test pyre ports on discovered LAN neighbors.\n"));
+  }
+}
+export {
+  getArpNeighbors,
+  getDefaultGateway,
+  parseWindowsArpOutput,
+  runTopoCommand
+};

package/dist/{updateCheck-52X6LJG5.js → updateCheck-LJHEMG3G.js}

@@ -1,3 +1,5 @@
+import "./chunk-3RG5ZIWI.js";
+
 // src/updateCheck.ts
 import fs from "fs";
 import path from "path";

package/dist/{watchdogCmd-6GR4UN6B.js → watchdogCmd-XM6OPTKM.js}

@@ -1,8 +1,9 @@
 import {
   collectAll
-} from "./chunk-23YWCI3O.js";
-import "./chunk-M73HCQD2.js";
-import "./chunk-VIACN2RU.js";
+} from "./chunk-QEH4LR6P.js";
+import "./chunk-NMGQVRCA.js";
+import "./chunk-FYCBGUTW.js";
+import "./chunk-OCL7P7N7.js";
 import {
   sendAlert
 } from "./chunk-Z2YV5HKV.js";
@@ -10,11 +11,13 @@ import "./chunk-MZO5QKUR.js";
 import {
   getConfigDir,
   readConfig
-} from "./chunk-QM5L43EK.js";
+} from "./chunk-LDJB5V4N.js";
+import "./chunk-3RG5ZIWI.js";
 
 // src/watchdogCmd.ts
 import fs from "fs";
 import path from "path";
+import { execSync } from "child_process";
 import chalk from "chalk";
 var DEFAULT_WATCHDOG_RULES = [
   {
@@ -121,12 +124,44 @@ async function runWatchdogCommand(opts = {}) {
           }
           if (rule.action === "kill" && targetPid) {
             try {
-              process.kill(targetPid, "SIGTERM");
-              console.log(chalk.green(`    \u2714 Killed PID ${targetPid} with SIGTERM`));
+              if (process.platform === "win32") {
+                execSync(`taskkill /F /PID ${targetPid} /T`, { stdio: "pipe" });
+                console.log(chalk.green(`    \u2714 Killed PID ${targetPid} with taskkill /F /T`));
+              } else {
+                process.kill(targetPid, "SIGTERM");
+                console.log(chalk.green(`    \u2714 Killed PID ${targetPid} with SIGTERM`));
+              }
             } catch (err) {
               console.log(chalk.red(`    \u2716 Failed to kill PID ${targetPid}: ${err.message}`));
             }
           }
+          if (rule.action === "renice" && targetPid) {
+            try {
+              execSync(`renice +10 -p ${targetPid}`, { stdio: "pipe" });
+              console.log(chalk.green(`    \u2714 Deprioritized runaway PID ${targetPid} to nice +10`));
+            } catch (err) {
+              console.log(chalk.red(`    \u2716 Failed to renice PID ${targetPid}: ${err.message}`));
+            }
+          }
+          if (rule.action === "command" && rule.command) {
+            try {
+              console.log(chalk.cyan(`    \u25B6 Executing remediation command: ${rule.command}`));
+              execSync(rule.command, { stdio: "pipe" });
+              console.log(chalk.green(`    \u2714 Remediation command executed successfully.`));
+            } catch (err) {
+              console.log(chalk.red(`    \u2716 Remediation command failed: ${err.message}`));
+            }
+          }
+          if (rule.dumpFlight) {
+            try {
+              const { captureCurrentFlightFrame, globalFlightRecorder } = await import("./flightRecorder-GJIAQOXC.js");
+              const frame = await captureCurrentFlightFrame();
+              globalFlightRecorder.push(frame);
+              const path2 = globalFlightRecorder.dump();
+              console.log(chalk.green(`    \u2714 Forensic flight recording dumped: ${path2}`));
+            } catch {
+            }
+          }
           if (rule.action === "alert") {
             await sendAlert({
               metric: rule.name,

package/dist/{wizard-JQMQWFAW.js → wizard-PRDOJROQ.js}

@@ -1,7 +1,8 @@
 import {
   CONFIG_FILE,
   writeConfig
-} from "./chunk-QM5L43EK.js";
+} from "./chunk-LDJB5V4N.js";
+import "./chunk-3RG5ZIWI.js";
 
 // src/wizard.ts
 import readline from "readline";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-cli",
-  "version": "10.3.0",
+  "version": "10.4.0",
   "description": "Cross-platform system monitoring CLI for macOS, Linux, and Windows: temps, system stats, live dashboard, packet monitor, battery predictor, export",
   "main": "dist/index.js",
   "type": "module",
@@ -21,7 +21,7 @@
     "build": "tsup src/index.ts --format esm --clean",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
-    "test": "node dist/index.js --help && tsx --test src/easy_features.test.ts src/platform.test.ts"
+    "test": "node dist/index.js --help && tsx --test src/easy_features.test.ts src/platform.test.ts src/menu.test.ts src/power_features.test.ts"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/benchGitCmd.ts

@@ -0,0 +1,110 @@
+/**
+ * pyre bench-git — Git Branch Performance Differ.
+ *
+ * Automatically benchmarks a test or build command across two git branches
+ * or commits, computing delta percentages for execution duration, peak RAM,
+ * and CPU utilization.
+ */
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { runWithBudget, formatBytes } from './budgetCmd.js';
+
+export interface BranchMetric {
+  branch: string;
+  durationSec: number;
+  peakMemoryBytes: number;
+  peakCpuPct: number;
+  exitCode: number;
+}
+
+export async function runBenchGitCommand(branchA: string, branchB: string, commandStr: string): Promise<void> {
+  // 1. Verify git repo and clean status
+  try {
+    const status = execSync('git status --porcelain', { encoding: 'utf-8' }).trim();
+    if (status) {
+      console.error(chalk.red('\n  ✖ Working directory contains uncommitted changes.'));
+      console.log(chalk.yellow('  Please commit or stash your changes before running `pyre bench-git`.\n'));
+      return;
+    }
+  } catch (err: any) {
+    console.error(chalk.red(`\n  ✖ Not a git repository: ${err.message}`));
+    return;
+  }
+
+  const startingBranch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+  console.log(chalk.bold(`\n  🔥 pyre bench-git — Cross-Branch Performance Differ\n`));
+  console.log(chalk.dim(`  Command:         ${commandStr}`));
+  console.log(chalk.dim(`  Baseline Branch: ${branchA}`));
+  console.log(chalk.dim(`  Target Branch:   ${branchB}`));
+  console.log(chalk.dim(`  Current Branch:  ${startingBranch}\n`));
+
+  const tokens = commandStr.split(/\s+/).filter(Boolean);
+
+  try {
+    // Benchmark Branch A
+    console.log(chalk.bold.cyan(`▶ [1/2] Checking out '${branchA}' and benchmarking...`));
+    execSync(`git checkout ${branchA}`, { stdio: 'pipe' });
+    const resA = await runWithBudget(tokens, {});
+
+    // Benchmark Branch B
+    console.log(chalk.bold.cyan(`\n▶ [2/2] Checking out '${branchB}' and benchmarking...`));
+    execSync(`git checkout ${branchB}`, { stdio: 'pipe' });
+    const resB = await runWithBudget(tokens, {});
+
+    // Restore original branch
+    execSync(`git checkout ${startingBranch}`, { stdio: 'pipe' });
+    console.log(chalk.dim(`\n  Restored workspace to '${startingBranch}'.`));
+
+    // Print side-by-side comparison
+    printGitComparisonTable(branchA, branchB, resA, resB);
+  } catch (err: any) {
+    // Ensure we attempt to restore branch
+    try {
+      execSync(`git checkout ${startingBranch}`, { stdio: 'pipe' });
+    } catch {}
+    console.error(chalk.red(`\n  ✖ Benchmark failed: ${err.message}`));
+  }
+}
+
+function printGitComparisonTable(branchA: string, branchB: string, resA: any, resB: any) {
+  const diffPct = (valA: number, valB: number, invertGood = false) => {
+    if (valA === 0) return '0%';
+    const delta = ((valB - valA) / valA) * 100;
+    const sign = delta > 0 ? '+' : '';
+    const formatted = `${sign}${delta.toFixed(1)}%`;
+    const isGood = invertGood ? delta > 0 : delta < 0;
+    const color = delta === 0 ? chalk.dim : isGood ? chalk.green : chalk.red;
+    return color(formatted);
+  };
+
+  console.log(chalk.bold('\n  ─────────────────────────────────────────────────────────────'));
+  console.log(chalk.bold('  🔥 Cross-Branch Performance Comparison Results'));
+  console.log(chalk.dim('  ─────────────────────────────────────────────────────────────'));
+
+  const colBranchA = branchA.padEnd(16);
+  const colBranchB = branchB.padEnd(16);
+  console.log(`  ${'Metric'.padEnd(18)} ${colBranchA} ${colBranchB} Delta`);
+  console.log(chalk.dim('  ─'.repeat(30)));
+
+  // Duration
+  const durA = `${resA.durationSec.toFixed(2)}s`.padEnd(16);
+  const durB = `${resB.durationSec.toFixed(2)}s`.padEnd(16);
+  console.log(`  ${'Duration'.padEnd(18)} ${durA} ${durB} ${diffPct(resA.durationSec, resB.durationSec)}`);
+
+  // Peak RAM
+  const ramA = formatBytes(resA.peakMemoryBytes).padEnd(16);
+  const ramB = formatBytes(resB.peakMemoryBytes).padEnd(16);
+  console.log(`  ${'Peak Memory'.padEnd(18)} ${ramA} ${ramB} ${diffPct(resA.peakMemoryBytes, resB.peakMemoryBytes)}`);
+
+  // Peak CPU
+  const cpuA = `${resA.peakCpuPct.toFixed(1)}%`.padEnd(16);
+  const cpuB = `${resB.peakCpuPct.toFixed(1)}%`.padEnd(16);
+  console.log(`  ${'Peak CPU'.padEnd(18)} ${cpuA} ${cpuB} ${diffPct(resA.peakCpuPct, resB.peakCpuPct)}`);
+
+  // Exit code
+  const codeA = `${resA.exitCode}`.padEnd(16);
+  const codeB = `${resB.exitCode}`.padEnd(16);
+  console.log(`  ${'Exit Code'.padEnd(18)} ${codeA} ${codeB}`);
+
+  console.log(chalk.dim('  ─────────────────────────────────────────────────────────────\n'));
+}

package/src/budgetCmd.ts

@@ -0,0 +1,199 @@
+/**
+ * pyre run — Performance Budgeting Runner.
+ *
+ * Spawns an arbitrary command and tracks its execution lifecycle,
+ * measuring runtime duration, peak RSS memory, and CPU utilization.
+ * Enforces budgets (--budget-cpu, --budget-mem, --budget-time), exiting
+ * with code 124 if thresholds are exceeded (ideal for CI/CD gates).
+ */
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+
+export interface BudgetLimits {
+  maxCpuPct?: number;
+  maxMemoryBytes?: number;
+  maxTimeSec?: number;
+}
+
+export interface BudgetRunResult {
+  command: string;
+  exitCode: number;
+  durationSec: number;
+  peakCpuPct: number;
+  avgCpuPct: number;
+  peakMemoryBytes: number;
+  violations: string[];
+}
+
+export function parseBytesString(s: string): number {
+  const trimmed = s.trim().toUpperCase();
+  const num = parseFloat(trimmed);
+  if (isNaN(num)) return 0;
+  if (trimmed.endsWith('G') || trimmed.endsWith('GB')) return num * 1024 * 1024 * 1024;
+  if (trimmed.endsWith('M') || trimmed.endsWith('MB')) return num * 1024 * 1024;
+  if (trimmed.endsWith('K') || trimmed.endsWith('KB')) return num * 1024;
+  return num;
+}
+
+export function formatBytes(b: number): string {
+  if (b >= 1024 * 1024 * 1024) return `${(b / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+  if (b >= 1024 * 1024) return `${(b / (1024 * 1024)).toFixed(2)} MB`;
+  if (b >= 1024) return `${(b / 1024).toFixed(1)} KB`;
+  return `${b} B`;
+}
+
+export async function runWithBudget(
+  commandArgs: string[],
+  budgets: BudgetLimits,
+  opts?: { markdown?: boolean; outFile?: string }
+): Promise<BudgetRunResult> {
+  if (commandArgs.length === 0) {
+    throw new Error('No command specified. Usage: pyre run [budget flags] -- <command>');
+  }
+
+  const cmdStr = commandArgs.join(' ');
+  const [bin, ...args] = commandArgs;
+
+  const startTime = Date.now();
+  const cpuSamples: number[] = [];
+  let peakMemBytes = 0;
+  let peakCpu = 0;
+
+  const child = spawn(bin, args, {
+    stdio: 'inherit',
+    env: process.env,
+  });
+
+  const pid = child.pid;
+  let sampleInterval: NodeJS.Timeout | null = null;
+
+  if (pid) {
+    sampleInterval = setInterval(() => {
+      try {
+        // Sample RSS memory using ps
+        const { execSync } = require('node:child_process');
+        const output = execSync(`ps -o %cpu,rss -p ${pid} 2>/dev/null`, { encoding: 'utf-8' });
+        const lines = output.trim().split('\n');
+        if (lines.length > 1) {
+          const parts = lines[1].trim().split(/\s+/);
+          const cpu = parseFloat(parts[0]) || 0;
+          const rssKb = parseInt(parts[1], 10) || 0;
+          const memBytes = rssKb * 1024;
+
+          cpuSamples.push(cpu);
+          if (cpu > peakCpu) peakCpu = cpu;
+          if (memBytes > peakMemBytes) peakMemBytes = memBytes;
+        }
+      } catch {
+        // Child exited
+      }
+    }, 100);
+  }
+
+  const exitCode = await new Promise<number>((resolve) => {
+    child.on('close', (code) => {
+      if (sampleInterval) clearInterval(sampleInterval);
+      resolve(code ?? 0);
+    });
+    child.on('error', () => {
+      if (sampleInterval) clearInterval(sampleInterval);
+      resolve(1);
+    });
+  });
+
+  const durationSec = (Date.now() - startTime) / 1000;
+  const avgCpu = cpuSamples.length > 0 ? cpuSamples.reduce((a, b) => a + b, 0) / cpuSamples.length : peakCpu;
+
+  // Evaluate budget limits
+  const violations: string[] = [];
+  if (budgets.maxTimeSec !== undefined && durationSec > budgets.maxTimeSec) {
+    violations.push(`Runtime exceeded budget: ${durationSec.toFixed(2)}s > ${budgets.maxTimeSec}s limit`);
+  }
+  if (budgets.maxMemoryBytes !== undefined && peakMemBytes > budgets.maxMemoryBytes) {
+    violations.push(`Memory exceeded budget: ${formatBytes(peakMemBytes)} > ${formatBytes(budgets.maxMemoryBytes)} limit`);
+  }
+  if (budgets.maxCpuPct !== undefined && peakCpu > budgets.maxCpuPct) {
+    violations.push(`CPU exceeded budget: ${peakCpu.toFixed(1)}% > ${budgets.maxCpuPct}% limit`);
+  }
+
+  const result: BudgetRunResult = {
+    command: cmdStr,
+    exitCode,
+    durationSec,
+    peakCpuPct: peakCpu,
+    avgCpuPct: avgCpu,
+    peakMemoryBytes: peakMemBytes,
+    violations,
+  };
+
+  printBudgetReport(result, budgets, opts);
+  return result;
+}
+
+function printBudgetReport(result: BudgetRunResult, budgets: BudgetLimits, opts?: { markdown?: boolean; outFile?: string }) {
+  const isViolated = result.violations.length > 0;
+  const isFailed = result.exitCode !== 0 || isViolated;
+
+  console.log(chalk.bold('\n  ─────────────────────────────────────────────────────────────'));
+  console.log(chalk.bold(`  🔥 pyre run — Performance Budget Report`));
+  console.log(chalk.dim(`  Command: ${result.command}`));
+  console.log(chalk.dim('  ─────────────────────────────────────────────────────────────'));
+
+  // Table rows
+  const statusTime = budgets.maxTimeSec === undefined
+    ? chalk.dim('unconstrained')
+    : result.durationSec <= budgets.maxTimeSec
+    ? chalk.green(`✔ Pass (<= ${budgets.maxTimeSec}s)`)
+    : chalk.red(`✖ FAIL (> ${budgets.maxTimeSec}s)`);
+
+  const statusMem = budgets.maxMemoryBytes === undefined
+    ? chalk.dim('unconstrained')
+    : result.peakMemoryBytes <= budgets.maxMemoryBytes
+    ? chalk.green(`✔ Pass (<= ${formatBytes(budgets.maxMemoryBytes)})`)
+    : chalk.red(`✖ FAIL (> ${formatBytes(budgets.maxMemoryBytes)})`);
+
+  const statusCpu = budgets.maxCpuPct === undefined
+    ? chalk.dim('unconstrained')
+    : result.peakCpuPct <= budgets.maxCpuPct
+    ? chalk.green(`✔ Pass (<= ${budgets.maxCpuPct}%)`)
+    : chalk.red(`✖ FAIL (> ${budgets.maxCpuPct}%)`);
+
+  console.log(`  Duration:    ${result.durationSec.toFixed(2)}s`.padEnd(28) + statusTime);
+  console.log(`  Peak Memory: ${formatBytes(result.peakMemoryBytes)}`.padEnd(28) + statusMem);
+  console.log(`  Peak CPU:    ${result.peakCpuPct.toFixed(1)}% (avg ${result.avgCpuPct.toFixed(1)}%)`.padEnd(28) + statusCpu);
+  console.log(`  Exit Code:   ${result.exitCode === 0 ? chalk.green('0') : chalk.red(result.exitCode)}`);
+
+  if (isViolated) {
+    console.log(chalk.bold.red('\n  ✖ Performance Budget Violations:'));
+    result.violations.forEach((v) => console.log(chalk.red(`    • ${v}`)));
+  }
+
+  console.log(chalk.dim('  ─────────────────────────────────────────────────────────────\n'));
+
+  if (opts?.outFile || opts?.markdown) {
+    const md = generateMarkdownBudgetReport(result, budgets);
+    if (opts.outFile) {
+      fs.writeFileSync(opts.outFile, md, 'utf-8');
+      console.log(chalk.dim(`  Saved report to ${opts.outFile}\n`));
+    }
+  }
+}
+
+function generateMarkdownBudgetReport(result: BudgetRunResult, budgets: BudgetLimits): string {
+  return [
+    `# Pyre Performance Budget Report`,
+    ``,
+    `**Command**: \`${result.command}\`  `,
+    `**Status**: ${result.violations.length === 0 && result.exitCode === 0 ? '✅ PASSED' : '❌ FAILED'}  `,
+    `**Exit Code**: \`${result.exitCode}\`  `,
+    ``,
+    `| Metric | Measured | Limit | Status |`,
+    `| :--- | :--- | :--- | :--- |`,
+    `| Duration | ${result.durationSec.toFixed(2)}s | ${budgets.maxTimeSec ? budgets.maxTimeSec + 's' : 'N/A'} | ${budgets.maxTimeSec && result.durationSec > budgets.maxTimeSec ? '❌ FAIL' : '✅ PASS'} |`,
+    `| Peak Memory | ${formatBytes(result.peakMemoryBytes)} | ${budgets.maxMemoryBytes ? formatBytes(budgets.maxMemoryBytes) : 'N/A'} | ${budgets.maxMemoryBytes && result.peakMemoryBytes > budgets.maxMemoryBytes ? '❌ FAIL' : '✅ PASS'} |`,
+    `| Peak CPU | ${result.peakCpuPct.toFixed(1)}% | ${budgets.maxCpuPct ? budgets.maxCpuPct + '%' : 'N/A'} | ${budgets.maxCpuPct && result.peakCpuPct > budgets.maxCpuPct ? '❌ FAIL' : '✅ PASS'} |`,
+    ``,
+    ...(result.violations.length > 0 ? [`### Violations`, ...result.violations.map((v) => `- ${v}`)] : []),
+  ].join('\n');
+}