bgrun 3.12.0 → 3.12.2

package/dist/index.js

@@ -1,23 +1,66 @@
 #!/usr/bin/env bun
 // @bun
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/platform.ts
+var exports_platform = {};
+__export(exports_platform, {
+  waitForPortFree: () => waitForPortFree,
+  terminateProcess: () => terminateProcess,
+  reconcileProcessPids: () => reconcileProcessPids,
+  readFileTail: () => readFileTail,
+  psExec: () => psExec,
+  killProcessOnPort: () => killProcessOnPort,
+  isWindows: () => isWindows,
+  isProcessRunning: () => isProcessRunning,
+  isPortFree: () => isPortFree,
+  getShellCommand: () => getShellCommand,
+  getProcessPorts: () => getProcessPorts,
+  getProcessMemory: () => getProcessMemory,
+  getProcessBatchResources: () => getProcessBatchResources,
+  getPortInfo: () => getPortInfo,
+  getHomeDir: () => getHomeDir,
+  findPidByPort: () => findPidByPort,
+  findChildPid: () => findChildPid,
+  ensureDir: () => ensureDir,
+  copyFile: () => copyFile
+});
 import * as fs from "fs";
 import * as os from "os";
+import { join } from "path";
 var {$ } = globalThis.Bun;
 import { createMeasure } from "measure-fn";
+function psExec(command, _timeoutMs = 3000) {
+  const tmpFile = join(os.tmpdir(), `bgr-ps-${Date.now()}.ps1`);
+  try {
+    fs.writeFileSync(tmpFile, command);
+    const result = Bun.spawnSync(["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", tmpFile]);
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {}
+    return result.stdout?.toString() || "";
+  } catch {
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {}
+    return "";
+  }
+}
 function isWindows() {
   return process.platform === "win32";
 }
@@ -33,8 +76,13 @@ async function isProcessRunning(pid, command) {
         return await isDockerContainerRunning(command);
       }
       if (isWindows()) {
-        const result = await $`tasklist /FI "PID eq ${pid}" /NH`.nothrow().text();
-        return result.includes(`${pid}`);
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch {
+          const output = psExec(`Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id`).trim();
+          return output === String(pid);
+        }
       } else {
         const result = await $`ps -p ${pid}`.nothrow().text();
         return result.includes(`${pid}`);
@@ -66,7 +114,7 @@ async function isDockerContainerRunning(command) {
 async function getChildPids(pid) {
   try {
     if (isWindows()) {
-      const result = await $`powershell -Command "Get-CimInstance Win32_Process -Filter 'ParentProcessId=${pid}' | Select-Object -ExpandProperty ProcessId"`.nothrow().text();
+      const result = await psExec(`Get-CimInstance Win32_Process -Filter 'ParentProcessId=${pid}' | Select-Object -ExpandProperty ProcessId`, 3000);
       return result.split(`
 `).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
     } else {
@@ -125,6 +173,35 @@ async function isPortFree(port) {
     return true;
   }
 }
+async function getPortInfo(port) {
+  try {
+    if (isWindows()) {
+      const result = await $`netstat -ano | findstr :${port}`.nothrow().quiet().text();
+      for (const line of result.split(`
+`)) {
+        const match = line.match(new RegExp(`:(${port})\\s+.*LISTENING\\s+(\\d+)`));
+        if (match) {
+          const pid = parseInt(match[2]);
+          if (pid > 0 && await isProcessRunning(pid)) {
+            const nameResult = await $`powershell -NoProfile -Command "(Get-Process -Id ${pid} -ErrorAction SilentlyContinue).ProcessName"`.nothrow().quiet().text();
+            return { inUse: true, pid, processName: nameResult.trim() || "unknown" };
+          }
+        }
+      }
+      return { inUse: false };
+    } else {
+      const result = await $`ss -tln sport = :${port}`.nothrow().quiet().text();
+      const lines = result.trim().split(`
+`).filter((l) => l.trim());
+      if (lines.length > 1) {
+        return { inUse: true };
+      }
+      return { inUse: false };
+    }
+  } catch {
+    return { inUse: false };
+  }
+}
 async function waitForPortFree(port, timeoutMs = 5000) {
   const startTime = Date.now();
   const pollInterval = 300;
@@ -188,12 +265,12 @@ function getShellCommand(command) {
 }
 async function findChildPid(parentPid) {
   let currentPid = parentPid;
-  const maxDepth = 5;
+  const maxDepth = 2;
   for (let depth = 0;depth < maxDepth; depth++) {
     try {
       let childPids = [];
       if (isWindows()) {
-        const result = await $`powershell -Command "Get-CimInstance Win32_Process -Filter 'ParentProcessId=${currentPid}' | Select-Object -ExpandProperty ProcessId"`.nothrow().text();
+        const result = await psExec(`Get-CimInstance Win32_Process -Filter 'ParentProcessId=${currentPid}' | Select-Object -ExpandProperty ProcessId`, 3000);
         childPids = result.split(`
 `).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
       } else {
@@ -201,9 +278,8 @@ async function findChildPid(parentPid) {
         childPids = result.trim().split(`
 `).map((line) => parseInt(line.trim())).filter((n) => !isNaN(n) && n > 0);
       }
-      if (childPids.length === 0) {
+      if (childPids.length === 0)
         break;
-      }
       currentPid = childPids[0];
     } catch {
       break;
@@ -211,6 +287,112 @@ async function findChildPid(parentPid) {
   }
   return currentPid;
 }
+async function reconcileProcessPids(processes, deadPids) {
+  return await plat.measure("Reconcile PIDs", async () => {
+    const result = new Map;
+    const needsReconciliation = processes.filter((p) => deadPids.has(p.pid) && p.pid > 0);
+    if (needsReconciliation.length === 0)
+      return result;
+    try {
+      let runningProcs = [];
+      if (isWindows()) {
+        const output = await psExec(`Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | ForEach-Object { Write-Output "$($_.ProcessId)|$($_.CommandLine)" }`, 5000);
+        for (const line of output.split(`
+`)) {
+          const sepIdx = line.indexOf("|");
+          if (sepIdx === -1)
+            continue;
+          const pid = parseInt(line.substring(0, sepIdx).trim());
+          const cmdLine = line.substring(sepIdx + 1).trim();
+          if (!isNaN(pid) && pid > 0 && cmdLine) {
+            runningProcs.push({ pid, cmdLine });
+          }
+        }
+      } else {
+        const psOutput = await $`ps -eo pid,args --no-headers`.nothrow().quiet().text();
+        for (const line of psOutput.trim().split(`
+`)) {
+          const match = line.trim().match(/^(\d+)\s+(.+)/);
+          if (match) {
+            runningProcs.push({ pid: parseInt(match[1]), cmdLine: match[2] });
+          }
+        }
+      }
+      for (const proc of needsReconciliation) {
+        const cmdParts = proc.command.split(/\s+/);
+        const workdirParts = proc.workdir.replace(/\\/g, "/").split("/").filter(Boolean);
+        const workdirLast = workdirParts[workdirParts.length - 1]?.toLowerCase() || "";
+        let bestMatch = null;
+        let ambiguous = false;
+        for (const running of runningProcs) {
+          const cmdLower = running.cmdLine.toLowerCase();
+          let score = 0;
+          for (const part of cmdParts) {
+            if (part.length > 2 && cmdLower.includes(part.toLowerCase()))
+              score++;
+          }
+          if (workdirLast && cmdLower.includes(workdirLast))
+            score += 3;
+          if (cmdLower.includes(proc.workdir.toLowerCase().replace(/\\/g, "/")))
+            score += 5;
+          if (cmdLower.includes(proc.workdir.toLowerCase()))
+            score += 5;
+          if (score < 4)
+            continue;
+          if (!bestMatch || score > bestMatch.score) {
+            ambiguous = false;
+            bestMatch = { pid: running.pid, score };
+          } else if (score === bestMatch.score) {
+            ambiguous = true;
+          }
+        }
+        if (bestMatch && !ambiguous) {
+          result.set(proc.name, bestMatch.pid);
+          runningProcs = runningProcs.filter((p) => p.pid !== bestMatch.pid);
+        }
+      }
+    } catch {}
+    return result;
+  }) ?? new Map;
+}
+async function findPidByPort(port, maxWaitMs = 8000) {
+  const start = Date.now();
+  const pollMs = 500;
+  while (Date.now() - start < maxWaitMs) {
+    try {
+      if (isWindows()) {
+        const result = await $`netstat -ano`.nothrow().quiet().text();
+        for (const line of result.split(`
+`)) {
+          if (line.includes(`:${port}`) && line.includes("LISTENING")) {
+            const parts = line.trim().split(/\s+/);
+            const pid = parseInt(parts[parts.length - 1]);
+            if (!isNaN(pid) && pid > 0)
+              return pid;
+          }
+        }
+      } else {
+        try {
+          const result2 = await $`ss -tlnp`.nothrow().quiet().text();
+          for (const line of result2.split(`
+`)) {
+            if (line.includes(`:${port}`)) {
+              const pidMatch = line.match(/pid=(\d+)/);
+              if (pidMatch)
+                return parseInt(pidMatch[1]);
+            }
+          }
+        } catch {}
+        const result = await $`lsof -iTCP:${port} -sTCP:LISTEN -t`.nothrow().quiet().text();
+        const pid = parseInt(result.trim());
+        if (!isNaN(pid) && pid > 0)
+          return pid;
+      }
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+  return null;
+}
 async function readFileTail(filePath, lines) {
   return await plat.measure(`Read tail ${lines ?? "all"}L`, async () => {
     try {
@@ -227,6 +409,13 @@ async function readFileTail(filePath, lines) {
     }
   }) ?? "";
 }
+function copyFile(src, dest) {
+  fs.copyFileSync(src, dest);
+}
+async function getProcessMemory(pid) {
+  const map = await getProcessBatchResources([pid]);
+  return map.get(pid)?.memory || 0;
+}
 async function getProcessBatchResources(pids) {
   if (pids.length === 0)
     return new Map;
@@ -235,28 +424,16 @@ async function getProcessBatchResources(pids) {
     const pidSet = new Set(pids);
     try {
       if (isWindows()) {
-        const result = await $`powershell -Command "Get-Process | Select-Object Id, CPU, WorkingSet"`.nothrow().quiet().text();
-        const lines = result.trim().split(`
-`);
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed.startsWith("Id") || trimmed.startsWith("--"))
+        const output = psExec(`Get-Process -Id ${pids.join(",")} -ErrorAction SilentlyContinue | Select-Object Id, WorkingSet64 | ForEach-Object { Write-Output "$($_.Id)|$($_.WorkingSet64)" }`);
+        for (const line of output.split(`
+`)) {
+          const sepIdx = line.indexOf("|");
+          if (sepIdx === -1)
             continue;
-          const parts = trimmed.split(/\s+/);
-          if (parts.length >= 3) {
-            const pid = parseInt(parts[0]);
-            let cpuStr = parts[1];
-            let memStr = parts[2];
-            if (parts.length === 2) {
-              cpuStr = "0";
-              memStr = parts[1];
-            }
-            const cpu = parseFloat(cpuStr) || 0;
-            const memory = parseInt(memStr) || 0;
-            if (!isNaN(pid) && !isNaN(memory)) {
-              if (pidSet.has(pid))
-                resourceMap.set(pid, { memory, cpu });
-            }
+          const pid = parseInt(line.substring(0, sepIdx).trim());
+          const memory = parseInt(line.substring(sepIdx + 1).trim()) || 0;
+          if (!isNaN(pid) && pidSet.has(pid)) {
+            resourceMap.set(pid, { memory, cpu: 0 });
           }
         }
       } else {
@@ -309,15 +486,13 @@ async function getProcessPorts(pid) {
         if (ports2.size > 0)
           return Array.from(ports2);
       } catch {}
-      const result = await $`lsof -i -P -n -p ${pid}`.nothrow().quiet().text();
+      const result = await $`lsof -Pan -p ${pid} -iTCP -sTCP:LISTEN`.nothrow().quiet().text();
       const ports = new Set;
       for (const line of result.split(`
 `)) {
-        if (line.includes("LISTEN")) {
-          const portMatch = line.match(/:(\d+)\s+\(LISTEN\)/);
-          if (portMatch) {
-            ports.add(parseInt(portMatch[1]));
-          }
+        const portMatch = line.match(/:(\d+)\s+\(LISTEN\)/);
+        if (portMatch) {
+          ports.add(parseInt(portMatch[1]));
         }
       }
       return Array.from(ports);
@@ -333,7 +508,6 @@ var init_platform = __esm(() => {
 
 // src/utils.ts
 import * as fs2 from "fs";
-import chalk from "chalk";
 function parseEnvString(envString) {
   const env = {};
   envString.split(",").forEach((pair) => {
@@ -351,8 +525,8 @@ function calculateRuntime(startTime) {
 }
 async function getVersion() {
   try {
-    const { join } = await import("path");
-    const pkgPath = join(import.meta.dir, "../package.json");
+    const { join: join2 } = await import("path");
+    const pkgPath = join2(import.meta.dir, "../package.json");
     const pkg = await Bun.file(pkgPath).json();
     return pkg.version || "0.0.0";
   } catch {
@@ -361,8 +535,7 @@ async function getVersion() {
 }
 function validateDirectory(directory) {
   if (!directory || !fs2.existsSync(directory)) {
-    console.log(chalk.red("\u274C Error: 'directory' must be a valid path."));
-    process.exit(1);
+    throw new Error(`Directory not found or invalid: '${directory}'`);
   }
 }
 function tailFile(path, prefix, colorFn, lines) {
@@ -417,21 +590,39 @@ var exports_db = {};
 __export(exports_db, {
   updateProcessPid: () => updateProcessPid,
   updateProcessEnv: () => updateProcessEnv,
+  saveTemplate: () => saveTemplate,
   retryDatabaseOperation: () => retryDatabaseOperation,
   removeProcessByName: () => removeProcessByName,
   removeProcess: () => removeProcess,
+  removeDependency: () => removeDependency,
   removeAllProcesses: () => removeAllProcesses,
+  removeAllDependencies: () => removeAllDependencies,
   insertProcess: () => insertProcess,
+  getTemplate: () => getTemplate,
+  getStartOrder: () => getStartOrder,
+  getRecentHistory: () => getRecentHistory,
+  getProcessHistory: () => getProcessHistory,
   getProcess: () => getProcess,
+  getDependents: () => getDependents,
+  getDependencyGraph: () => getDependencyGraph,
+  getDependencies: () => getDependencies,
   getDbInfo: () => getDbInfo,
+  getAllTemplates: () => getAllTemplates,
   getAllProcesses: () => getAllProcesses,
+  deleteTemplate: () => deleteTemplate,
   dbPath: () => dbPath,
   db: () => db,
+  clearOldHistory: () => clearOldHistory,
   bgrHome: () => bgrHome,
-  ProcessSchema: () => ProcessSchema
+  addHistoryEntry: () => addHistoryEntry,
+  addDependency: () => addDependency,
+  TemplateSchema: () => TemplateSchema,
+  ProcessSchema: () => ProcessSchema,
+  HistorySchema: () => HistorySchema,
+  DependencySchema: () => DependencySchema
 });
 import { Database, z } from "sqlite-zod-orm";
-import { join } from "path";
+import { join as join2 } from "path";
 var {sleep } = globalThis.Bun;
 import { existsSync as existsSync3, copyFileSync as copyFileSync2 } from "fs";
 function getProcess(name) {
@@ -476,6 +667,154 @@ function updateProcessEnv(name, envJson) {
     db.process.update(proc.id, { env: envJson });
   }
 }
+function getAllTemplates() {
+  return db.template.select().all();
+}
+function getTemplate(name) {
+  return db.template.select().where({ name }).limit(1).get() || null;
+}
+function saveTemplate(data) {
+  const existing = db.template.select().where({ name: data.name }).limit(1).get();
+  if (existing) {
+    db.template.update(existing.id, {
+      command: data.command,
+      workdir: data.workdir || "",
+      env: data.env || "",
+      group: data.group || ""
+    });
+  } else {
+    db.template.insert({
+      name: data.name,
+      command: data.command,
+      workdir: data.workdir || "",
+      env: data.env || "",
+      group: data.group || ""
+    });
+  }
+}
+function deleteTemplate(name) {
+  const tmpl = db.template.select().where({ name }).limit(1).get();
+  if (tmpl) {
+    db.template.delete(tmpl.id);
+  }
+}
+function getProcessHistory(name, limit = 50) {
+  return db.history.select().where({ process_name: name }).orderBy("timestamp", "desc").limit(limit).all();
+}
+function addHistoryEntry(processName, event, pid, metadata = {}) {
+  return db.history.insert({
+    process_name: processName,
+    event,
+    pid,
+    metadata: JSON.stringify(metadata)
+  });
+}
+function getRecentHistory(limit = 100) {
+  return db.history.select().orderBy("timestamp", "desc").limit(limit).all();
+}
+function clearOldHistory(daysToKeep = 30) {
+  const cutoff = new Date;
+  cutoff.setDate(cutoff.getDate() - daysToKeep);
+  const cutoffStr = cutoff.toISOString();
+  const oldEntries = db.history.select().where("timestamp", "<", cutoffStr).all();
+  for (const entry of oldEntries) {
+    db.history.delete(entry.id);
+  }
+  return oldEntries.length;
+}
+function getDependencies(processName) {
+  return db.dependency.select().where({ process_name: processName }).all().map((d) => d.depends_on);
+}
+function getDependents(processName) {
+  return db.dependency.select().where({ depends_on: processName }).all().map((d) => d.process_name);
+}
+function getDependencyGraph() {
+  const all = db.dependency.select().all();
+  const graph = {};
+  for (const dep of all) {
+    if (!graph[dep.process_name])
+      graph[dep.process_name] = [];
+    graph[dep.process_name].push(dep.depends_on);
+  }
+  return graph;
+}
+function addDependency(processName, dependsOn) {
+  if (processName === dependsOn)
+    return false;
+  const existing = db.dependency.select().where({ process_name: processName, depends_on: dependsOn }).limit(1).get();
+  if (existing)
+    return false;
+  if (wouldCreateCycle(processName, dependsOn))
+    return false;
+  db.dependency.insert({ process_name: processName, depends_on: dependsOn });
+  return true;
+}
+function removeDependency(processName, dependsOn) {
+  const matches = db.dependency.select().where({ process_name: processName, depends_on: dependsOn }).all();
+  for (const dep of matches) {
+    db.dependency.delete(dep.id);
+  }
+}
+function removeAllDependencies(processName) {
+  const matches = db.dependency.select().where({ process_name: processName }).all();
+  for (const dep of matches) {
+    db.dependency.delete(dep.id);
+  }
+}
+function wouldCreateCycle(processName, dependsOn) {
+  const graph = getDependencyGraph();
+  if (!graph[processName])
+    graph[processName] = [];
+  graph[processName].push(dependsOn);
+  const visited = new Set;
+  const stack = [dependsOn];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === processName)
+      return true;
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    for (const dep of graph[current] || []) {
+      stack.push(dep);
+    }
+  }
+  return false;
+}
+function getStartOrder() {
+  const graph = getDependencyGraph();
+  const allProcesses = getAllProcesses().map((p) => p.name);
+  const allNames = new Set(allProcesses);
+  const inDegree = {};
+  for (const name of allNames)
+    inDegree[name] = 0;
+  for (const [proc, deps] of Object.entries(graph)) {
+    for (const dep of deps) {
+      if (allNames.has(dep)) {
+        inDegree[proc] = (inDegree[proc] || 0) + 1;
+      }
+    }
+  }
+  const queue = [];
+  for (const name of allNames) {
+    if ((inDegree[name] || 0) === 0)
+      queue.push(name);
+  }
+  const order = [];
+  while (queue.length > 0) {
+    queue.sort();
+    const current = queue.shift();
+    order.push(current);
+    for (const [proc, deps] of Object.entries(graph)) {
+      if (deps.includes(current) && allNames.has(proc)) {
+        inDegree[proc]--;
+        if (inDegree[proc] === 0)
+          queue.push(proc);
+      }
+    }
+  }
+  return order;
+}
 function getDbInfo() {
   return {
     dbPath,
@@ -498,7 +837,7 @@ async function retryDatabaseOperation(operation, maxRetries = 5, delay = 100) {
   }
   throw new Error("Max retries reached for database operation");
 }
-var ProcessSchema, homePath, bgrDir, dbFilename, dbPath, bgrHome, legacyDbPath, db;
+var ProcessSchema, TemplateSchema, HistorySchema, DependencySchema, homePath, bgrDir, dbFilename, dbPath, bgrHome, legacyDbPath, db;
 var init_db = __esm(() => {
   init_platform();
   ProcessSchema = z.object({
@@ -510,15 +849,36 @@ var init_db = __esm(() => {
     configPath: z.string().default(""),
     stdout_path: z.string(),
     stderr_path: z.string(),
-    timestamp: z.string().default(() => new Date().toISOString())
+    timestamp: z.string().default(() => new Date().toISOString()),
+    group: z.string().default("")
+  });
+  TemplateSchema = z.object({
+    name: z.string(),
+    command: z.string(),
+    workdir: z.string().default(""),
+    env: z.string().default(""),
+    group: z.string().default(""),
+    created_at: z.string().default(() => new Date().toISOString())
+  });
+  HistorySchema = z.object({
+    process_name: z.string(),
+    event: z.string(),
+    pid: z.number().optional(),
+    timestamp: z.string().default(() => new Date().toISOString()),
+    metadata: z.string().default("")
+  });
+  DependencySchema = z.object({
+    process_name: z.string(),
+    depends_on: z.string(),
+    created_at: z.string().default(() => new Date().toISOString())
   });
   homePath = getHomeDir();
-  bgrDir = join(homePath, ".bgr");
+  bgrDir = join2(homePath, ".bgr");
   ensureDir(bgrDir);
   dbFilename = process.env.BGRUN_DB ?? "bgrun.sqlite";
-  dbPath = join(bgrDir, dbFilename);
+  dbPath = join2(bgrDir, dbFilename);
   bgrHome = bgrDir;
-  legacyDbPath = join(bgrDir, "bgr_v2.sqlite");
+  legacyDbPath = join2(bgrDir, "bgr_v2.sqlite");
   if (!existsSync3(dbPath) && existsSync3(legacyDbPath)) {
     try {
       copyFileSync2(legacyDbPath, dbPath);
@@ -526,17 +886,23 @@ var init_db = __esm(() => {
     } catch (e) {}
   }
   db = new Database(dbPath, {
-    process: ProcessSchema
+    process: ProcessSchema,
+    template: TemplateSchema,
+    history: HistorySchema,
+    dependency: DependencySchema
   }, {
     indexes: {
-      process: ["name", "timestamp", "pid"]
+      process: ["name", "timestamp", "pid"],
+      template: ["name"],
+      history: ["process_name", "timestamp"],
+      dependency: ["process_name", "depends_on"]
     }
   });
 });
 
 // src/logger.ts
 import boxen from "boxen";
-import chalk2 from "chalk";
+import chalk from "chalk";
 function announce(message, title) {
   console.log(boxen(message, {
     padding: 1,
@@ -549,7 +915,7 @@ function announce(message, title) {
 }
 function error(message) {
   const text = message instanceof Error ? message.stack || message.message : String(message);
-  console.error(boxen(chalk2.red(text), {
+  console.error(boxen(chalk.red(text), {
     padding: 1,
     margin: 1,
     borderColor: "red",
@@ -557,9 +923,17 @@ function error(message) {
     titleAlignment: "center",
     borderStyle: "double"
   }));
-  process.exit(1);
+  throw new BgrunError(text);
 }
-var init_logger = () => {};
+var BgrunError;
+var init_logger = __esm(() => {
+  BgrunError = class BgrunError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "BgrunError";
+    }
+  };
+});
 
 // src/config.ts
 function formatEnvKey(key) {
@@ -596,10 +970,10 @@ async function parseConfigFile(configPath) {
 var exports_deps = {};
 __export(exports_deps, {
   getUnmetDeps: () => getUnmetDeps,
-  getDependencies: () => getDependencies,
+  getDependencies: () => getDependencies2,
   buildDepGraph: () => buildDepGraph
 });
-function getDependencies(envStr) {
+function getDependencies2(envStr) {
   const env = parseEnvString(envStr);
   const raw = env.BGR_DEPENDS_ON || "";
   return raw.split(",").map((s) => s.trim()).filter(Boolean);
@@ -608,7 +982,7 @@ async function buildDepGraph() {
   const processes = getAllProcesses();
   const nodeMap = new Map;
   for (const proc of processes) {
-    const deps = getDependencies(proc.env);
+    const deps = getDependencies2(proc.env);
     const alive = await isProcessRunning(proc.pid, proc.command);
     nodeMap.set(proc.name, {
       name: proc.name,
@@ -660,7 +1034,7 @@ async function getUnmetDeps(name) {
   const proc = getProcess(name);
   if (!proc)
     return [];
-  const deps = getDependencies(proc.env);
+  const deps = getDependencies2(proc.env);
   const unmet = [];
   for (const depName of deps) {
     const depProc = getProcess(depName);
@@ -684,10 +1058,10 @@ var init_deps = __esm(() => {
 // src/commands/run.ts
 var {$: $2 } = globalThis.Bun;
 var {sleep: sleep2 } = globalThis.Bun;
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { createMeasure as createMeasure2 } from "measure-fn";
 async function handleRun(options) {
-  const { command, directory, env, name, configPath, force, fetch, stdout, stderr } = options;
+  const { command, directory, env, name, configPath, force, fetch: fetch2, stdout, stderr } = options;
   const existingProcess = name ? getProcess(name) : null;
   if (name && existingProcess) {
     const { getUnmetDeps: getUnmetDeps2 } = await Promise.resolve().then(() => (init_deps(), exports_deps));
@@ -708,7 +1082,7 @@ async function handleRun(options) {
     const finalDirectory2 = directory || existingProcess.workdir;
     validateDirectory(finalDirectory2);
     $2.cwd(finalDirectory2);
-    if (fetch) {
+    if (fetch2) {
       if (!__require("fs").existsSync(__require("path").join(finalDirectory2, ".git"))) {
         error(`Cannot --fetch: '${finalDirectory2}' is not a Git repository.`);
       }
@@ -758,9 +1132,15 @@ async function handleRun(options) {
     if (cmdToMatch) {
       await run.measure("Zombie sweep", async () => {
         try {
-          const result = await $2`powershell -Command "Get-Process -Name bun -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -match '${cmdToMatch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").split(" ")[1] || cmdToMatch}' } | Select-Object -ExpandProperty Id"`.nothrow().text();
+          const cmdKeyword = cmdToMatch.split(" ")[1] || cmdToMatch;
+          const GENERIC_KEYWORDS = ["dev", "run", "start", "serve", "build", "test"];
+          if (GENERIC_KEYWORDS.includes(cmdKeyword.toLowerCase())) {
+            return;
+          }
+          const currentPid = process.pid;
+          const result = await psExec(`Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | Where-Object { $_.CommandLine -match '${cmdKeyword.replace(/'/g, "''")}' -and $_.ProcessId -ne ${currentPid} } | Select-Object -ExpandProperty ProcessId`, 3000);
           const zombiePids = result.split(`
-`).map((l) => parseInt(l.trim())).filter((n) => !isNaN(n) && n > 0);
+`).map((l) => parseInt(l.trim())).filter((n) => !isNaN(n) && n > 0 && n !== currentPid);
           for (const zPid of zombiePids) {
             await $2`taskkill /F /T /PID ${zPid}`.nothrow().quiet();
           }
@@ -781,6 +1161,9 @@ async function handleRun(options) {
   const finalCommand = command || existingProcess.command;
   const finalDirectory = directory || existingProcess?.workdir;
   let finalEnv = env || (existingProcess ? parseEnvString(existingProcess.env) : {});
+  if (!("BGR_KEEP_ALIVE" in finalEnv)) {
+    finalEnv.BGR_KEEP_ALIVE = "true";
+  }
   let finalConfigPath;
   if (configPath !== undefined) {
     finalConfigPath = configPath;
@@ -790,7 +1173,7 @@ async function handleRun(options) {
     finalConfigPath = ".config.toml";
   }
   if (finalConfigPath) {
-    const fullConfigPath = join2(finalDirectory, finalConfigPath);
+    const fullConfigPath = join3(finalDirectory, finalConfigPath);
     if (await Bun.file(fullConfigPath).exists()) {
       const configEnv = await run.measure(`Parse config "${finalConfigPath}"`, async () => {
         try {
@@ -808,9 +1191,9 @@ async function handleRun(options) {
       console.log(`Config file '${finalConfigPath}' not found, continuing without it.`);
     }
   }
-  const stdoutPath = stdout || existingProcess?.stdout_path || join2(homePath2, ".bgr", `${name}-out.txt`);
+  const stdoutPath = stdout || existingProcess?.stdout_path || join3(homePath2, ".bgr", `${name}-out.txt`);
   Bun.write(stdoutPath, "");
-  const stderrPath = stderr || existingProcess?.stderr_path || join2(homePath2, ".bgr", `${name}-err.txt`);
+  const stderrPath = stderr || existingProcess?.stderr_path || join3(homePath2, ".bgr", `${name}-err.txt`);
   Bun.write(stderrPath, "");
   const actualPid = await run.measure(`Spawn "${name}" \u2192 ${finalCommand}`, async () => {
     const newProcess = Bun.spawn(getShellCommand(finalCommand), {
@@ -854,7 +1237,7 @@ __export(exports_log_rotation, {
   rotateLogFile: () => rotateLogFile,
   rotateAllLogs: () => rotateAllLogs
 });
-import { existsSync as existsSync7, statSync as statSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync7, statSync as statSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 function rotateLogFile(filePath, maxBytes = DEFAULT_MAX_BYTES, keepLines = DEFAULT_KEEP_LINES) {
   try {
     if (!existsSync7(filePath))
@@ -870,7 +1253,7 @@ function rotateLogFile(filePath, maxBytes = DEFAULT_MAX_BYTES, keepLines = DEFAU
     const truncated = lines.slice(-keepLines);
     const header = `--- [bgrun] Log rotated at ${new Date().toISOString()} (was ${lines.length} lines, ${formatBytes(stat.size)}) ---
 `;
-    writeFileSync(filePath, header + truncated.join(`
+    writeFileSync2(filePath, header + truncated.join(`
 `));
     return true;
   } catch {
@@ -922,22 +1305,87 @@ var init_log_rotation = __esm(() => {
 var exports_server = {};
 __export(exports_server, {
   startServer: () => startServer,
-  guardRestartCounts: () => guardRestartCounts
+  guardRestartCounts: () => guardRestartCounts,
+  guardEvents: () => guardEvents
 });
 import path2 from "path";
+async function cleanupPort(port) {
+  if (process.platform !== "win32")
+    return port;
+  try {
+    const proc = Bun.spawn([
+      "powershell",
+      "-NoProfile",
+      "-Command",
+      `Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`
+    ], { stdout: "pipe", stderr: "pipe" });
+    const text = await new Response(proc.stdout).text();
+    const pid = parseInt(text.trim(), 10);
+    if (!pid || pid === process.pid)
+      return port;
+    const checkProc = Bun.spawn([
+      "powershell",
+      "-NoProfile",
+      "-Command",
+      `Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id`
+    ], { stdout: "pipe", stderr: "pipe" });
+    const checkText = await new Response(checkProc.stdout).text();
+    if (checkText.trim()) {
+      console.log(`[server] Killing PID ${pid} holding port ${port}`);
+      Bun.spawn(["taskkill", "/F", "/PID", String(pid)], { stdout: "pipe", stderr: "pipe" });
+      await Bun.sleep(1000);
+      return port;
+    } else {
+      const fallback = port + 1;
+      console.log(`[server] \u26A0 Port ${port} held by zombie PID ${pid} \u2014 falling back to port ${fallback}`);
+      return fallback;
+    }
+  } catch {
+    return port;
+  }
+}
 async function startServer() {
   const { start } = await import("melina");
   const appDir = path2.join(import.meta.dir, "../dashboard/app");
-  const explicitPort = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : undefined;
+  const requestedPort = process.env.BUN_PORT ? parseInt(process.env.BUN_PORT, 10) : 3000;
+  _originalPort = requestedPort;
+  const resolvedPort = await cleanupPort(requestedPort);
+  _currentPort = resolvedPort;
+  const needsExplicitPort = process.env.BUN_PORT || resolvedPort !== requestedPort;
   await start({
     appDir,
     defaultTitle: "bgrun Dashboard - Process Manager",
     globalCss: path2.join(appDir, "globals.css"),
-    ...explicitPort !== undefined && { port: explicitPort }
+    ...needsExplicitPort && { port: resolvedPort }
   });
   startGuard();
   const { startLogRotation: startLogRotation2 } = await Promise.resolve().then(() => (init_log_rotation(), exports_log_rotation));
   startLogRotation2(() => getAllProcesses());
+  if (resolvedPort !== requestedPort) {
+    startStickyPortChecker();
+  }
+}
+function startStickyPortChecker() {
+  const CHECK_INTERVAL_MS = 60000;
+  console.log(`[server] Starting sticky port checker (original: ${_originalPort}, current: ${_currentPort})`);
+  setInterval(async () => {
+    if (_currentPort === _originalPort)
+      return;
+    try {
+      const proc = Bun.spawn([
+        "powershell",
+        "-NoProfile",
+        "-Command",
+        `Get-NetTCPConnection -LocalPort ${_originalPort} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess`
+      ], { stdout: "pipe", stderr: "pipe" });
+      const text = await new Response(proc.stdout).text();
+      const pid = parseInt(text.trim(), 10);
+      if (!pid) {
+        console.log(`[server] \u2713 Original port ${_originalPort} is now available! Consider restarting to reclaim it.`);
+        _currentPort = _originalPort;
+      }
+    } catch {}
+  }, CHECK_INTERVAL_MS);
 }
 function startGuard() {
   console.log(`[guard] \u2713 Built-in process guard started (checking every ${GUARD_INTERVAL_MS / 1000}s)`);
@@ -959,6 +1407,7 @@ function startGuard() {
           if (now < nextRestart)
             continue;
           console.log(`[guard] \u26A0 Guarded process "${proc.name}" (PID ${proc.pid}) is dead, restarting...`);
+          let success = false;
           try {
             await handleRun({
               action: "run",
@@ -966,9 +1415,16 @@ function startGuard() {
               force: true,
               remoteName: ""
             });
+            success = true;
             const prevCount = guardRestartCounts.get(proc.name) || 0;
             const newCount = prevCount + 1;
             guardRestartCounts.set(proc.name, newCount);
+            try {
+              addHistoryEntry(proc.name, "restart", undefined, { by: "guard", count: newCount });
+            } catch {}
+            guardEvents.unshift({ time: now, name: proc.name, action: "restart", success: true });
+            if (guardEvents.length > 100)
+              guardEvents.pop();
             if (newCount > 5) {
               const backoffSeconds = Math.min(30 * Math.pow(2, newCount - 6), 300);
               guardNextRestartTime.set(proc.name, Date.now() + backoffSeconds * 1000);
@@ -978,6 +1434,9 @@ function startGuard() {
             }
           } catch (err) {
             console.error(`[guard] \u2717 Failed to restart "${proc.name}": ${err.message}`);
+            guardEvents.unshift({ time: now, name: proc.name, action: "restart", success: false });
+            if (guardEvents.length > 100)
+              guardEvents.pop();
           }
         } else {
           const prevCount = guardRestartCounts.get(proc.name) || 0;
@@ -995,7 +1454,7 @@ function startGuard() {
     }
   }, GUARD_INTERVAL_MS);
 }
-var GUARD_INTERVAL_MS = 30000, GUARD_SKIP_NAMES, _g, guardRestartCounts, guardNextRestartTime;
+var GUARD_INTERVAL_MS = 30000, GUARD_SKIP_NAMES, _g, guardRestartCounts, guardNextRestartTime, guardEvents, _originalPort = 3000, _currentPort = 3000;
 var init_server = __esm(() => {
   init_db();
   init_platform();
@@ -1007,8 +1466,11 @@ var init_server = __esm(() => {
     _g.__bgrGuardRestartCounts = new Map;
   if (!_g.__bgrGuardNextRestartTime)
     _g.__bgrGuardNextRestartTime = new Map;
+  if (!_g.__bgrGuardEvents)
+    _g.__bgrGuardEvents = [];
   guardRestartCounts = _g.__bgrGuardRestartCounts;
   guardNextRestartTime = _g.__bgrGuardNextRestartTime;
+  guardEvents = _g.__bgrGuardEvents;
 });
 
 // src/guard.ts
@@ -1016,6 +1478,38 @@ var exports_guard = {};
 __export(exports_guard, {
   startGuardLoop: () => startGuardLoop
 });
+import { createHmac } from "crypto";
+async function notifyWebhook(event, name, details) {
+  if (!WEBHOOK_URL)
+    return;
+  try {
+    const payload = JSON.stringify({
+      event,
+      process: name,
+      timestamp: new Date().toISOString(),
+      ...details
+    });
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": "bgrun-guard/1.0"
+    };
+    if (WEBHOOK_SECRET) {
+      const sig = createHmac("sha256", WEBHOOK_SECRET).update(payload).digest("hex");
+      headers["X-BGR-Signature"] = `sha256=${sig}`;
+    }
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    await fetch(WEBHOOK_URL, {
+      method: "POST",
+      headers,
+      body: payload,
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+  } catch (err) {
+    console.error(`[guard] Webhook failed: ${err.message}`);
+  }
+}
 async function restartProcess(name) {
   try {
     await handleRun({
@@ -1064,6 +1558,7 @@ async function guardCycle() {
             continue;
           }
           console.log(`[guard] \u26A0 "${proc.name}" (PID ${proc.pid}) is dead \u2014 restarting...`);
+          notifyWebhook("crash", proc.name, { pid: proc.pid, isDashboard });
           const success = await restartProcess(proc.name);
           if (success) {
             const count = (state.restartCounts.get(proc.name) || 0) + 1;
@@ -1077,6 +1572,9 @@ async function guardCycle() {
               console.log(`[guard] \u2713 Restarted "${proc.name}" (#${count})`);
             }
             restarted++;
+            notifyWebhook("restart", proc.name, { pid: proc.pid, restartCount: count, backoffMs: backoff });
+          } else {
+            notifyWebhook("restart_failed", proc.name, { pid: proc.pid });
           }
         } else if (alive) {
           const count = state.restartCounts.get(proc.name) || 0;
@@ -1111,17 +1609,20 @@ async function startGuardLoop(intervalMs = DEFAULT_INTERVAL_MS) {
   console.log(`[guard]    Crash backoff threshold: ${CRASH_THRESHOLD} restarts`);
   console.log(`[guard]    Stability window: ${STABILITY_WINDOW_MS / 1000}s`);
   console.log(`[guard]    Monitoring: BGR_KEEP_ALIVE=true + bgr-dashboard`);
+  console.log(`[guard]    Webhook: ${WEBHOOK_URL || "(none \u2014 set BGR_WEBHOOK_URL to enable)"}`);
   console.log(`[guard]    Started: ${new Date().toLocaleString()}`);
   console.log(`[guard] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
   await guardCycle();
   setInterval(guardCycle, interval);
 }
-var DEFAULT_INTERVAL_MS = 30000, MAX_BACKOFF_MS, CRASH_THRESHOLD = 5, STABILITY_WINDOW_MS = 120000, state;
+var WEBHOOK_URL, WEBHOOK_SECRET, DEFAULT_INTERVAL_MS = 30000, MAX_BACKOFF_MS, CRASH_THRESHOLD = 5, STABILITY_WINDOW_MS = 120000, state;
 var init_guard = __esm(() => {
   init_db();
   init_platform();
   init_run();
   init_utils();
+  WEBHOOK_URL = process.env.BGR_WEBHOOK_URL || "";
+  WEBHOOK_SECRET = process.env.BGR_WEBHOOK_SECRET || "";
   MAX_BACKOFF_MS = 5 * 60000;
   state = {
     restartCounts: new Map,
@@ -1136,10 +1637,10 @@ init_run();
 import { parseArgs } from "util";
 
 // src/commands/list.ts
-import chalk4 from "chalk";
+import chalk3 from "chalk";
 
 // src/table.ts
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 function getTerminalWidth() {
   return process.stdout.columns || 120;
 }
@@ -1221,7 +1722,7 @@ function renderBorder(widths, padding, style) {
 function renderHorizontalTable(rows, columns, options = {}) {
   const { maxWidth = getTerminalWidth(), padding = 2, borderStyle = "rounded", showHeaders = true } = options;
   if (rows.length === 0)
-    return { table: chalk3.gray("No data to display"), truncatedIndices: [] };
+    return { table: chalk2.gray("No data to display"), truncatedIndices: [] };
   const borderChars = {
     rounded: ["\u256D", "\u252C", "\u256E", "\u2500", "\u2502", "\u251C", "\u253C", "\u2524", "\u2570", "\u2534", "\u256F"],
     single: ["\u250C", "\u252C", "\u2510", "\u2500", "\u2502", "\u251C", "\u253C", "\u2524", "\u2514", "\u2534", "\u2518"],
@@ -1237,7 +1738,7 @@ function renderHorizontalTable(rows, columns, options = {}) {
   if (borderStyle !== "none")
     lines.push(renderBorder(widthArray, padding, [tl, tc, tr, h]));
   if (showHeaders) {
-    const headerCells = columns.map((col, i) => chalk3.bold(truncateString(col.header, widthArray[i]).padEnd(widthArray[i])));
+    const headerCells = columns.map((col, i) => chalk2.bold(truncateString(col.header, widthArray[i]).padEnd(widthArray[i])));
     lines.push(`${v}${cellPadding}${headerCells.join(`${cellPadding}${v}${cellPadding}`)}${cellPadding}${v}`);
     if (borderStyle !== "none")
       lines.push(renderBorder(widthArray, padding, [ml, mc, mr, h]));
@@ -1266,10 +1767,10 @@ function renderVerticalTree(rows, columns) {
     if (index > 0)
       lines.push("");
     const name = row.name ? `'${row.name}'` : `(ID: ${row.id})`;
-    lines.push(chalk3.cyan(`\u25B6 ${name}`));
+    lines.push(chalk2.cyan(`\u25B6 ${name}`));
     columns.forEach((col) => {
       const value = col.formatter ? col.formatter(row[col.key]) : String(row[col.key] || "");
-      lines.push(`  \u251C\u2500 ${chalk3.gray(`${col.header}:`)} ${value}`);
+      lines.push(`  \u251C\u2500 ${chalk2.gray(`${col.header}:`)} ${value}`);
     });
   });
   return lines.join(`
@@ -1288,15 +1789,15 @@ function renderHybridTable(rows, columns, options = {}) {
 }
 function renderProcessTable(processes, options) {
   const columns = [
-    { key: "id", header: "ID", formatter: (id) => chalk3.blue(id) },
-    { key: "pid", header: "PID", formatter: (pid) => chalk3.yellow(pid) },
-    { key: "name", header: "Name", formatter: (name) => chalk3.cyan.bold(name) },
-    { key: "port", header: "Port", formatter: (port) => port === "-" ? chalk3.gray(port) : chalk3.hex("#FF6B6B")(port) },
-    { key: "memory", header: "Memory", formatter: (mem) => mem === "-" ? chalk3.gray(mem) : chalk3.hex("#4ECDC4")(mem) },
+    { key: "id", header: "ID", formatter: (id) => chalk2.blue(id) },
+    { key: "pid", header: "PID", formatter: (pid) => chalk2.yellow(pid) },
+    { key: "name", header: "Name", formatter: (name) => chalk2.cyan.bold(name) },
+    { key: "port", header: "Port", formatter: (port) => port === "-" ? chalk2.gray(port) : chalk2.hex("#FF6B6B")(port) },
+    { key: "memory", header: "Memory", formatter: (mem) => mem === "-" ? chalk2.gray(mem) : chalk2.hex("#4ECDC4")(mem) },
     { key: "command", header: "Command" },
-    { key: "workdir", header: "Directory", formatter: (dir) => chalk3.gray(dir), truncator: truncatePath },
+    { key: "workdir", header: "Directory", formatter: (dir) => chalk2.gray(dir), truncator: truncatePath },
     { key: "status", header: "Status" },
-    { key: "runtime", header: "Runtime", formatter: (runtime) => chalk3.magenta(runtime) }
+    { key: "runtime", header: "Runtime", formatter: (runtime) => chalk2.magenta(runtime) }
   ];
   return renderHybridTable(processes, columns, options);
 }
@@ -1322,10 +1823,29 @@ async function showAll(opts) {
     const envVars = parseEnvString(proc.env);
     return envVars["BGR_GROUP"] === opts.filter;
   });
+  const deadPids = new Set;
+  const aliveCache = new Map;
+  for (const proc of filtered) {
+    const alive = await isProcessRunning(proc.pid, proc.command);
+    aliveCache.set(proc.pid, alive);
+    if (!alive && proc.pid > 0)
+      deadPids.add(proc.pid);
+  }
+  if (deadPids.size > 0) {
+    const reconciled = await reconcileProcessPids(filtered.map((p) => ({ name: p.name, pid: p.pid, command: p.command, workdir: p.workdir })), deadPids);
+    for (const [name, newPid] of reconciled) {
+      updateProcessPid(name, newPid);
+      const proc = filtered.find((p) => p.name === name);
+      if (proc) {
+        proc.pid = newPid;
+        aliveCache.set(newPid, true);
+      }
+    }
+  }
   if (opts?.json) {
     const jsonData = [];
     for (const proc of filtered) {
-      const isRunning = await isProcessRunning(proc.pid, proc.command);
+      const isRunning = aliveCache.get(proc.pid) ?? await isProcessRunning(proc.pid, proc.command);
       const envVars = parseEnvString(proc.env);
       const ports = isRunning ? await getProcessPorts(proc.pid) : [];
       jsonData.push({
@@ -1343,7 +1863,7 @@ async function showAll(opts) {
   const allPids = filtered.map((p) => p.pid);
   const resourceMap = await getProcessBatchResources(allPids);
   for (const proc of filtered) {
-    const isRunning = await isProcessRunning(proc.pid, proc.command);
+    const isRunning = aliveCache.get(proc.pid) ?? await isProcessRunning(proc.pid, proc.command);
     const runtime = calculateRuntime(proc.timestamp);
     const mem = isRunning ? resourceMap.get(proc.pid)?.memory || 0 : 0;
     const ports = isRunning ? await getProcessPorts(proc.pid) : [];
@@ -1355,7 +1875,7 @@ async function showAll(opts) {
       memory: formatMemory(mem),
       command: proc.command,
       workdir: proc.workdir,
-      status: isRunning ? chalk4.green.bold("\u25CF Running") : chalk4.red.bold("\u25CB Stopped"),
+      status: isRunning ? chalk3.green.bold("\u25CF Running") : chalk3.red.bold("\u25CB Stopped"),
       runtime
     });
   }
@@ -1375,7 +1895,7 @@ async function showAll(opts) {
   console.log(tableOutput);
   const runningCount = tableData.filter((p) => p.status.includes("Running")).length;
   const stoppedCount = tableData.filter((p) => p.status.includes("Stopped")).length;
-  console.log(chalk4.cyan(`Total: ${tableData.length} processes (${chalk4.green(`${runningCount} running`)}, ${chalk4.red(`${stoppedCount} stopped`)})`));
+  console.log(chalk3.cyan(`Total: ${tableData.length} processes (${chalk3.green(`${runningCount} running`)}, ${chalk3.red(`${stoppedCount} stopped`)})`));
 }
 
 // src/commands/cleanup.ts
@@ -1506,7 +2026,7 @@ init_utils();
 init_run();
 import * as fs4 from "fs";
 import path from "path";
-import chalk5 from "chalk";
+import chalk4 from "chalk";
 async function handleWatch(options, logOptions) {
   let currentProcess = null;
   let isRestarting = false;
@@ -1517,7 +2037,7 @@ async function handleWatch(options, logOptions) {
     const isDead = !await isProcessRunning(proc.pid);
     if (!isDead)
       return false;
-    console.log(chalk5.yellow(`\uD83D\uDC80 Process '${options.name}' died immediately after ${reason}\u2014dumping logs:`));
+    console.log(chalk4.yellow(`\uD83D\uDC80 Process '${options.name}' died immediately after ${reason}\u2014dumping logs:`));
     const readAndDump = (path2, color, label) => {
       try {
         if (fs4.existsSync(path2)) {
@@ -1531,14 +2051,14 @@ ${color(content)}
           }
         }
       } catch (err) {
-        console.warn(chalk5.gray(`Could not read ${label} log: ${err}`));
+        console.warn(chalk4.gray(`Could not read ${label} log: ${err}`));
       }
     };
     if (logOptions.logType === "both" || logOptions.logType === "stdout") {
-      readAndDump(proc.stdout_path, chalk5.white, "\uD83D\uDCC4 Stdout");
+      readAndDump(proc.stdout_path, chalk4.white, "\uD83D\uDCC4 Stdout");
     }
     if (logOptions.logType === "both" || logOptions.logType === "stderr") {
-      readAndDump(proc.stderr_path, chalk5.red, "\uD83D\uDCC4 Stderr");
+      readAndDump(proc.stderr_path, chalk4.red, "\uD83D\uDCC4 Stderr");
     }
     return true;
   };
@@ -1579,29 +2099,29 @@ ${color(content)}
     const stops = [];
     if (!logOptions.showLogs || !currentProcess)
       return stops;
-    console.log(chalk5.gray(`
+    console.log(chalk4.gray(`
 ` + "\u2500".repeat(50) + `
 `));
     if (logOptions.logType === "both" || logOptions.logType === "stdout") {
-      console.log(chalk5.green.bold(`\uD83D\uDCC4 Tailing stdout for ${options.name}:`));
-      console.log(chalk5.gray("\u2550".repeat(50)));
+      console.log(chalk4.green.bold(`\uD83D\uDCC4 Tailing stdout for ${options.name}:`));
+      console.log(chalk4.gray("\u2550".repeat(50)));
       try {
         await waitForLogReady(currentProcess.stdout_path);
       } catch (err) {
-        console.warn(chalk5.yellow(`\u26A0\uFE0F  Stdout log not ready yet for ${options.name}\u2014starting tail anyway: ${err.message}`));
+        console.warn(chalk4.yellow(`\u26A0\uFE0F  Stdout log not ready yet for ${options.name}\u2014starting tail anyway: ${err.message}`));
       }
-      const stop = tailFile(currentProcess.stdout_path, "", chalk5.white, logOptions.lines);
+      const stop = tailFile(currentProcess.stdout_path, "", chalk4.white, logOptions.lines);
       stops.push(stop);
     }
     if (logOptions.logType === "both" || logOptions.logType === "stderr") {
-      console.log(chalk5.red.bold(`\uD83D\uDCC4 Tailing stderr for ${options.name}:`));
-      console.log(chalk5.gray("\u2550".repeat(50)));
+      console.log(chalk4.red.bold(`\uD83D\uDCC4 Tailing stderr for ${options.name}:`));
+      console.log(chalk4.gray("\u2550".repeat(50)));
       try {
         await waitForLogReady(currentProcess.stderr_path);
       } catch (err) {
-        console.warn(chalk5.yellow(`\u26A0\uFE0F  Stderr log not ready yet for ${options.name}\u2014starting tail anyway: ${err.message}`));
+        console.warn(chalk4.yellow(`\u26A0\uFE0F  Stderr log not ready yet for ${options.name}\u2014starting tail anyway: ${err.message}`));
       }
-      const stop = tailFile(currentProcess.stderr_path, "", chalk5.red, logOptions.lines);
+      const stop = tailFile(currentProcess.stderr_path, "", chalk4.red, logOptions.lines);
       stops.push(stop);
     }
     return stops;
@@ -1626,7 +2146,7 @@ ${color(content)}
       const died = await dumpLogsIfDead(currentProcess, restartReason);
       if (died) {
         if (lastRestartPath) {
-          console.log(chalk5.yellow(`\u26A0\uFE0F  Compile error on change\u2014pausing restarts until manual fix.`));
+          console.log(chalk4.yellow(`\u26A0\uFE0F  Compile error on change\u2014pausing restarts until manual fix.`));
           return;
         } else {
           error(`Failed to start process '${options.name}'. Aborting watch mode.`);
@@ -1639,7 +2159,7 @@ ${color(content)}
     } finally {
       isRestarting = false;
       if (currentProcess) {
-        console.log(chalk5.cyan(`
+        console.log(chalk4.cyan(`
 \uD83D\uDC40 Watching for file changes in: ${currentProcess.workdir}`));
       }
     }
@@ -1659,7 +2179,7 @@ ${color(content)}
   }
   tailStops = await startTails();
   const workdir = currentProcess.workdir;
-  console.log(chalk5.cyan(`
+  console.log(chalk4.cyan(`
 \uD83D\uDC40 Watching for file changes in: ${workdir}`));
   const watcher = fs4.watch(workdir, { recursive: true }, (eventType, filename) => {
     if (filename == null)
@@ -1672,7 +2192,7 @@ ${color(content)}
     debounceTimeout = setTimeout(() => restartProcess(fullPath), 500);
   });
   const cleanup = async () => {
-    console.log(chalk5.magenta(`
+    console.log(chalk4.magenta(`
 SIGINT received...`));
     watcher.close();
     tailStops.forEach((stop) => stop());
@@ -1695,7 +2215,7 @@ SIGINT received...`));
 init_db();
 init_logger();
 init_platform();
-import chalk6 from "chalk";
+import chalk5 from "chalk";
 import * as fs5 from "fs";
 async function showLogs(name, logType = "both", lines) {
   const proc = getProcess(name);
@@ -1704,17 +2224,17 @@ async function showLogs(name, logType = "both", lines) {
     return;
   }
   if (logType === "both" || logType === "stdout") {
-    console.log(chalk6.green.bold(`\uD83D\uDCC4 Stdout logs for ${name}:`));
-    console.log(chalk6.gray("\u2550".repeat(50)));
+    console.log(chalk5.green.bold(`\uD83D\uDCC4 Stdout logs for ${name}:`));
+    console.log(chalk5.gray("\u2550".repeat(50)));
     if (fs5.existsSync(proc.stdout_path)) {
       try {
         const output = await readFileTail(proc.stdout_path, lines);
-        console.log(output || chalk6.gray("(no output)"));
+        console.log(output || chalk5.gray("(no output)"));
       } catch (err) {
-        console.log(chalk6.red(`Error reading stdout: ${err}`));
+        console.log(chalk5.red(`Error reading stdout: ${err}`));
       }
     } else {
-      console.log(chalk6.gray("(log file not found)"));
+      console.log(chalk5.gray("(log file not found)"));
     }
     if (logType === "both") {
       console.log(`
@@ -1722,17 +2242,17 @@ async function showLogs(name, logType = "both", lines) {
     }
   }
   if (logType === "both" || logType === "stderr") {
-    console.log(chalk6.red.bold(`\uD83D\uDCC4 Stderr logs for ${name}:`));
-    console.log(chalk6.gray("\u2550".repeat(50)));
+    console.log(chalk5.red.bold(`\uD83D\uDCC4 Stderr logs for ${name}:`));
+    console.log(chalk5.gray("\u2550".repeat(50)));
     if (fs5.existsSync(proc.stderr_path)) {
       try {
         const output = await readFileTail(proc.stderr_path, lines);
-        console.log(output || chalk6.gray("(no errors)"));
+        console.log(output || chalk5.gray("(no errors)"));
       } catch (err) {
-        console.log(chalk6.red(`Error reading stderr: ${err}`));
+        console.log(chalk5.red(`Error reading stderr: ${err}`));
       }
     } else {
-      console.log(chalk6.gray("(log file not found)"));
+      console.log(chalk5.gray("(log file not found)"));
     }
   }
 }
@@ -1742,35 +2262,44 @@ init_logger();
 init_db();
 init_utils();
 init_platform();
-import chalk7 from "chalk";
+import chalk6 from "chalk";
 async function showDetails(name) {
   const proc = getProcess(name);
   if (!proc) {
     error(`No process found named '${name}'`);
     return;
   }
-  const isRunning = await isProcessRunning(proc.pid, proc.command);
+  let isRunning = await isProcessRunning(proc.pid, proc.command);
+  if (!isRunning && proc.pid > 0) {
+    const reconciled = await reconcileProcessPids([{ name: proc.name, pid: proc.pid, command: proc.command, workdir: proc.workdir }], new Set([proc.pid]));
+    const newPid = reconciled.get(proc.name);
+    if (newPid) {
+      updateProcessPid(proc.name, newPid);
+      proc.pid = newPid;
+      isRunning = true;
+    }
+  }
   const runtime = calculateRuntime(proc.timestamp);
   const envVars = parseEnvString(proc.env);
   const ports = isRunning ? await getProcessPorts(proc.pid) : [];
-  const portDisplay = ports.length > 0 ? ports.map((p) => chalk7.hex("#FF6B6B")(`:${p}`)).join(", ") : null;
+  const portDisplay = ports.length > 0 ? ports.map((p) => chalk6.hex("#FF6B6B")(`:${p}`)).join(", ") : null;
   const details = `
-${chalk7.bold("Process Details:")}
-${chalk7.gray("\u2550".repeat(50))}
-${chalk7.cyan.bold("Name:")} ${proc.name}
-${chalk7.yellow.bold("PID:")} ${proc.pid}${portDisplay ? `
-${chalk7.hex("#FF6B6B").bold("Port:")} ${portDisplay}` : ""}
-${chalk7.bold("Status:")} ${isRunning ? chalk7.green.bold("\u25CF Running") : chalk7.red.bold("\u25CB Stopped")}
-${chalk7.magenta.bold("Runtime:")} ${runtime}
-${chalk7.blue.bold("Working Directory:")} ${proc.workdir}
-${chalk7.white.bold("Command:")} ${proc.command}
-${chalk7.gray.bold("Config Path:")} ${proc.configPath}
-${chalk7.green.bold("Stdout Path:")} ${proc.stdout_path}
-${chalk7.red.bold("Stderr Path:")} ${proc.stderr_path}
+${chalk6.bold("Process Details:")}
+${chalk6.gray("\u2550".repeat(50))}
+${chalk6.cyan.bold("Name:")} ${proc.name}
+${chalk6.yellow.bold("PID:")} ${proc.pid}${portDisplay ? `
+${chalk6.hex("#FF6B6B").bold("Port:")} ${portDisplay}` : ""}
+${chalk6.bold("Status:")} ${isRunning ? chalk6.green.bold("\u25CF Running") : chalk6.red.bold("\u25CB Stopped")}
+${chalk6.magenta.bold("Runtime:")} ${runtime}
+${chalk6.blue.bold("Working Directory:")} ${proc.workdir}
+${chalk6.white.bold("Command:")} ${proc.command}
+${chalk6.gray.bold("Config Path:")} ${proc.configPath}
+${chalk6.green.bold("Stdout Path:")} ${proc.stdout_path}
+${chalk6.red.bold("Stderr Path:")} ${proc.stderr_path}
 
-${chalk7.bold("\uD83D\uDD27 Environment Variables:")}
-${chalk7.gray("\u2550".repeat(50))}
-${Object.entries(envVars).map(([key, value]) => `${chalk7.cyan.bold(key)} = ${chalk7.yellow(value)}`).join(`
+${chalk6.bold("\uD83D\uDD27 Environment Variables:")}
+${chalk6.gray("\u2550".repeat(50))}
+${Object.entries(envVars).map(([key, value]) => `${chalk6.cyan.bold(key)} = ${chalk6.yellow(value)}`).join(`
 `)}
 `;
   announce(details, `Process Details: ${name}`);
@@ -1781,8 +2310,8 @@ init_logger();
 init_platform();
 init_db();
 import dedent from "dedent";
-import chalk8 from "chalk";
-import { join as join3 } from "path";
+import chalk7 from "chalk";
+import { join as join4 } from "path";
 var {sleep: sleep3 } = globalThis.Bun;
 import { configure } from "measure-fn";
 if (!Bun.argv.includes("--_serve")) {
@@ -1790,15 +2319,55 @@ if (!Bun.argv.includes("--_serve")) {
     configure({ silent: true });
   }
 }
+function redirectConsoleToFiles() {
+  const stdoutPath = Bun.env.BGR_STDOUT;
+  const stderrPath = Bun.env.BGR_STDERR;
+  if (!stdoutPath && !stderrPath)
+    return;
+  const { appendFileSync } = __require("fs");
+  const stripAnsi2 = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+  const timestamp = () => new Date().toISOString().replace("T", " ").substring(0, 19);
+  if (stdoutPath) {
+    const origLog = console.log;
+    const origWarn = console.warn;
+    console.log = (...args) => {
+      const line = `[${timestamp()}] ${stripAnsi2(args.map(String).join(" "))}
+`;
+      try {
+        appendFileSync(stdoutPath, line);
+      } catch {}
+      origLog.apply(console, args);
+    };
+    console.warn = (...args) => {
+      const line = `[${timestamp()}] WARN: ${stripAnsi2(args.map(String).join(" "))}
+`;
+      try {
+        appendFileSync(stdoutPath, line);
+      } catch {}
+      origWarn.apply(console, args);
+    };
+  }
+  if (stderrPath) {
+    const origError = console.error;
+    console.error = (...args) => {
+      const line = `[${timestamp()}] ERROR: ${stripAnsi2(args.map(String).join(" "))}
+`;
+      try {
+        appendFileSync(stderrPath, line);
+      } catch {}
+      origError.apply(console, args);
+    };
+  }
+}
 async function showHelp() {
   const usage = dedent`
-    ${chalk8.bold("bgrun \u2014 Bun Background Runner")}
-    ${chalk8.gray("\u2550".repeat(50))}
+    ${chalk7.bold("bgrun \u2014 Bun Background Runner")}
+    ${chalk7.gray("\u2550".repeat(50))}
 
-    ${chalk8.yellow("Usage:")}
+    ${chalk7.yellow("Usage:")}
       bgrun [name] [options]
 
-    ${chalk8.yellow("Commands:")}
+    ${chalk7.yellow("Commands:")}
       bgrun                     List all processes
       bgrun [name]             Show details for a process
       bgrun --dashboard        Launch web dashboard (managed by bgrun)
@@ -1811,7 +2380,7 @@ async function showHelp() {
       bgrun --clean            Remove all stopped processes
       bgrun --nuke             Delete ALL processes
 
-    ${chalk8.yellow("Options:")}
+    ${chalk7.yellow("Options:")}
       --name <string>        Process name (required for new)
       --command <string>     Process command (required for new)
       --directory <path>     Working directory (required for new)
@@ -1831,7 +2400,7 @@ async function showHelp() {
       --port <number>        Port for dashboard (default: 3000)
       --help                 Show this help message
 
-    ${chalk8.yellow("Examples:")}
+    ${chalk7.yellow("Examples:")}
       bgrun --dashboard
       bgrun --name myapp --command "bun run dev" --directory . --watch
       bgrun myapp --logs --lines 50
@@ -1878,11 +2447,13 @@ async function run2() {
     allowPositionals: true
   });
   if (values["_serve"]) {
+    redirectConsoleToFiles();
     const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
     await startServer2();
     return;
   }
   if (values["_guard-loop"]) {
+    redirectConsoleToFiles();
     const { startGuardLoop: startGuardLoop2 } = await Promise.resolve().then(() => (init_guard(), exports_guard));
     const intervalStr = positionals[0];
     const intervalMs = intervalStr ? parseInt(intervalStr) * 1000 : undefined;
@@ -1892,7 +2463,7 @@ async function run2() {
   if (values.dashboard) {
     const dashboardName = "bgr-dashboard";
     const homePath3 = getHomeDir();
-    const bgrDir2 = join3(homePath3, ".bgr");
+    const bgrDir2 = join4(homePath3, ".bgr");
     const requestedPort = values.port;
     const existing = getProcess(dashboardName);
     if (existing && await isProcessRunning(existing.pid)) {
@@ -1906,10 +2477,10 @@ async function run2() {
       const portStr = existingPorts.length > 0 ? `:${existingPorts[0]}` : "(detecting...)";
       announce(`Dashboard is already running (PID ${existing.pid})
 
-` + `  \uD83C\uDF10  ${chalk8.cyan(`http://localhost${portStr}`)}
+` + `  \uD83C\uDF10  ${chalk7.cyan(`http://localhost${portStr}`)}
 
-  Use ${chalk8.yellow(`bgrun --stop ${dashboardName}`)} to stop it
-  Use ${chalk8.yellow(`bgrun --dashboard --force`)} to restart`, "BGR Dashboard");
+  Use ${chalk7.yellow(`bgrun --stop ${dashboardName}`)} to stop it
+  Use ${chalk7.yellow(`bgrun --dashboard --force`)} to restart`, "BGR Dashboard");
       return;
     }
     if (existing) {
@@ -1927,35 +2498,39 @@ async function run2() {
     const scriptPath = resolve(process.argv[1]);
     const spawnCommand = `bun run ${scriptPath} --_serve`;
     const command = `bgrun --_serve`;
-    const stdoutPath = join3(bgrDir2, `${dashboardName}-out.txt`);
-    const stderrPath = join3(bgrDir2, `${dashboardName}-err.txt`);
+    const stdoutPath = join4(bgrDir2, `${dashboardName}-out.txt`);
+    const stderrPath = join4(bgrDir2, `${dashboardName}-err.txt`);
     await Bun.write(stdoutPath, "");
     await Bun.write(stderrPath, "");
     const spawnEnv = { ...Bun.env };
     if (requestedPort) {
       spawnEnv.BUN_PORT = requestedPort;
     }
+    spawnEnv.BGR_STDOUT = stdoutPath;
+    spawnEnv.BGR_STDERR = stderrPath;
     const targetPort = parseInt(requestedPort || Bun.env.BUN_PORT || "3000");
     if (!isNaN(targetPort) && targetPort > 0) {
       const portFree = await isPortFree(targetPort);
       if (!portFree) {
-        console.log(chalk8.yellow(`  \u26A1 Port ${targetPort} is occupied \u2014 reclaiming...`));
+        console.log(chalk7.yellow(`  \u26A1 Port ${targetPort} is occupied \u2014 reclaiming...`));
         await killProcessOnPort(targetPort);
         const freed = await waitForPortFree(targetPort, 5000);
         if (!freed) {
-          console.log(chalk8.red(`  \u26A0 Could not free port ${targetPort} \u2014 dashboard may pick a fallback port`));
+          console.log(chalk7.red(`  \u26A0 Could not free port ${targetPort} \u2014 dashboard may pick a fallback port`));
         }
       }
     }
     const newProcess = Bun.spawn(getShellCommand(spawnCommand), {
       env: spawnEnv,
       cwd: bgrDir2,
-      stdout: Bun.file(stdoutPath),
-      stderr: Bun.file(stderrPath)
+      stdout: "ignore",
+      stderr: "ignore",
+      detached: true
     });
     newProcess.unref();
     await sleep3(2000);
-    const actualPid = await findChildPid(newProcess.pid);
+    const resolvedPort = parseInt(requestedPort || Bun.env.BUN_PORT || "3000");
+    const actualPid = await findPidByPort(resolvedPort, 1e4) ?? await findChildPid(newProcess.pid);
     let actualPort = null;
     for (let attempt = 0;attempt < 10; attempt++) {
       const ports = await getProcessPorts(actualPid);
@@ -1978,19 +2553,19 @@ async function run2() {
     const portDisplay = actualPort ? String(actualPort) : "(detecting...)";
     const urlDisplay = actualPort ? `http://localhost:${actualPort}` : "http://localhost (port auto-assigned)";
     const msg = dedent`
-      ${chalk8.bold("\u26A1 BGR Dashboard launched")}
-      ${chalk8.gray("\u2500".repeat(40))}
+      ${chalk7.bold("\u26A1 BGR Dashboard launched")}
+      ${chalk7.gray("\u2500".repeat(40))}
 
-        \u{1f310}  Open in browser: ${chalk8.cyan.underline(urlDisplay)}
+        \u{1f310}  Open in browser: ${chalk7.cyan.underline(urlDisplay)}
         \u{1f4ca}  Manage all your processes from the web UI
         \u{1f504}  Auto-refreshes every 3 seconds
 
-      ${chalk8.gray("\u2500".repeat(40))}
-        Process: ${chalk8.white(dashboardName)}  |  PID: ${chalk8.white(String(actualPid))}  |  Port: ${chalk8.white(portDisplay)}
+      ${chalk7.gray("\u2500".repeat(40))}
+        Process: ${chalk7.white(dashboardName)}  |  PID: ${chalk7.white(String(actualPid))}  |  Port: ${chalk7.white(portDisplay)}
 
-        ${chalk8.yellow("bgrun bgr-dashboard --logs")}    View dashboard logs
-        ${chalk8.yellow("bgrun --stop bgr-dashboard")}    Stop the dashboard
-        ${chalk8.yellow("bgrun --restart bgr-dashboard")} Restart the dashboard
+        ${chalk7.yellow("bgrun bgr-dashboard --logs")}    View dashboard logs
+        ${chalk7.yellow("bgrun --stop bgr-dashboard")}    Stop the dashboard
+        ${chalk7.yellow("bgrun --restart bgr-dashboard")} Restart the dashboard
     `;
     announce(msg, "BGR Dashboard");
     return;
@@ -1998,13 +2573,13 @@ async function run2() {
   if (values.guard) {
     const guardName = "bgr-guard";
     const homePath3 = getHomeDir();
-    const bgrDir2 = join3(homePath3, ".bgr");
+    const bgrDir2 = join4(homePath3, ".bgr");
     const existing = getProcess(guardName);
     if (existing && await isProcessRunning(existing.pid)) {
       announce(`Guard is already running (PID ${existing.pid})
 
-  Use ${chalk8.yellow(`bgrun --stop ${guardName}`)} to stop it
-  Use ${chalk8.yellow(`bgrun --guard --force`)} to restart`, "BGR Guard");
+  Use ${chalk7.yellow(`bgrun --stop ${guardName}`)} to stop it
+  Use ${chalk7.yellow(`bgrun --guard --force`)} to restart`, "BGR Guard");
       return;
     }
     if (existing) {
@@ -2017,19 +2592,27 @@ async function run2() {
     const scriptPath = resolve(process.argv[1]);
     const spawnCommand = `bun run ${scriptPath} --_guard-loop`;
     const command = `bgrun --_guard-loop`;
-    const stdoutPath = join3(bgrDir2, `${guardName}-out.txt`);
-    const stderrPath = join3(bgrDir2, `${guardName}-err.txt`);
+    const stdoutPath = join4(bgrDir2, `${guardName}-out.txt`);
+    const stderrPath = join4(bgrDir2, `${guardName}-err.txt`);
     await Bun.write(stdoutPath, "");
     await Bun.write(stderrPath, "");
     const newProcess = Bun.spawn(getShellCommand(spawnCommand), {
-      env: { ...Bun.env },
+      env: { ...Bun.env, BGR_STDOUT: stdoutPath, BGR_STDERR: stderrPath },
       cwd: bgrDir2,
-      stdout: Bun.file(stdoutPath),
-      stderr: Bun.file(stderrPath)
+      stdout: "ignore",
+      stderr: "ignore",
+      detached: true
     });
     newProcess.unref();
     await sleep3(1000);
-    const actualPid = await findChildPid(newProcess.pid);
+    let actualPid = await findChildPid(newProcess.pid);
+    if (!await isProcessRunning(actualPid)) {
+      const { psExec: ps } = await Promise.resolve().then(() => (init_platform(), exports_platform));
+      const result = ps(`Get-CimInstance Win32_Process -Filter "Name='bun.exe'" | Where-Object { $_.CommandLine -match '_guard-loop' } | Sort-Object -Property CreationDate -Descending | Select-Object -First 1 -ExpandProperty ProcessId`, 3000);
+      const foundPid = parseInt(result.trim());
+      if (!isNaN(foundPid) && foundPid > 0)
+        actualPid = foundPid;
+    }
     await retryDatabaseOperation(() => insertProcess({
       pid: actualPid,
       workdir: bgrDir2,
@@ -2041,19 +2624,19 @@ async function run2() {
       stderr_path: stderrPath
     }));
     const msg = dedent`
-      ${chalk8.bold("\uD83D\uDEE1\uFE0F  BGR Standalone Guard launched")}
-      ${chalk8.gray("\u2500".repeat(40))}
+      ${chalk7.bold("\uD83D\uDEE1\uFE0F  BGR Standalone Guard launched")}
+      ${chalk7.gray("\u2500".repeat(40))}
 
         Monitors: All processes with BGR_KEEP_ALIVE=true
         Also watches: bgr-dashboard (auto-restart if it dies)
         Check interval: 30 seconds
         Backoff: Exponential after 5 rapid crashes
 
-      ${chalk8.gray("\u2500".repeat(40))}
-        Process: ${chalk8.white(guardName)}  |  PID: ${chalk8.white(String(actualPid))}
+      ${chalk7.gray("\u2500".repeat(40))}
+        Process: ${chalk7.white(guardName)}  |  PID: ${chalk7.white(String(actualPid))}
 
-        ${chalk8.yellow(`bgrun ${guardName} --logs`)}    View guard logs
-        ${chalk8.yellow(`bgrun --stop ${guardName}`)}    Stop the guard
+        ${chalk7.yellow(`bgrun ${guardName} --logs`)}    View guard logs
+        ${chalk7.yellow(`bgrun --stop ${guardName}`)}    Stop the guard
     `;
     announce(msg, "BGR Guard");
     return;
@@ -2070,13 +2653,13 @@ async function run2() {
     const info = getDbInfo();
     const version = await getVersion();
     console.log(dedent`
-      ${chalk8.bold("bgrun debug info")}
-      ${chalk8.gray("\u2500".repeat(40))}
-      Version:   ${chalk8.cyan(version)}
-      BGR Home:  ${chalk8.yellow(info.bgrHome)}
-      DB Path:   ${chalk8.yellow(info.dbPath)}
+      ${chalk7.bold("bgrun debug info")}
+      ${chalk7.gray("\u2500".repeat(40))}
+      Version:   ${chalk7.cyan(version)}
+      BGR Home:  ${chalk7.yellow(info.bgrHome)}
+      DB Path:   ${chalk7.yellow(info.dbPath)}
       DB File:   ${info.dbFilename}
-      DB Exists: ${info.exists ? chalk8.green("\u2713") : chalk8.red("\u2717")}
+      DB Exists: ${info.exists ? chalk7.green("\u2713") : chalk7.red("\u2717")}
       Platform:  ${process.platform}
       Bun:       ${Bun.version}
     `);
@@ -2097,12 +2680,12 @@ async function run2() {
       error("No processes registered.");
       return;
     }
-    console.log(chalk8.bold(`
+    console.log(chalk7.bold(`
   Restarting ${all.length} processes...
 `));
     for (const proc of all) {
       try {
-        console.log(chalk8.yellow(`  \u21BB Restarting ${proc.name}...`));
+        console.log(chalk7.yellow(`  \u21BB Restarting ${proc.name}...`));
         await handleRun({
           action: "run",
           name: proc.name,
@@ -2110,10 +2693,10 @@ async function run2() {
           remoteName: ""
         });
       } catch (err) {
-        console.error(chalk8.red(`  \u2717 Failed to restart ${proc.name}: ${err.message}`));
+        console.error(chalk7.red(`  \u2717 Failed to restart ${proc.name}: ${err.message}`));
       }
     }
-    console.log(chalk8.green(`
+    console.log(chalk7.green(`
   \u2713 All processes restarted.
 `));
     return;
@@ -2125,22 +2708,22 @@ async function run2() {
       error("No processes registered.");
       return;
     }
-    console.log(chalk8.bold(`
+    console.log(chalk7.bold(`
   Stopping ${all.length} processes...
 `));
     for (const proc of all) {
       try {
         if (await isProcessRunning(proc.pid)) {
-          console.log(chalk8.yellow(`  \u25A0 Stopping ${proc.name} (PID ${proc.pid})...`));
+          console.log(chalk7.yellow(`  \u25A0 Stopping ${proc.name} (PID ${proc.pid})...`));
           await handleStop(proc.name);
         } else {
-          console.log(chalk8.gray(`  \u25CB ${proc.name} already stopped`));
+          console.log(chalk7.gray(`  \u25CB ${proc.name} already stopped`));
         }
       } catch (err) {
-        console.error(chalk8.red(`  \u2717 Failed to stop ${proc.name}: ${err.message}`));
+        console.error(chalk7.red(`  \u2717 Failed to stop ${proc.name}: ${err.message}`));
       }
     }
-    console.log(chalk8.green(`
+    console.log(chalk7.green(`
   \u2713 All processes stopped.
 `));
     return;
@@ -2201,6 +2784,13 @@ async function run2() {
     });
     return;
   }
+  if (name === "list") {
+    await showAll({
+      json: values.json,
+      filter: values.filter
+    });
+    return;
+  }
   if (name) {
     if (!values.command && !values.directory) {
       await showDetails(name);
@@ -2230,5 +2820,8 @@ async function run2() {
   }
 }
 run2().catch((err) => {
-  error(err);
+  if (err.name !== "BgrunError") {
+    console.error(err);
+  }
+  process.exit(1);
 });