@plumpslabs/fennec-cli 1.12.2 → 1.13.0

package/dist/index.js

@@ -1958,6 +1958,9 @@ function renderKV(key, value, options) {
   const pad = " ".repeat(indent);
   return `${pad}${pc.dim(key + sep)} ${value}`;
 }
+function renderKVColor(key, value, color = pc.bold) {
+  return `  ${pc.dim(key + ":")} ${color(value)}`;
+}
 function createSpinner(text) {
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   let i = 0;
@@ -2010,10 +2013,10 @@ async function selectPrompt(message, options) {
   console.log(`  ${pc.dim("0)  Cancel")}
 `);
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve8) => {
+  const answer = await new Promise((resolve12) => {
     rl.question(`  ${pc.bold("Enter number")} ${pc.dim("(0-" + options.length + ")")}: `, (ans) => {
       rl.close();
-      resolve8(ans.trim());
+      resolve12(ans.trim());
     });
   });
   const num = parseInt(answer, 10);
@@ -2028,11 +2031,11 @@ async function selectPrompt(message, options) {
 async function confirmPrompt(message, defaultValue = false) {
   const hint = defaultValue ? pc.bold("Y") + pc.dim("/n") : pc.dim("y/") + pc.bold("N");
   const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve8) => {
+  const answer = await new Promise((resolve12) => {
     rl.question(`
   ${message} ${pc.dim("(" + hint + ")")}: `, (ans) => {
       rl.close();
-      resolve8(ans.trim().toLowerCase());
+      resolve12(ans.trim().toLowerCase());
     });
   });
   if (!answer) return defaultValue;
@@ -2088,7 +2091,7 @@ function hexColor(color) {
 }
 var fennecOrange2 = hexColor("#FF6432");
 var fennecGold = hexColor("#FFB347");
-var VERSION = "1.12.2";
+var VERSION = "1.13.0";
 var cachedBanner = null;
 var cachedCompact = null;
 function generateBanner() {
@@ -2220,6 +2223,7 @@ function showHelp() {
 }
 
 // src/commands/pipe.ts
+import { PipeWatcher } from "@plumpslabs/fennec-core";
 async function pipeCommand(args2) {
   const nameIndex = args2.indexOf("--name");
   const name = nameIndex !== -1 ? args2[nameIndex + 1] : "pipe";
@@ -2227,7 +2231,6 @@ async function pipeCommand(args2) {
     console.error("Error: --name is required for pipe command");
     process.exit(1);
   }
-  const { PipeWatcher } = await import("@plumpslabs/fennec-core");
   const watcher = new PipeWatcher();
   const { write } = watcher.createPipe(name);
   console.error(`Pipe watcher '${name}' active. Forwarding stdin...`);
@@ -2265,13 +2268,13 @@ async function pipeCommand(args2) {
 }
 
 // src/commands/attach-pid.ts
+import { PortDetector } from "@plumpslabs/fennec-core";
 async function attachPidCommand(args2) {
   const pid = parseInt(args2[0], 10);
   if (isNaN(pid)) {
     console.error("Error: valid PID is required");
     process.exit(1);
   }
-  const { PortDetector } = await import("@plumpslabs/fennec-core");
   const detector = new PortDetector();
   const info = detector.detectByPid(pid);
   if (info) {
@@ -2284,14 +2287,14 @@ async function attachPidCommand(args2) {
 }
 
 // src/commands/attach-port.ts
+import { PortDetector as PortDetector2 } from "@plumpslabs/fennec-core";
 async function attachPortCommand(args2) {
   const port = parseInt(args2[0], 10);
   if (isNaN(port)) {
     console.error("Error: valid port number is required");
     process.exit(1);
   }
-  const { PortDetector } = await import("@plumpslabs/fennec-core");
-  const detector = new PortDetector();
+  const detector = new PortDetector2();
   const info = detector.detectByPort(port);
   if (info) {
     console.log(`Found process on port ${port}: PID ${info.pid}${info.command ? ` (${info.command})` : ""}`);
@@ -2304,6 +2307,7 @@ async function attachPortCommand(args2) {
 // src/commands/watch.ts
 import { existsSync } from "fs";
 import { resolve } from "path";
+import { LogWatcher } from "@plumpslabs/fennec-core";
 async function watchCommand(args2) {
   const fileIndex = args2.indexOf("--file");
   const filePath = fileIndex !== -1 ? args2[fileIndex + 1] : void 0;
@@ -2318,7 +2322,6 @@ async function watchCommand(args2) {
     console.error(`Error: File not found: ${resolvedPath}`);
     process.exit(1);
   }
-  const { LogWatcher } = await import("@plumpslabs/fennec-core");
   const watcher = new LogWatcher();
   const watcherId = watcher.watchFile(resolvedPath, name);
   console.log(`Watching file: ${resolvedPath}`);
@@ -2327,12 +2330,12 @@ async function watchCommand(args2) {
 }
 
 // src/commands/start.ts
-import { createWriteStream, readFileSync as readFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { createWriteStream, mkdirSync as mkdirSync2 } from "fs";
 import { resolve as resolve3 } from "path";
 import { homedir as homedir2 } from "os";
 import { spawn } from "child_process";
 import { FennecServer } from "@plumpslabs/fennec-core";
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 
 // src/commands/tracker.ts
 import { existsSync as existsSync2, writeFileSync, readFileSync, mkdirSync, renameSync, statSync, rmSync } from "fs";
@@ -2676,10 +2679,198 @@ function formatProcessState(state) {
   }
 }
 
+// src/commands/ps.ts
+import pc4 from "picocolors";
+async function psCommand(args2) {
+  const watchFlag = args2.includes("-w") || args2.includes("--watch");
+  const systemFlag = args2.includes("--system") || args2.includes("-a") || args2.includes("--all");
+  const jsonFlag = args2.includes("--json");
+  const nameFilter = args2.includes("--name") ? args2[args2.indexOf("--name") + 1] : void 0;
+  const sortBy = args2.includes("--sort") ? args2[args2.indexOf("--sort") + 1] : "name";
+  if (jsonFlag) {
+    await psJson();
+    return;
+  }
+  if (watchFlag && systemFlag) {
+    await watchSystemProcesses(sortBy, 15);
+    return;
+  }
+  if (systemFlag) {
+    const spinner = createSpinner("Scanning system processes...");
+    try {
+      const processes = getSystemProcesses({ name: nameFilter, userOnly: true, sortBy, limit: 30 });
+      spinner.stop();
+      process.stdout.write("\r\x1B[K");
+      if (processes.length === 0) {
+        console.error(`
+  ${pc4.dim("No system processes found.")}
+`);
+        return;
+      }
+      const columns2 = [
+        { key: "pid", label: "PID", align: "right", format: (v) => pc4.dim(String(v).padStart(6)) },
+        { key: "name", label: "Name", format: (v) => pc4.bold(String(v)) },
+        { key: "cpu", label: "CPU%", align: "right", format: (v) => {
+          const n = v;
+          return n > 10 ? pc4.red(String(n)) : n > 5 ? pc4.yellow(String(n)) : pc4.dim(String(n));
+        } },
+        { key: "mem", label: "MEM%", align: "right", format: (v) => {
+          const n = v;
+          return n > 10 ? pc4.red(String(n)) : n > 5 ? pc4.yellow(String(n)) : pc4.dim(String(n));
+        } },
+        { key: "state", label: "State", format: (v) => {
+          const s = String(v);
+          if (s === "R" || s === "Running") return pc4.green(s);
+          if (s === "Z" || s === "Zombie") return pc4.red(s);
+          if (s === "S" || s === "Sleeping") return pc4.cyan(s);
+          return pc4.dim(s);
+        } }
+      ];
+      const rows2 = processes.map((p) => ({ pid: p.pid, name: p.name, cpu: p.cpuPercent, mem: p.memPercent, state: formatProcessState(p.state) }));
+      console.error(`
+  ${symbols.fox} ${pc4.bold("System Processes")} ${pc4.dim(`(top ${processes.length} by ${sortBy})`)}
+`);
+      console.error(renderTable(columns2, rows2));
+      console.error();
+    } catch (error) {
+      spinner.fail("Failed to scan processes");
+      console.error(renderError("Process scan failed", String(error)));
+    }
+    return;
+  }
+  const tracked = readTracked();
+  if (tracked.length === 0) {
+    console.error(`
+  ${pc4.dim("No tracked processes.")}`);
+    console.error(`  ${pc4.dim("Start an app with:")} ${pc4.cyan("fennec start <command> --name <name>")}
+`);
+    return;
+  }
+  const columns = [
+    { key: "name", label: "App", format: (v) => pc4.bold(String(v)) },
+    { key: "pid", label: "PID", align: "right" },
+    { key: "status", label: "Status", format: (v) => {
+      const s = v;
+      return s === "running" ? pc4.green("\u25CF running") : pc4.red("\u25CB stopped");
+    } },
+    { key: "port", label: "Port", format: (v) => {
+      const p = v;
+      return p ? pc4.yellow(`:${p}`) : pc4.dim("-");
+    } },
+    { key: "command", label: "Command", format: (v) => {
+      const c = String(v);
+      return c.length > 50 ? c.slice(0, 50) + "\u2026" : c;
+    } },
+    { key: "uptime", label: "Uptime", format: (v) => pc4.dim(String(v)) }
+  ];
+  const rows = tracked.map((t) => {
+    const running = isProcessRunning(t.pid);
+    const uptime = running ? formatUptime(Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3)) : "-";
+    return { name: t.name, pid: running ? String(t.pid) : pc4.dim(String(t.pid)), status: running ? "running" : "stopped", port: t.port ?? null, command: t.command, uptime };
+  });
+  const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
+  console.error(`
+  ${symbols.fox} ${pc4.bold("Fennec Apps")} ${pc4.dim(`(${runningCount}/${tracked.length} running)`)}
+`);
+  console.error(renderTable(columns, rows));
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec start <command> --name <name> --port <port>")} ${pc4.dim("to add more apps.")}`);
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec log <name>")} ${pc4.dim("to view logs.")}`);
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec stop <name>")} ${pc4.dim("to pause an app.")}`);
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec spawn <name>")} ${pc4.dim("to resume a paused app.")}`);
+  console.error(`  ${pc4.dim("Use")} ${pc4.cyan("fennec kill <name>")} ${pc4.dim("to permanently remove an app.")}`);
+  console.error();
+}
+async function psJson() {
+  const tracked = readTracked();
+  const data = tracked.map((t) => {
+    const running = isProcessRunning(t.pid);
+    return {
+      name: t.name,
+      pid: t.pid,
+      status: running ? "running" : "stopped",
+      port: t.port ?? null,
+      command: t.command,
+      cwd: t.cwd ?? null,
+      startedAt: t.startedAt,
+      uptime: running ? Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3) : null
+    };
+  });
+  console.log(JSON.stringify(data, null, 2));
+}
+async function statusCommand(_args) {
+  const watchFlag = _args.includes("-w") || _args.includes("--watch");
+  const tracked = readTracked();
+  const topSystem = getSystemProcesses({ userOnly: true, sortBy: "cpu", limit: 5 });
+  const totalUserProcs = getSystemProcesses({ userOnly: true }).length;
+  console.error(`
+  ${symbols.fox} ${pc4.bold("Fennec Status")}
+`);
+  if (tracked.length > 0) {
+    const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
+    console.error(`  ${pc4.bold("Managed Apps")} ${pc4.dim(`(${runningCount}/${tracked.length} running)`)}
+`);
+    for (const t of tracked) {
+      const running = isProcessRunning(t.pid);
+      const statusIcon = running ? pc4.green("\u25CF") : pc4.red("\u25CB");
+      const portStr = t.port ? ` ${pc4.yellow(`:${t.port}`)}` : "";
+      const uptime = running ? pc4.dim(formatUptime(Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3))) : pc4.red("stopped");
+      console.error(`  ${statusIcon} ${pc4.bold(t.name)}${portStr} ${pc4.dim(`(PID ${t.pid})`)} \u2014 ${uptime}`);
+    }
+    console.error();
+  } else {
+    console.error(`  ${pc4.dim("No managed apps.")} ${pc4.cyan("fennec start <command> --name <name>")}
+`);
+  }
+  console.error(`  ${pc4.bold("System")} ${pc4.dim(`(${totalUserProcs} user processes)`)}`);
+  for (const p of topSystem) {
+    const cpuStr = p.cpuPercent > 10 ? pc4.red(`${p.cpuPercent}%`) : p.cpuPercent > 5 ? pc4.yellow(`${p.cpuPercent}%`) : pc4.dim(`${p.cpuPercent}%`);
+    const memStr = p.memPercent > 10 ? pc4.red(`${p.memPercent}%`) : p.memPercent > 5 ? pc4.yellow(`${p.memPercent}%`) : pc4.dim(`${p.memPercent}%`);
+    console.error(`  ${pc4.dim(`PID ${p.pid}`)} ${pc4.bold(p.name)} \u2014 CPU: ${cpuStr} MEM: ${memStr}`);
+  }
+  if (watchFlag) await watchSystemProcesses("cpu", 15);
+  console.error();
+}
+async function watchSystemProcesses(sortBy, limit) {
+  console.error(`
+  ${pc4.bold("Watching system processes")} ${pc4.dim("(Ctrl+C to stop, refreshes every 3s)")}
+`);
+  const render = () => {
+    const processes = getSystemProcesses({ userOnly: true, sortBy, limit });
+    const columns = [
+      { key: "pid", label: "PID", align: "right", format: (v) => pc4.dim(String(v).padStart(6)) },
+      { key: "name", label: "Name", format: (v) => pc4.bold(String(v)) },
+      { key: "cpu", label: "CPU%", align: "right", format: (v) => {
+        const n = v;
+        return n > 10 ? pc4.red(String(n)) : n > 5 ? pc4.yellow(String(n)) : pc4.dim(String(n));
+      } },
+      { key: "mem", label: "MEM%", align: "right", format: (v) => {
+        const n = v;
+        return n > 10 ? pc4.red(String(n)) : n > 5 ? pc4.yellow(String(n)) : pc4.dim(String(n));
+      } },
+      { key: "state", label: "S", align: "center" }
+    ];
+    const rows = processes.map((p) => ({ pid: p.pid, name: p.name, cpu: p.cpuPercent, mem: p.memPercent, state: p.state }));
+    return `  ${timestamp()} ${pc4.dim(`${processes.length} processes`)}
+${renderTable(columns, rows, { compact: true })}`;
+  };
+  console.error(render());
+  const interval = setInterval(() => {
+    process.stdout.write("\x1B[J");
+    console.error(render());
+  }, 3e3);
+  await new Promise((resolve12) => {
+    process.once("SIGINT", () => {
+      clearInterval(interval);
+      process.stdout.write("\x1B[J");
+      resolve12();
+    });
+  });
+}
+
 // src/commands/start.ts
 async function startServer(args2) {
   printBanner();
-  console.error(`  ${pc4.dim("Starting Fennec MCP server...")}
+  console.error(`  ${pc5.dim("Starting Fennec MCP server...")}
 `);
   const configIndex = args2.indexOf("--config");
   const configPath = configIndex !== -1 ? args2[configIndex + 1] : void 0;
@@ -2688,11 +2879,11 @@ async function startServer(args2) {
     await resurrectTracked();
     await server.start();
     console.error(`
-  ${pc4.green("\u2713")} ${pc4.bold("Fennec server is running")}`);
+  ${pc5.green("\u2713")} ${pc5.bold("Fennec server is running")}`);
     console.error(`  ${renderKV("Transport", "stdio")}`);
     console.error(`  ${renderKV("AI Agent", "Connect via MCP protocol")}`);
     console.error(`
-  ${pc4.dim("Press Ctrl+C to stop")}
+  ${pc5.dim("Press Ctrl+C to stop")}
 `);
   } catch (error) {
     console.error(renderError("Failed to start server", String(error)));
@@ -2701,7 +2892,7 @@ async function startServer(args2) {
 }
 async function startCommand(args2) {
   printBanner();
-  console.error(`  ${pc4.dim("Starting app...")}
+  console.error(`  ${pc5.dim("Starting app...")}
 `);
   await runCommand(args2);
 }
@@ -2712,12 +2903,13 @@ async function runCommand(args2) {
   const port = portIndex !== -1 ? parseInt(args2[portIndex + 1], 10) : void 0;
   const cwdIndex = args2.indexOf("--cwd");
   const cwd = cwdIndex !== -1 ? args2[cwdIndex + 1] : void 0;
+  const restartFlag = args2.includes("--restart");
   const stopFlags = [nameIndex, portIndex, cwdIndex].filter((i) => i !== -1);
   const cmdEnd = Math.min(...stopFlags, Infinity);
   const cmdParts = args2.slice(0, cmdEnd);
   const cmd = cmdParts.join(" ");
   if (!cmd) {
-    console.error(renderError("Missing command", "Usage: fennec start|run <command> --name <name> [--port <port>] [--cwd <dir>]"));
+    console.error(renderError("Missing command", "Usage: fennec start|run <command> --name <name> [--port <port>] [--cwd <dir>] [--restart]"));
     process.exit(1);
   }
   const appName = name ?? cmdParts[0] ?? "app";
@@ -2725,9 +2917,9 @@ async function runCommand(args2) {
   const existing = tracked.find((t) => t.name === appName);
   if (existing && isProcessRunning(existing.pid)) {
     console.error();
-    console.error(`  ${pc4.yellow("\u26A0")} ${pc4.bold(appName)} ${pc4.dim(`is already running (PID: ${existing.pid})`)}`);
-    console.error(`  ${renderKV("Logs", pc4.cyan(`fennec log ${appName}`))}`);
-    console.error(`  ${renderKV("Stop", pc4.cyan(`fennec kill ${appName}`))}`);
+    console.error(`  ${pc5.yellow("\u26A0")} ${pc5.bold(appName)} ${pc5.dim(`is already running (PID: ${existing.pid})`)}`);
+    console.error(`  ${renderKV("Logs", pc5.cyan(`fennec log ${appName}`))}`);
+    console.error(`  ${renderKV("Stop", pc5.cyan(`fennec kill ${appName}`))}`);
     console.error();
     process.exit(0);
   }
@@ -2735,25 +2927,26 @@ async function runCommand(args2) {
   mkdirSync2(logDir, { recursive: true });
   const logFilePath = resolve3(logDir, `${appName}.log`);
   console.error(`
-  ${symbols.fox} ${pc4.bold("Starting")} ${renderAppName(appName)} ${pc4.dim("(daemon)")}
+  ${symbols.fox} ${pc5.bold("Starting")} ${renderAppName(appName)} ${pc5.dim("(daemon)")}
 `);
   console.error(`  ${renderKV("Command", cmd)}`);
   if (port) console.error(`  ${renderKV("Port", String(port))}`);
   if (cwd) console.error(`  ${renderKV("Directory", cwd)}`);
+  if (restartFlag) console.error(`  ${renderKV("Auto-restart", pc5.green("enabled"))}`);
   console.error(`  ${divider()}`);
   try {
-    const child = spawn(cmdParts[0], cmdParts.slice(1), {
+    let currentChild = spawn(cmdParts[0], cmdParts.slice(1), {
       cwd,
       env: { ...process.env },
       stdio: ["ignore", "pipe", "pipe"],
       detached: true
     });
-    const pid = child.pid ?? 0;
+    const pid = currentChild.pid ?? 0;
     rotateLogFile(logFilePath);
     const logStream = createWriteStream(logFilePath, { flags: "a" });
-    if (child.stdout) child.stdout.pipe(logStream);
-    if (child.stderr) child.stderr.pipe(logStream);
-    child.unref();
+    if (currentChild.stdout) currentChild.stdout.pipe(logStream);
+    if (currentChild.stderr) currentChild.stderr.pipe(logStream);
+    currentChild.unref();
     addTracked({
       name: appName,
       pid,
@@ -2762,32 +2955,45 @@ async function runCommand(args2) {
       cwd,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
-    console.error(`
-  ${pc4.green("\u25CF")} ${pc4.bold(appName)} ${pc4.dim(`started (PID: ${pid})`)}${port ? pc4.dim(` :${port}`) : ""}
-`);
-    await new Promise((r) => setTimeout(r, 1500));
-    try {
-      const initialLogs = readFileSync3(logFilePath, "utf-8").split("\n").filter(Boolean).slice(-8);
-      if (initialLogs.length > 0) {
-        for (const line of initialLogs) {
-          const truncated = line.length > 150 ? line.slice(0, 150) + "\u2026" : line;
-          if (line.toLowerCase().includes("error")) {
-            console.error(`  ${pc4.dim("\u2502")} ${pc4.red(truncated)}`);
-          } else if (line.toLowerCase().includes("warn")) {
-            console.error(`  ${pc4.dim("\u2502")} ${pc4.yellow(truncated)}`);
-          } else {
-            console.error(`  ${pc4.dim("\u2502")} ${truncated}`);
+    console.error(`  ${pc5.green("\u2713")} ${pc5.bold(appName)} ${pc5.dim(`started (PID: ${pid})`)}`);
+    if (restartFlag) {
+      let setupRestartWatch2 = function(c) {
+        c.on("exit", (code, signal) => {
+          if (code !== 0 && signal !== "SIGTERM" && signal !== "SIGKILL") {
+            console.error(`  ${pc5.yellow("\u26A0")} ${pc5.bold(appName)} ${pc5.dim(`exited with code ${code}, restarting...`)}`);
+            const restarted = spawn(cmdParts[0], cmdParts.slice(1), {
+              cwd,
+              env: { ...process.env },
+              stdio: ["ignore", "pipe", "pipe"],
+              detached: true
+            });
+            const newPid = restarted.pid ?? 0;
+            rotateLogFile(logFilePath);
+            const rs = createWriteStream(logFilePath, { flags: "a" });
+            if (restarted.stdout) restarted.stdout.pipe(rs);
+            if (restarted.stderr) restarted.stderr.pipe(rs);
+            restarted.unref();
+            addTracked({ name: appName, pid: newPid, command: cmd, port, cwd, startedAt: (/* @__PURE__ */ new Date()).toISOString() });
+            console.error(`  ${pc5.green("\u2713")} ${pc5.bold(appName)} ${pc5.dim(`restarted (PID: ${newPid})`)}`);
+            currentChild = restarted;
+            setupRestartWatch2(restarted);
           }
-        }
-      }
-    } catch {
+        });
+      };
+      var setupRestartWatch = setupRestartWatch2;
+      console.error(`  ${pc5.dim("Auto-restart enabled \u2014 watching for crashes...")}
+`);
+      setupRestartWatch2(currentChild);
+      await new Promise((resolve12) => {
+        process.once("SIGINT", () => {
+          currentChild.kill("SIGTERM");
+          resolve12();
+        });
+      });
+    }
+    if (!restartFlag) {
+      await psCommand([]);
     }
-    console.error();
-    console.error(`  ${pc4.green("\u2713")} ${pc4.bold(appName)} running in background`);
-    console.error(`  ${renderKV("Logs", pc4.cyan(`fennec log ${appName}`))}`);
-    console.error(`  ${renderKV("Status", pc4.cyan("fennec ps"))}`);
-    console.error(`  ${renderKV("Stop", pc4.cyan(`fennec kill ${appName}`))}`);
-    console.error();
   } catch (error) {
     console.error(renderError(`Failed to start ${appName}`, String(error)));
     process.exit(1);
@@ -2838,227 +3044,70 @@ async function resurrectTracked() {
   spinner.stop();
   process.stdout.write("\r\x1B[K");
   if (resurrected > 0) {
-    console.error(`  ${pc4.green("\u25CF")} ${pc4.bold(`Resurrected ${resurrected} process(es)`)}`);
+    console.error(`  ${pc5.green("\u25CF")} ${pc5.bold(`Resurrected ${resurrected} process(es)`)}`);
   }
   if (failed > 0) {
-    console.error(`  ${pc4.red("\u25CF")} ${pc4.bold(`${failed} process(es) failed to resurrect`)}`);
+    console.error(`  ${pc5.red("\u25CF")} ${pc5.bold(`${failed} process(es) failed to resurrect`)}`);
   }
 }
 
-// src/commands/ps.ts
-import pc5 from "picocolors";
-async function psCommand(args2) {
-  const watchFlag = args2.includes("-w") || args2.includes("--watch");
-  const systemFlag = args2.includes("--system") || args2.includes("-a") || args2.includes("--all");
-  const nameFilter = args2.includes("--name") ? args2[args2.indexOf("--name") + 1] : void 0;
-  const sortBy = args2.includes("--sort") ? args2[args2.indexOf("--sort") + 1] : "name";
-  if (watchFlag && systemFlag) {
-    await watchSystemProcesses(sortBy, 15);
+// src/commands/kill.ts
+import pc6 from "picocolors";
+async function killCommand(args2) {
+  const rawTarget = args2[0];
+  const signalIndex = args2.indexOf("--signal");
+  const signalRaw = signalIndex !== -1 ? args2[signalIndex + 1] : "SIGTERM";
+  const signal = signalRaw ?? "SIGTERM";
+  if (rawTarget === "all" || args2.includes("--all") || args2.includes("-a")) {
+    await killAll(signal);
     return;
   }
-  if (systemFlag) {
-    const spinner = createSpinner("Scanning system processes...");
-    try {
-      const processes = getSystemProcesses({ name: nameFilter, userOnly: true, sortBy, limit: 30 });
-      spinner.stop();
-      process.stdout.write("\r\x1B[K");
-      if (processes.length === 0) {
+  if (!rawTarget) {
+    console.error(renderError("Missing target", "Usage: fennec kill <pid|name|all> [--signal SIGTERM|SIGKILL|SIGINT]"));
+    process.exit(1);
+  }
+  let targetPid;
+  let displayName;
+  const pid = parseInt(rawTarget, 10);
+  if (!isNaN(pid) && String(pid) === rawTarget) {
+    if (!isProcessRunning(pid)) {
+      console.error(renderError("Process not found", `No process with PID ${pid} is running`));
+      process.exit(1);
+    }
+    targetPid = pid;
+    displayName = `PID ${pid}`;
+  } else {
+    const tracked = readTracked();
+    const trackedMatch = tracked.find((t) => t.name === rawTarget);
+    if (trackedMatch && isProcessRunning(trackedMatch.pid)) {
+      targetPid = trackedMatch.pid;
+      displayName = `${trackedMatch.name} (PID ${targetPid})`;
+    } else {
+      const matches = getSystemProcesses({ name: rawTarget, userOnly: true, sortBy: "cpu" });
+      if (matches.length === 0) {
+        console.error(renderError("Process not found", `No running process matching "${rawTarget}"`));
+        process.exit(1);
+      }
+      if (matches.length > 1) {
         console.error(`
-  ${pc5.dim("No system processes found.")}
-`);
-        return;
+  ${pc6.bold(`Multiple processes match "${rawTarget}":`)}`);
+        const selected = await selectPrompt("Select which to kill:", matches.map((p, i) => ({ value: String(i), label: `${p.name} (PID ${p.pid})`, description: `${p.command.slice(0, 80)} \u2014 CPU: ${p.cpuPercent}% MEM: ${p.memPercent}%` })));
+        if (selected === null) {
+          console.error(`  ${pc6.dim("Cancelled")}`);
+          return;
+        }
+        const idx = parseInt(selected, 10);
+        targetPid = matches[idx].pid;
+        displayName = `${matches[idx].name} (PID ${targetPid})`;
+      } else {
+        targetPid = matches[0].pid;
+        displayName = `${matches[0].name} (PID ${targetPid})`;
       }
-      const columns2 = [
-        { key: "pid", label: "PID", align: "right", format: (v) => pc5.dim(String(v).padStart(6)) },
-        { key: "name", label: "Name", format: (v) => pc5.bold(String(v)) },
-        { key: "cpu", label: "CPU%", align: "right", format: (v) => {
-          const n = v;
-          return n > 10 ? pc5.red(String(n)) : n > 5 ? pc5.yellow(String(n)) : pc5.dim(String(n));
-        } },
-        { key: "mem", label: "MEM%", align: "right", format: (v) => {
-          const n = v;
-          return n > 10 ? pc5.red(String(n)) : n > 5 ? pc5.yellow(String(n)) : pc5.dim(String(n));
-        } },
-        { key: "state", label: "State", format: (v) => {
-          const s = String(v);
-          if (s === "R" || s === "Running") return pc5.green(s);
-          if (s === "Z" || s === "Zombie") return pc5.red(s);
-          if (s === "S" || s === "Sleeping") return pc5.cyan(s);
-          return pc5.dim(s);
-        } }
-      ];
-      const rows2 = processes.map((p) => ({ pid: p.pid, name: p.name, cpu: p.cpuPercent, mem: p.memPercent, state: formatProcessState(p.state) }));
-      console.error(`
-  ${symbols.fox} ${pc5.bold("System Processes")} ${pc5.dim(`(top ${processes.length} by ${sortBy})`)}
-`);
-      console.error(renderTable(columns2, rows2));
-      console.error();
-    } catch (error) {
-      spinner.fail("Failed to scan processes");
-      console.error(renderError("Process scan failed", String(error)));
     }
-    return;
   }
-  const tracked = readTracked();
-  if (tracked.length === 0) {
-    console.error(`
-  ${pc5.dim("No tracked processes.")}`);
-    console.error(`  ${pc5.dim("Start an app with:")} ${pc5.cyan("fennec start <command> --name <name>")}
-`);
-    return;
-  }
-  const columns = [
-    { key: "name", label: "App", format: (v) => pc5.bold(String(v)) },
-    { key: "pid", label: "PID", align: "right" },
-    { key: "status", label: "Status", format: (v) => {
-      const s = v;
-      return s === "running" ? pc5.green("\u25CF running") : pc5.red("\u25CB stopped");
-    } },
-    { key: "port", label: "Port", format: (v) => {
-      const p = v;
-      return p ? pc5.yellow(`:${p}`) : pc5.dim("-");
-    } },
-    { key: "command", label: "Command", format: (v) => {
-      const c = String(v);
-      return c.length > 50 ? c.slice(0, 50) + "\u2026" : c;
-    } },
-    { key: "uptime", label: "Uptime", format: (v) => pc5.dim(String(v)) }
-  ];
-  const rows = tracked.map((t) => {
-    const running = isProcessRunning(t.pid);
-    const uptime = running ? formatUptime(Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3)) : "-";
-    return { name: t.name, pid: running ? String(t.pid) : pc5.dim(String(t.pid)), status: running ? "running" : "stopped", port: t.port ?? null, command: t.command, uptime };
-  });
-  const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
-  console.error(`
-  ${symbols.fox} ${pc5.bold("Fennec Apps")} ${pc5.dim(`(${runningCount}/${tracked.length} running)`)}
-`);
-  console.error(renderTable(columns, rows));
-  console.error(`  ${pc5.dim("Use")} ${pc5.cyan("fennec start <command> --name <name> --port <port>")} ${pc5.dim("to add more apps.")}`);
-  console.error(`  ${pc5.dim("Use")} ${pc5.cyan("fennec log <name>")} ${pc5.dim("to view logs.")}`);
-  console.error(`  ${pc5.dim("Use")} ${pc5.cyan("fennec kill <name>")} ${pc5.dim("to stop an app.")}`);
-  console.error();
-}
-async function statusCommand(_args) {
-  const watchFlag = _args.includes("-w") || _args.includes("--watch");
-  const tracked = readTracked();
-  const topSystem = getSystemProcesses({ userOnly: true, sortBy: "cpu", limit: 5 });
-  const totalUserProcs = getSystemProcesses({ userOnly: true }).length;
-  console.error(`
-  ${symbols.fox} ${pc5.bold("Fennec Status")}
-`);
-  if (tracked.length > 0) {
-    const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
-    console.error(`  ${pc5.bold("Managed Apps")} ${pc5.dim(`(${runningCount}/${tracked.length} running)`)}
-`);
-    for (const t of tracked) {
-      const running = isProcessRunning(t.pid);
-      const statusIcon = running ? pc5.green("\u25CF") : pc5.red("\u25CB");
-      const portStr = t.port ? ` ${pc5.yellow(`:${t.port}`)}` : "";
-      const uptime = running ? pc5.dim(formatUptime(Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3))) : pc5.red("stopped");
-      console.error(`  ${statusIcon} ${pc5.bold(t.name)}${portStr} ${pc5.dim(`(PID ${t.pid})`)} \u2014 ${uptime}`);
-    }
-    console.error();
-  } else {
-    console.error(`  ${pc5.dim("No managed apps.")} ${pc5.cyan("fennec start <command> --name <name>")}
-`);
-  }
-  console.error(`  ${pc5.bold("System")} ${pc5.dim(`(${totalUserProcs} user processes)`)}`);
-  for (const p of topSystem) {
-    const cpuStr = p.cpuPercent > 10 ? pc5.red(`${p.cpuPercent}%`) : p.cpuPercent > 5 ? pc5.yellow(`${p.cpuPercent}%`) : pc5.dim(`${p.cpuPercent}%`);
-    const memStr = p.memPercent > 10 ? pc5.red(`${p.memPercent}%`) : p.memPercent > 5 ? pc5.yellow(`${p.memPercent}%`) : pc5.dim(`${p.memPercent}%`);
-    console.error(`  ${pc5.dim(`PID ${p.pid}`)} ${pc5.bold(p.name)} \u2014 CPU: ${cpuStr} MEM: ${memStr}`);
-  }
-  if (watchFlag) await watchSystemProcesses("cpu", 15);
-  console.error();
-}
-async function watchSystemProcesses(sortBy, limit) {
-  console.error(`
-  ${pc5.bold("Watching system processes")} ${pc5.dim("(Ctrl+C to stop, refreshes every 3s)")}
-`);
-  const render = () => {
-    const processes = getSystemProcesses({ userOnly: true, sortBy, limit });
-    const columns = [
-      { key: "pid", label: "PID", align: "right", format: (v) => pc5.dim(String(v).padStart(6)) },
-      { key: "name", label: "Name", format: (v) => pc5.bold(String(v)) },
-      { key: "cpu", label: "CPU%", align: "right", format: (v) => {
-        const n = v;
-        return n > 10 ? pc5.red(String(n)) : n > 5 ? pc5.yellow(String(n)) : pc5.dim(String(n));
-      } },
-      { key: "mem", label: "MEM%", align: "right", format: (v) => {
-        const n = v;
-        return n > 10 ? pc5.red(String(n)) : n > 5 ? pc5.yellow(String(n)) : pc5.dim(String(n));
-      } },
-      { key: "state", label: "S", align: "center" }
-    ];
-    const rows = processes.map((p) => ({ pid: p.pid, name: p.name, cpu: p.cpuPercent, mem: p.memPercent, state: p.state }));
-    return `  ${timestamp()} ${pc5.dim(`${processes.length} processes`)}
-${renderTable(columns, rows, { compact: true })}`;
-  };
-  console.error(render());
-  const interval = setInterval(() => {
-    process.stdout.write("\x1B[J");
-    console.error(render());
-  }, 3e3);
-  await new Promise((resolve8) => {
-    process.once("SIGINT", () => {
-      clearInterval(interval);
-      process.stdout.write("\x1B[J");
-      resolve8();
-    });
-  });
-}
-
-// src/commands/kill.ts
-import pc6 from "picocolors";
-async function killCommand(args2) {
-  const rawTarget = args2[0];
-  const signalIndex = args2.indexOf("--signal");
-  const signalRaw = signalIndex !== -1 ? args2[signalIndex + 1] : "SIGTERM";
-  const signal = signalRaw ?? "SIGTERM";
-  if (rawTarget === "all" || args2.includes("--all") || args2.includes("-a")) {
-    await killAll(signal);
-    return;
-  }
-  if (!rawTarget) {
-    console.error(renderError("Missing target", "Usage: fennec kill <pid|name|all> [--signal SIGTERM|SIGKILL|SIGINT]"));
-    process.exit(1);
-  }
-  let targetPid;
-  let displayName;
-  const pid = parseInt(rawTarget, 10);
-  if (!isNaN(pid) && String(pid) === rawTarget) {
-    if (!isProcessRunning(pid)) {
-      console.error(renderError("Process not found", `No process with PID ${pid} is running`));
-      process.exit(1);
-    }
-    targetPid = pid;
-    displayName = `PID ${pid}`;
-  } else {
-    const matches = getSystemProcesses({ name: rawTarget, userOnly: true, sortBy: "cpu" });
-    if (matches.length === 0) {
-      console.error(renderError("Process not found", `No running process matching "${rawTarget}"`));
-      process.exit(1);
-    }
-    if (matches.length > 1) {
-      console.error(`
-  ${pc6.bold(`Multiple processes match "${rawTarget}":`)}`);
-      const selected = await selectPrompt("Select which to kill:", matches.map((p, i) => ({ value: String(i), label: `${p.name} (PID ${p.pid})`, description: `${p.command.slice(0, 80)} \u2014 CPU: ${p.cpuPercent}% MEM: ${p.memPercent}%` })));
-      if (selected === null) {
-        console.error(`  ${pc6.dim("Cancelled")}`);
-        return;
-      }
-      const idx = parseInt(selected, 10);
-      targetPid = matches[idx].pid;
-      displayName = `${matches[idx].name} (PID ${targetPid})`;
-    } else {
-      targetPid = matches[0].pid;
-      displayName = `${matches[0].name} (PID ${targetPid})`;
-    }
-  }
-  const confirmed = await confirmPrompt(`Kill ${pc6.bold(displayName)} with ${pc6.yellow(signal)}?`, false);
-  if (!confirmed) {
-    console.error(`  ${pc6.dim("Cancelled")}`);
+  const confirmed = await confirmPrompt(`Kill ${pc6.bold(displayName)} with ${pc6.yellow(signal)}?`, false);
+  if (!confirmed) {
+    console.error(`  ${pc6.dim("Cancelled")}`);
     return;
   }
   const spinner = createSpinner(`Sending ${signal} to ${displayName}...`);
@@ -3120,12 +3169,295 @@ async function killAll(signal) {
   if (failed > 0) console.error(`  ${pc6.yellow(`${failed} process(es) could not be killed`)} ${pc6.dim("(try with sudo)")}`);
 }
 
-// src/commands/restart.ts
+// src/commands/stop.ts
 import pc7 from "picocolors";
-import { mkdirSync as mkdirSync3, createWriteStream as createWriteStream2 } from "fs";
+async function stopCommand(args2) {
+  const stopAll = args2.includes("--all") || args2.includes("-a");
+  if (stopAll) {
+    await stopAllTracked();
+    return;
+  }
+  const rawTarget = args2[0];
+  if (!rawTarget) {
+    console.error(renderError("Missing name", "Usage: fennec stop <name|--all>"));
+    process.exit(1);
+  }
+  const tracked = readTracked();
+  const trackedMatch = tracked.find((t) => t.name === rawTarget);
+  if (!trackedMatch) {
+    console.error(renderError("Not found", `No tracked process named "${rawTarget}". Use ${pc7.cyan("fennec kill <pid>")} to kill a system process.`));
+    process.exit(1);
+  }
+  if (!isProcessRunning(trackedMatch.pid)) {
+    console.error(`
+  ${pc7.yellow("\u26A0")} ${pc7.bold(rawTarget)} ${pc7.dim("is already stopped")}`);
+    console.error();
+    process.exit(0);
+  }
+  const displayName = `${trackedMatch.name} (PID ${trackedMatch.pid})`;
+  const confirmed = await confirmPrompt(`Stop ${pc7.bold(displayName)}? ${pc7.dim("It can be re-spawned later via fennec spawn")}`, false);
+  if (!confirmed) {
+    console.error(`  ${pc7.dim("Cancelled")}`);
+    return;
+  }
+  await stopSingleProcess(trackedMatch.pid, trackedMatch.name);
+}
+async function stopAllTracked() {
+  const tracked = readTracked();
+  const running = tracked.filter((t) => isProcessRunning(t.pid));
+  if (running.length === 0) {
+    console.error(`
+  ${pc7.dim("No running tracked processes to stop.")}
+`);
+    return;
+  }
+  console.error(`
+  ${pc7.yellow("\u26A0")} ${pc7.bold(`Stop all ${running.length} running process(es)?`)} ${pc7.dim("(They can be re-spawned later)")}
+`);
+  for (const t of running) {
+    console.error(`  ${pc7.green("\u25CF")} ${pc7.bold(t.name)} ${pc7.dim(`(PID ${t.pid})`)}`);
+  }
+  console.error();
+  const confirmed = await confirmPrompt("Stop all?", false);
+  if (!confirmed) {
+    console.error(`  ${pc7.dim("Cancelled")}
+`);
+    return;
+  }
+  const spinner = createSpinner(`Stopping ${running.length} process(es)...`);
+  let stopped = 0;
+  let failed = 0;
+  for (const t of running) {
+    if (killProcess(t.pid, "SIGTERM")) {
+      stopped++;
+    } else {
+      failed++;
+    }
+  }
+  await new Promise((r) => setTimeout(r, 300));
+  spinner.stop();
+  process.stdout.write("\r\x1B[K");
+  if (stopped > 0) {
+    console.error(`  ${pc7.green("\u2713")} ${pc7.bold(`Stopped ${stopped} process(es)`)} ${pc7.dim("(kept in tracked.json)")}`);
+  }
+  if (failed > 0) {
+    console.error(`  ${pc7.red("\u2717")} ${pc7.bold(`${failed} process(es) failed to stop`)}`);
+  }
+  console.error();
+  await psCommand([]);
+}
+async function stopSingleProcess(pid, name) {
+  const displayName = `${name} (PID ${pid})`;
+  const spinner = createSpinner(`Stopping ${displayName}...`);
+  const success = killProcess(pid, "SIGTERM");
+  if (success) {
+    await new Promise((r) => setTimeout(r, 200));
+    const stillRunning = isProcessRunning(pid);
+    if (stillRunning) {
+      spinner.warn(`${displayName} did not respond to SIGTERM`);
+      const forceKill = await confirmPrompt(`Send ${pc7.red("SIGKILL")} to force stop?`, true);
+      if (forceKill) {
+        const forceSpinner = createSpinner(`Sending SIGKILL to ${displayName}...`);
+        killProcess(pid, "SIGKILL");
+        await new Promise((r) => setTimeout(r, 300));
+        isProcessRunning(pid) ? forceSpinner.fail(`${displayName} could not be stopped (permission denied?)`) : forceSpinner.succeed(`${displayName} force stopped`);
+      } else {
+        console.error(`  ${pc7.yellow("\u26A0")} ${displayName} ${pc7.dim("may still be running")}`);
+      }
+    } else {
+      spinner.succeed(`${displayName} stopped`);
+    }
+    console.error();
+    await psCommand([]);
+  } else {
+    spinner.fail(`Failed to stop ${displayName}`);
+    console.error(renderError("Permission denied", "Try running with sudo or use fennec kill."));
+  }
+}
+
+// src/commands/spawn.ts
+import pc8 from "picocolors";
+import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync3 } from "fs";
 import { resolve as resolve4 } from "path";
 import { homedir as homedir3 } from "os";
 import { spawn as spawn2 } from "child_process";
+async function spawnCommand(args2) {
+  const spawnAll = args2.includes("--all") || args2.includes("-a");
+  const name = args2[0];
+  if (spawnAll) {
+    await spawnAllStopped();
+    return;
+  }
+  if (!name) {
+    await spawnList();
+    return;
+  }
+  const tracked = readTracked();
+  const match = tracked.find((t) => t.name === name);
+  if (!match) {
+    console.error(renderError("Not found", `No tracked process named "${name}". Use ${pc8.cyan("fennec spawn")} to see available processes, or ${pc8.cyan("fennec start <command> --name <name>")} to create a new one.`));
+    process.exit(1);
+  }
+  if (isProcessRunning(match.pid)) {
+    console.error(`
+  ${pc8.yellow("\u26A0")} ${pc8.bold(name)} ${pc8.dim("is already running (PID:")} ${match.pid}${pc8.dim(")")}`);
+    console.error(`  ${pc8.dim("Use")} ${pc8.cyan(`fennec stop ${name}`)} ${pc8.dim("to stop it first.")}`);
+    console.error();
+    process.exit(0);
+  }
+  if (!match.command) {
+    console.error(renderError("No command saved", `"${name}" has no saved command and cannot be re-spawned.`));
+    process.exit(1);
+  }
+  await respawnProcess(match);
+}
+async function spawnAllStopped() {
+  const tracked = readTracked();
+  const toSpawn = tracked.filter((t) => !isProcessRunning(t.pid) && t.command);
+  if (toSpawn.length === 0) {
+    console.error(`
+  ${pc8.dim("No stopped processes with saved commands to spawn.")}
+`);
+    return;
+  }
+  console.error(`
+  ${symbols.fox} ${pc8.bold(`Spawning ${toSpawn.length} process(es)...`)}
+`);
+  for (const t of toSpawn) {
+    console.error(`  ${pc8.dim("\xB7")} ${pc8.bold(t.name)} ${pc8.dim(`(${t.command})`)}`);
+  }
+  console.error();
+  const spinner = createSpinner("Spawning...");
+  let spawned = 0;
+  let failed = 0;
+  for (const proc of toSpawn) {
+    try {
+      const cmdParts = proc.command.split(/\s+/);
+      const logDir = resolve4(homedir3(), ".fennec", "logs");
+      mkdirSync3(logDir, { recursive: true });
+      const logFilePath = resolve4(logDir, `${proc.name}.log`);
+      const child = spawn2(cmdParts[0], cmdParts.slice(1), {
+        cwd: proc.cwd,
+        env: { ...process.env },
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: true
+      });
+      const pid = child.pid ?? 0;
+      rotateLogFile(logFilePath);
+      const logStream = createWriteStream2(logFilePath, { flags: "a" });
+      if (child.stdout) child.stdout.pipe(logStream);
+      if (child.stderr) child.stderr.pipe(logStream);
+      child.unref();
+      addTracked({
+        name: proc.name,
+        pid,
+        command: proc.command,
+        port: proc.port,
+        cwd: proc.cwd,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      spawned++;
+    } catch {
+      failed++;
+    }
+  }
+  spinner.stop();
+  process.stdout.write("\r\x1B[K");
+  if (spawned > 0) {
+    console.error(`  ${pc8.green("\u2713")} ${pc8.bold(`Spawned ${spawned} process(es)`)}`);
+  }
+  if (failed > 0) {
+    console.error(`  ${pc8.red("\u2717")} ${pc8.bold(`${failed} process(es) failed to spawn`)}`);
+  }
+  console.error();
+  await psCommand([]);
+}
+async function spawnList() {
+  const tracked = readTracked();
+  if (tracked.length === 0) {
+    console.error(`
+  ${pc8.dim("No tracked processes found.")}`);
+    console.error(`  ${pc8.dim("Start an app first:")} ${pc8.cyan("fennec start <command> --name <name>")}`);
+    console.error();
+    return;
+  }
+  const stopped = tracked.filter((t) => !isProcessRunning(t.pid));
+  const running = tracked.filter((t) => isProcessRunning(t.pid));
+  if (stopped.length === 0) {
+    console.error(`
+  ${pc8.dim("All tracked processes are running. Nothing to spawn.")}`);
+    console.error();
+    return;
+  }
+  console.error(`
+  ${symbols.fox} ${pc8.bold("Available to spawn")} ${pc8.dim(`(${stopped.length}/${tracked.length} stopped)`)}`);
+  if (running.length > 0) {
+    console.error(`  ${pc8.dim("Running (use stop first):")}`);
+    for (const r of running) {
+      console.error(`    ${pc8.green("\u25CF")} ${pc8.bold(r.name)} ${pc8.dim(`(PID ${r.pid})`)}`);
+    }
+    console.error();
+  }
+  const selected = await selectPrompt("Select a process to spawn:", stopped.map((t) => ({
+    value: t.name,
+    label: t.name,
+    description: t.command.length > 80 ? t.command.slice(0, 80) + "..." : t.command
+  })));
+  if (selected === null) {
+    console.error(`  ${pc8.dim("Cancelled")}`);
+    return;
+  }
+  const match = stopped.find((t) => t.name === selected);
+  if (match) {
+    await respawnProcess(match);
+  }
+}
+async function respawnProcess(proc) {
+  const cmdParts = proc.command.split(/\s+/);
+  const logDir = resolve4(homedir3(), ".fennec", "logs");
+  mkdirSync3(logDir, { recursive: true });
+  const logFilePath = resolve4(logDir, `${proc.name}.log`);
+  console.error(`
+  ${symbols.fox} ${pc8.bold("Spawning")} ${renderAppName(proc.name)} ${pc8.dim("(from saved config)")}
+`);
+  console.error(`  ${renderKV("Command", proc.command)}`);
+  if (proc.cwd) console.error(`  ${renderKV("Directory", proc.cwd)}`);
+  if (proc.port) console.error(`  ${renderKV("Port", String(proc.port))}`);
+  try {
+    const child = spawn2(cmdParts[0], cmdParts.slice(1), {
+      cwd: proc.cwd,
+      env: { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true
+    });
+    const pid = child.pid ?? 0;
+    rotateLogFile(logFilePath);
+    const logStream = createWriteStream2(logFilePath, { flags: "a" });
+    if (child.stdout) child.stdout.pipe(logStream);
+    if (child.stderr) child.stderr.pipe(logStream);
+    child.unref();
+    addTracked({
+      name: proc.name,
+      pid,
+      command: proc.command,
+      port: proc.port,
+      cwd: proc.cwd,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    console.error(`  ${pc8.green("\u2713")} ${pc8.bold(proc.name)} ${pc8.dim(`spawned (PID: ${pid})`)}`);
+    await psCommand([]);
+  } catch (error) {
+    console.error(renderError(`Failed to spawn ${proc.name}`, String(error)));
+    process.exit(1);
+  }
+}
+
+// src/commands/restart.ts
+import pc9 from "picocolors";
+import { mkdirSync as mkdirSync4, createWriteStream as createWriteStream3 } from "fs";
+import { resolve as resolve5 } from "path";
+import { homedir as homedir4 } from "os";
+import { spawn as spawn3 } from "child_process";
 async function restartCommand(args2) {
   const name = args2[0];
   if (!name) {
@@ -3150,9 +3482,9 @@ async function restartCommand(args2) {
       targetPid = processes[0].pid;
     }
   }
-  const confirmed = await confirmPrompt(`Restart ${pc7.bold(`${name} (PID ${targetPid})`)}?`, false);
+  const confirmed = await confirmPrompt(`Restart ${pc9.bold(`${name} (PID ${targetPid})`)}?`, false);
   if (!confirmed) {
-    console.error(`  ${pc7.dim("Cancelled")}`);
+    console.error(`  ${pc9.dim("Cancelled")}`);
     return;
   }
   const spinner = createSpinner(`Stopping PID ${targetPid}...`);
@@ -3172,17 +3504,17 @@ async function restartCommand(args2) {
     const respawnSpinner = createSpinner(`Re-spawning ${trackedEntry.name}...`);
     try {
       const cmdParts = trackedEntry.command.split(" ");
-      const logDir = resolve4(homedir3(), ".fennec", "logs");
-      mkdirSync3(logDir, { recursive: true });
-      const logFilePath = resolve4(logDir, `${trackedEntry.name}.log`);
-      const child = spawn2(cmdParts[0], cmdParts.slice(1), {
+      const logDir = resolve5(homedir4(), ".fennec", "logs");
+      mkdirSync4(logDir, { recursive: true });
+      const logFilePath = resolve5(logDir, `${trackedEntry.name}.log`);
+      const child = spawn3(cmdParts[0], cmdParts.slice(1), {
         cwd: trackedEntry.cwd,
         env: { ...process.env },
         stdio: ["ignore", "pipe", "pipe"],
         detached: true
       });
       rotateLogFile(logFilePath);
-      const logStream = createWriteStream2(logFilePath, { flags: "a" });
+      const logStream = createWriteStream3(logFilePath, { flags: "a" });
       if (child.stdout) child.stdout.pipe(logStream);
       if (child.stderr) child.stderr.pipe(logStream);
       child.unref();
@@ -3198,35 +3530,41 @@ async function restartCommand(args2) {
       respawnSpinner.succeed(`${trackedEntry.name} restarted (PID: ${child.pid})`);
     } catch (error) {
       respawnSpinner.fail(`Failed to re-spawn ${trackedEntry.name}: ${String(error)}`);
-      console.error(`  ${pc7.dim("Config preserved. Re-run manually:")} ${renderCommand(trackedEntry.command)}`);
+      console.error(`  ${pc9.dim("Config preserved. Re-run manually:")} ${renderCommand(trackedEntry.command)}`);
     }
   } else {
-    console.error(`  ${pc7.dim("No tracked config found. Re-run manually:")} ${renderCommand(name)}`);
+    console.error(`  ${pc9.dim("No tracked config found. Re-run manually:")} ${renderCommand(name)}`);
   }
 }
 
 // src/commands/log.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve5 } from "path";
-import { homedir as homedir4 } from "os";
-import { spawn as spawn3, execSync as execSync2 } from "child_process";
-import pc8 from "picocolors";
+import { existsSync as existsSync4, readFileSync as readFileSync3, unlinkSync } from "fs";
+import { resolve as resolve6 } from "path";
+import { homedir as homedir5 } from "os";
+import { spawn as spawn4, execSync as execSync2 } from "child_process";
+import pc10 from "picocolors";
 async function logCommand(args2) {
   const target = args2[0];
   if (!target) {
-    console.error(renderError("Missing process name/pid", "Usage: fennec log <name|pid> [--lines N] [-f]"));
+    console.error(renderError("Missing process name/pid", "Usage: fennec log <name|pid> [--lines N] [-f] [--clear] [--level error|warn|info|debug]"));
     process.exit(1);
   }
+  const clearFlag = args2.includes("--clear");
   const linesIndex = args2.indexOf("--lines");
   const lineCount = linesIndex !== -1 ? parseInt(args2[linesIndex + 1], 10) : 30;
   const followFlag = args2.includes("-f") || args2.includes("--follow");
+  const levelFilter = args2.includes("--level") ? args2[args2.indexOf("--level") + 1]?.toLowerCase() : void 0;
+  if (levelFilter && !["error", "warn", "info", "debug"].includes(levelFilter)) {
+    console.error(renderError("Invalid level", `"${levelFilter}" is not a valid level. Use: error, warn, info, debug`));
+    process.exit(1);
+  }
   let logFilePath = null;
   let displayName = target;
   const tracked = readTracked();
   const trackedMatch = tracked.find((t) => t.name === target || parseInt(target, 10) === t.pid && !isNaN(parseInt(target, 10)));
   if (trackedMatch) {
     displayName = trackedMatch.name;
-    logFilePath = resolve5(homedir4(), ".fennec", "logs", `${trackedMatch.name}.log`);
+    logFilePath = resolve6(homedir5(), ".fennec", "logs", `${trackedMatch.name}.log`);
   } else {
     const pid = parseInt(target, 10);
     if (!isNaN(pid) && String(pid) === target) {
@@ -3234,11 +3572,29 @@ async function logCommand(args2) {
       if (existsSync4(procPath)) logFilePath = procPath;
     }
   }
+  if (clearFlag) {
+    if (!logFilePath || !existsSync4(logFilePath)) {
+      console.error(`
+  ${pc10.yellow("\u26A0")} ${pc10.dim("No log file found for")} ${pc10.bold(displayName)}
+`);
+      process.exit(0);
+    }
+    try {
+      unlinkSync(logFilePath);
+      console.error(`
+  ${pc10.green("\u2713")} ${pc10.bold("Log cleared")} ${pc10.dim(`\u2014 ${logFilePath}`)}
+`);
+    } catch (err) {
+      console.error(renderError("Failed to clear log", String(err)));
+      process.exit(1);
+    }
+    return;
+  }
   const spinner = createSpinner(`Reading logs for ${displayName}...`);
   try {
     let logLines = [];
     if (logFilePath && existsSync4(logFilePath)) {
-      const content = readFileSync4(logFilePath, "utf-8");
+      const content = readFileSync3(logFilePath, "utf-8");
       logLines = content.split("\n").filter(Boolean);
     } else {
       const pid = trackedMatch?.pid ?? parseInt(target, 10);
@@ -3253,27 +3609,55 @@ async function logCommand(args2) {
         logLines = ["(no logs available)"];
       }
     }
+    if (levelFilter) {
+      const levelRegex = new RegExp(`\\b(${levelFilter.toUpperCase()})\\b`, "i");
+      logLines = logLines.filter((line) => levelRegex.test(line));
+    }
     spinner.stop();
     process.stdout.write("\r\x1B[K");
     console.error(`
-  ${symbols.fox} ${pc8.bold("Logs")} ${renderAppName(displayName)} ${pc8.dim(`(last ${logLines.length} lines)`)}
-`);
+  ${symbols.fox} ${pc10.bold("Logs")} ${renderAppName(displayName)} ${pc10.dim(`(last ${logLines.length} line${logLines.length !== 1 ? "s" : ""})`)}`);
     const sliced = logLines.slice(-lineCount);
     for (const line of sliced) {
       const display = line.length > 300 ? line.slice(0, 300) + "\u2026" : line;
-      if (line.toLowerCase().includes("error") || line.toLowerCase().includes("fail")) console.error(`  ${pc8.red(display)}`);
-      else if (line.toLowerCase().includes("warn")) console.error(`  ${pc8.yellow(display)}`);
-      else if (line.toLowerCase().includes("info") || line.includes("[")) console.error(`  ${pc8.cyan(display)}`);
-      else console.error(`  ${display}`);
+      const prefix = followFlag ? `${timestamp()} ` : "";
+      if (line.toLowerCase().includes("error") || line.toLowerCase().includes("fail") || line.toLowerCase().includes("fatal")) {
+        console.error(`  ${pc10.red(prefix + display)}`);
+      } else if (line.toLowerCase().includes("warn")) {
+        console.error(`  ${pc10.yellow(prefix + display)}`);
+      } else if (line.toLowerCase().includes("info") || line.includes("[")) {
+        console.error(`  ${pc10.cyan(prefix + display)}`);
+      } else {
+        console.error(`  ${prefix}${display}`);
+      }
     }
     if (followFlag && logFilePath) {
-      console.error(`
-  ${pc8.dim("Following... (Ctrl+C to stop)")}
+      const tailArgs = ["-n", "0", "-f"];
+      if (levelFilter) {
+        const tail = spawn4("tail", ["-n", "0", "-f", logFilePath], { stdio: ["ignore", "pipe", "pipe"] });
+        const grep = spawn4("grep", ["--line-buffered", "-i", levelFilter], { stdio: ["pipe", "inherit", "inherit"] });
+        if (tail.stdout) tail.stdout.pipe(grep.stdin);
+        await new Promise((resolve12) => {
+          tail.on("exit", () => resolve12());
+          process.once("SIGINT", () => {
+            tail.kill("SIGTERM");
+            grep.kill("SIGTERM");
+            resolve12();
+          });
+        });
+      } else {
+        console.error(`
+  ${pc10.dim("Following... (Ctrl+C to stop)")}
 `);
-      const tail = spawn3("tail", ["-n", "0", "-f", logFilePath], { stdio: "inherit" });
-      tail.on("exit", () => process.exit(0));
-      await new Promise(() => {
-      });
+        const tail = spawn4("tail", tailArgs.concat([logFilePath]), { stdio: "inherit" });
+        await new Promise((resolve12) => {
+          tail.on("exit", () => resolve12());
+          process.once("SIGINT", () => {
+            tail.kill("SIGTERM");
+            resolve12();
+          });
+        });
+      }
     }
     console.error();
   } catch (error) {
@@ -3283,7 +3667,8 @@ async function logCommand(args2) {
 }
 
 // src/commands/attach.ts
-import pc9 from "picocolors";
+import { PortDetector as PortDetector3 } from "@plumpslabs/fennec-core";
+import pc11 from "picocolors";
 async function attachCommand(args2) {
   const port = parseInt(args2[0], 10);
   if (isNaN(port)) {
@@ -3295,14 +3680,13 @@ async function attachCommand(args2) {
   const name = rawName ?? `port-${port}`;
   const spinner = createSpinner(`Attaching to :${port}...`);
   try {
-    const { PortDetector } = await import("@plumpslabs/fennec-core");
-    const detector = new PortDetector();
+    const detector = new PortDetector3();
     const info = detector.detectByPort(port);
     if (info) {
       spinner.succeed(`Attached to :${port}`);
       console.error(`  ${renderKV("Name", renderAppName(name))}`);
       console.error(`  ${renderKV("PID", String(info.pid))}`);
-      console.error(`  ${renderKV("Command", info.command || pc9.dim("unknown"))}`);
+      console.error(`  ${renderKV("Command", info.command || pc11.dim("unknown"))}`);
     } else {
       spinner.fail(`No process found on port ${port}`);
       process.exit(1);
@@ -3316,35 +3700,35 @@ async function attachCommand(args2) {
 
 // src/commands/sessions.ts
 import { SessionStore } from "@plumpslabs/fennec-core";
-import pc10 from "picocolors";
+import pc12 from "picocolors";
 async function sessionsCommand() {
   const store = new SessionStore("./.fennec/sessions");
   const sessions = store.list();
   if (sessions.length === 0) {
     console.error(`
-  ${pc10.dim("No saved sessions found.")}
+  ${pc12.dim("No saved sessions found.")}
 `);
     return;
   }
   const columns = [
-    { key: "name", label: "Name", format: (v) => pc10.bold(String(v)) },
+    { key: "name", label: "Name", format: (v) => pc12.bold(String(v)) },
     { key: "origin", label: "Origin" },
-    { key: "savedAt", label: "Saved", format: (v) => pc10.dim(String(v)) }
+    { key: "savedAt", label: "Saved", format: (v) => pc12.dim(String(v)) }
   ];
   const rows = sessions.map((s) => ({ name: s.name, origin: s.origin, savedAt: new Date(s.savedAt).toLocaleString() }));
   console.error(`
-  ${symbols.fox} ${pc10.bold("Saved Sessions")}
+  ${symbols.fox} ${pc12.bold("Saved Sessions")}
 `);
   console.error(renderTable(columns, rows));
-  console.error(`  ${pc10.dim(`${sessions.length} session(s)`)}
+  console.error(`  ${pc12.dim(`${sessions.length} session(s)`)}
 `);
 }
 
 // src/commands/setup.ts
-import pc11 from "picocolors";
+import pc13 from "picocolors";
 async function setupCommand() {
   console.error(`
-  ${symbols.fox} ${pc11.bold("Fennec Setup")}
+  ${symbols.fox} ${pc13.bold("Fennec Setup")}
 `);
   const mcpClient = await selectPrompt("Which MCP client are you using?", [
     { value: "claude", label: "Claude Desktop", description: "Anthropic's AI desktop app" },
@@ -3353,12 +3737,12 @@ async function setupCommand() {
     { value: "other", label: "Other MCP client", description: "Any MCP-compatible client" }
   ]);
   if (!mcpClient) {
-    console.error(`  ${pc11.dim("Setup cancelled.")}
+    console.error(`  ${pc13.dim("Setup cancelled.")}
 `);
     return;
   }
   console.error(`
-  ${pc11.green("\u2713")} Selected: ${pc11.bold(mcpClient)}
+  ${pc13.green("\u2713")} Selected: ${pc13.bold(mcpClient)}
 `);
   const configSnippet = `{
   "mcpServers": {
@@ -3368,24 +3752,24 @@ async function setupCommand() {
     }
   }
 }`;
-  console.error(`  ${pc11.bold("Add this to your MCP client config:")}
+  console.error(`  ${pc13.bold("Add this to your MCP client config:")}
 `);
-  console.error(`  ${pc11.dim("```")}`);
+  console.error(`  ${pc13.dim("```")}`);
   console.error(configSnippet.split("\n").map((l) => `  ${l}`).join("\n"));
-  console.error(`  ${pc11.dim("```")}
+  console.error(`  ${pc13.dim("```")}
 `);
-  console.error(`  ${renderSuccess("Setup complete!")} ${pc11.dim("Run")} ${renderCommand("fennec start")} ${pc11.dim("to begin.")}
+  console.error(`  ${renderSuccess("Setup complete!")} ${pc13.dim("Run")} ${renderCommand("fennec start")} ${pc13.dim("to begin.")}
 `);
 }
 
 // src/commands/management.ts
 import { existsSync as existsSync5, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import { execSync as execSync3 } from "child_process";
-import pc12 from "picocolors";
+import pc14 from "picocolors";
 async function installBrowsersCommand() {
   console.error(`
-  ${pc12.bold("Installing Browser Engines")}
+  ${pc14.bold("Installing Browser Engines")}
 `);
   const spinner = createSpinner("Installing Chromium...");
   try {
@@ -3393,21 +3777,21 @@ async function installBrowsersCommand() {
     spinner.succeed("Chromium installed successfully");
   } catch {
     spinner.fail("Failed to install Chromium");
-    console.error(`  ${pc12.yellow("\u2192")} Try running: ${renderCommand("npx playwright install chromium")}`);
+    console.error(`  ${pc14.yellow("\u2192")} Try running: ${renderCommand("npx playwright install chromium")}`);
   }
   console.error(`
-  ${pc12.green("\u2713")} Browser installation complete.
+  ${pc14.green("\u2713")} Browser installation complete.
 `);
 }
 async function initCommand() {
   console.error(`
-  ${pc12.bold("Initialize Fennec Configuration")}
+  ${pc14.bold("Initialize Fennec Configuration")}
 `);
-  const configFile = resolve6("./fennec.config.yaml");
+  const configFile = resolve7("./fennec.config.yaml");
   if (existsSync5(configFile)) {
-    const overwrite = await confirmPrompt(`${pc12.yellow("fennec.config.yaml")} already exists. Overwrite?`, false);
+    const overwrite = await confirmPrompt(`${pc14.yellow("fennec.config.yaml")} already exists. Overwrite?`, false);
     if (!overwrite) {
-      console.error(`  ${pc12.dim("Cancelled.")}
+      console.error(`  ${pc14.dim("Cancelled.")}
 `);
       return;
     }
@@ -3487,21 +3871,21 @@ logging:
   file: null
 `;
   writeFileSync2(configFile, config, "utf-8");
-  spinner.succeed(`Configuration written to ${pc12.bold(configFile)}`);
+  spinner.succeed(`Configuration written to ${pc14.bold(configFile)}`);
   console.error(`
-  ${pc12.dim("Edit the file to customize Fennec behavior.")}
+  ${pc14.dim("Edit the file to customize Fennec behavior.")}
 `);
 }
 
 // src/commands/health.ts
 import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { execSync as execSync4 } from "child_process";
-import { resolve as resolve7 } from "path";
-import { homedir as homedir5 } from "os";
-import pc13 from "picocolors";
+import { resolve as resolve8 } from "path";
+import { homedir as homedir6 } from "os";
+import pc15 from "picocolors";
 async function healthCommand() {
   printBanner();
-  console.error(`  ${pc13.bold("Fennec Health Check")}
+  console.error(`  ${pc15.bold("Fennec Health Check")}
 `);
   let adbStatus = "unknown";
   try {
@@ -3511,20 +3895,20 @@ async function healthCommand() {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const version = result.split("\n")[0]?.trim() ?? "installed";
-    adbStatus = pc13.green(version);
+    adbStatus = pc15.green(version);
   } catch {
-    adbStatus = pc13.dim("not found") + " (optional)";
+    adbStatus = pc15.dim("not found") + " (optional)";
   }
   const tracked = readTracked();
   const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
-  const logDir = resolve7(homedir5(), ".fennec", "logs");
+  const logDir = resolve8(homedir6(), ".fennec", "logs");
   let logSize = "0 B";
   try {
     if (existsSync6(logDir)) {
       const files = readdirSync2(logDir);
       let totalBytes = 0;
       for (const f of files) {
-        const fStat = statSync2(resolve7(logDir, f));
+        const fStat = statSync2(resolve8(logDir, f));
         totalBytes += fStat.size;
       }
       logSize = totalBytes > 1024 * 1024 ? `${(totalBytes / (1024 * 1024)).toFixed(1)} MB` : `${(totalBytes / 1024).toFixed(1)} KB`;
@@ -3537,7 +3921,7 @@ async function healthCommand() {
     memoryInfo = `${(mem.rss / (1024 * 1024)).toFixed(0)} MB RSS / ${(mem.heapUsed / (1024 * 1024)).toFixed(0)} MB heap`;
   } catch {
   }
-  console.error(`  ${symbols.fox} ${pc13.bold("System")}
+  console.error(`  ${symbols.fox} ${pc15.bold("System")}
 `);
   console.error(`  ${renderKV("Node.js", process.version)}`);
   console.error(`  ${renderKV("Platform", `${process.platform} ${process.arch}`)}`);
@@ -3545,7 +3929,7 @@ async function healthCommand() {
   console.error(`  ${renderKV("ADB", adbStatus)}`);
   console.error(`  ${renderKV("PID", String(process.pid))}`);
   console.error();
-  console.error(`  ${symbols.fox} ${pc13.bold("Processes")}
+  console.error(`  ${symbols.fox} ${pc15.bold("Processes")}
 `);
   console.error(`  ${renderKV("Tracked", String(tracked.length))}`);
   console.error(`  ${renderKV("Running", String(runningCount))}`);
@@ -3553,15 +3937,238 @@ async function healthCommand() {
   console.error();
   const allHealthy = runningCount === tracked.length || tracked.length === 0;
   if (allHealthy) {
-    console.error(`  ${pc13.green("\u2713")} ${pc13.bold("All systems healthy")}
+    console.error(`  ${pc15.green("\u2713")} ${pc15.bold("All systems healthy")}
 `);
   } else {
     const stopped = tracked.length - runningCount;
-    console.error(`  ${pc13.yellow("\u26A0")} ${pc13.bold(`${stopped} process(es) stopped`)}  ${pc13.dim("fennec ps")}
+    console.error(`  ${pc15.yellow("\u26A0")} ${pc15.bold(`${stopped} process(es) stopped`)}  ${pc15.dim("fennec ps")}
 `);
   }
 }
 
+// src/commands/cleanup.ts
+import pc16 from "picocolors";
+async function cleanupCommand() {
+  const tracked = readTracked();
+  if (tracked.length === 0) {
+    console.error(`
+  ${pc16.dim("No tracked processes to clean up.")}
+`);
+    return;
+  }
+  const toRemove = tracked.filter((t) => !isProcessRunning(t.pid) && !t.command);
+  if (toRemove.length === 0) {
+    console.error(`
+  ${pc16.green("\u2713")} ${pc16.bold("All clean")} ${pc16.dim("\u2014 no dead entries without saved commands.")}
+`);
+    return;
+  }
+  console.error(`
+  ${pc16.yellow("\u26A0")} ${pc16.bold(`Found ${toRemove.length} dead entr${toRemove.length > 1 ? "ies" : "y"} without saved commands`)}
+`);
+  for (const entry of toRemove) {
+    console.error(`  ${pc16.dim("\xB7")} ${pc16.bold(entry.name)} ${pc16.dim(`(PID ${entry.pid})`)}`);
+  }
+  console.error();
+  const confirmed = await confirmPrompt(`Remove ${toRemove.length} entr${toRemove.length > 1 ? "ies" : "y"}?`, false);
+  if (!confirmed) {
+    console.error(`  ${pc16.dim("Cancelled")}
+`);
+    return;
+  }
+  const remaining = tracked.filter((t) => !toRemove.includes(t));
+  saveTracked(remaining);
+  console.error(`
+  ${pc16.green("\u2713")} ${pc16.bold(`Removed ${toRemove.length} entr${toRemove.length > 1 ? "ies" : "y"}`)} ${pc16.dim(`(${remaining.length} remaining)`)}
+`);
+}
+
+// src/commands/info.ts
+import pc17 from "picocolors";
+import { resolve as resolve9 } from "path";
+import { homedir as homedir7 } from "os";
+async function infoCommand(args2) {
+  const name = args2[0];
+  if (!name) {
+    console.error(renderError("Missing name", "Usage: fennec info <name>"));
+    process.exit(1);
+  }
+  const tracked = readTracked();
+  const match = tracked.find((t) => t.name === name);
+  if (!match) {
+    console.error(renderError("Not found", `No tracked process named "${name}".`));
+    process.exit(1);
+  }
+  const running = isProcessRunning(match.pid);
+  const statusIcon = running ? pc17.green("\u25CF") : pc17.red("\u25CB");
+  const statusText = running ? pc17.green("running") : pc17.red("stopped");
+  const uptime = running ? formatUptime(Math.floor((Date.now() - new Date(match.startedAt).getTime()) / 1e3)) : "-";
+  const logPath = resolve9(homedir7(), ".fennec", "logs", `${match.name}.log`);
+  console.error(`
+  ${symbols.fox} ${pc17.bold(match.name)} ${pc17.dim("\u2014 Process Info")}
+`);
+  console.error(`  ${renderKVColor("Name", match.name, pc17.bold)}`);
+  console.error(`  ${renderKVColor("Status", `${statusIcon} ${statusText}`)}`);
+  console.error(`  ${renderKVColor("PID", String(match.pid))}`);
+  console.error(`  ${renderKVColor("Port", match.port ? String(match.port) : "-")}`);
+  console.error(`  ${renderKVColor("Command", match.command || pc17.dim("(none)"))}`);
+  if (match.cwd) console.error(`  ${renderKVColor("CWD", match.cwd)}`);
+  console.error(`  ${renderKVColor("Started", new Date(match.startedAt).toLocaleString())}`);
+  console.error(`  ${renderKVColor("Uptime", uptime)}`);
+  console.error(`  ${renderKVColor("Log Path", logPath)}`);
+  if (!running && match.command) {
+    console.error(`
+  ${pc17.dim("Re-spawn with:")} ${pc17.cyan(`fennec spawn ${match.name}`)}`);
+  }
+  console.error();
+}
+
+// src/commands/rename.ts
+import pc18 from "picocolors";
+import { existsSync as existsSync7, renameSync as renameSync2 } from "fs";
+import { resolve as resolve10 } from "path";
+import { homedir as homedir8 } from "os";
+async function renameCommand(args2) {
+  const [oldName, newName] = args2;
+  if (!oldName || !newName) {
+    console.error(renderError("Missing arguments", "Usage: fennec rename <old-name> <new-name>"));
+    process.exit(1);
+  }
+  if (oldName === newName) {
+    console.error(`
+  ${pc18.yellow("\u26A0")} ${pc18.dim("Old and new names are the same.")}
+`);
+    process.exit(0);
+  }
+  const tracked = readTracked();
+  const match = tracked.find((t) => t.name === oldName);
+  if (!match) {
+    console.error(renderError("Not found", `No tracked process named "${oldName}".`));
+    process.exit(1);
+  }
+  if (tracked.some((t) => t.name === newName)) {
+    console.error(renderError("Name taken", `A process named "${newName}" already exists.`));
+    process.exit(1);
+  }
+  console.error(`
+  ${symbols.fox} ${pc18.bold("Rename Process")}
+`);
+  console.error(`  ${renderKVColor("From", oldName)}`);
+  console.error(`  ${renderKVColor("To", newName)}`);
+  if (isProcessRunning(match.pid)) {
+    console.error(`  ${pc18.yellow("\u26A0")} ${pc18.dim("Process is still running \u2014 log entries will go to the old file until stopped.")}`);
+  }
+  console.error();
+  const confirmed = await confirmPrompt(`Rename ${pc18.bold(oldName)} ${pc18.dim("\u2192")} ${pc18.bold(newName)}?`, true);
+  if (!confirmed) {
+    console.error(`  ${pc18.dim("Cancelled")}
+`);
+    return;
+  }
+  const spinner = createSpinner(`Renaming ${oldName} \u2192 ${newName}...`);
+  const logDir = resolve10(homedir8(), ".fennec", "logs");
+  const oldLog = resolve10(logDir, `${oldName}.log`);
+  const newLog = resolve10(logDir, `${newName}.log`);
+  if (existsSync7(oldLog) && !existsSync7(newLog)) {
+    try {
+      renameSync2(oldLog, newLog);
+    } catch {
+    }
+  }
+  match.name = newName;
+  saveTracked(tracked);
+  spinner.succeed(`${pc18.bold(oldName)} ${pc18.dim("\u2192")} ${pc18.bold(newName)}`);
+  console.error();
+}
+
+// src/commands/export-import.ts
+import pc19 from "picocolors";
+import { existsSync as existsSync8, writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve11 } from "path";
+async function exportCommand(args2) {
+  const tracked = readTracked();
+  const fileIndex = args2.indexOf("--file");
+  const filePath = fileIndex !== -1 ? args2[fileIndex + 1] : void 0;
+  if (fileIndex !== -1 && !filePath) {
+    console.error(renderError("Missing file path", "Usage: fennec export --file <path>"));
+    process.exit(1);
+  }
+  if (tracked.length === 0) {
+    console.error(`
+  ${pc19.dim("No tracked processes to export.")}
+`);
+    return;
+  }
+  const json = JSON.stringify(tracked, null, 2);
+  if (filePath) {
+    try {
+      writeFileSync3(resolve11(filePath), json, "utf-8");
+      console.error(`
+  ${pc19.green("\u2713")} ${pc19.bold(`Exported ${tracked.length} process(es)`)} ${pc19.dim(`\u2192 ${filePath}`)}
+`);
+    } catch (err) {
+      console.error(renderError("Export failed", String(err)));
+      process.exit(1);
+    }
+  } else {
+    console.log(json);
+  }
+}
+async function importCommand(args2) {
+  const filePath = args2[0];
+  if (!filePath) {
+    console.error(renderError("Missing file", "Usage: fennec import <file>"));
+    process.exit(1);
+  }
+  const resolvedPath = resolve11(filePath);
+  if (!existsSync8(resolvedPath)) {
+    console.error(renderError("File not found", `"${filePath}" does not exist.`));
+    process.exit(1);
+  }
+  let imported;
+  try {
+    imported = JSON.parse(readFileSync4(resolvedPath, "utf-8"));
+    if (!Array.isArray(imported) || imported.length === 0) {
+      console.error(renderError("Invalid file", "File must contain a non-empty JSON array of process objects."));
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(renderError("Invalid JSON", String(err)));
+    process.exit(1);
+  }
+  const existing = readTracked();
+  console.error(`
+  ${symbols.fox} ${pc19.bold("Import Processes")}
+`);
+  console.error(`  ${renderKVColor("File", resolvedPath)}`);
+  console.error(`  ${renderKVColor("Importing", `${imported.length} process(es)`)}`);
+  console.error(`  ${renderKVColor("Existing", `${existing.length} process(es)`)}`);
+  console.error(`
+  ${pc19.bold("Processes to import:")}`);
+  for (const p of imported) {
+    console.error(`  ${pc19.green("+")} ${pc19.bold(p.name)} ${pc19.dim(`(${p.command})`)}`);
+  }
+  console.error();
+  const confirmed = await confirmPrompt("Merge into tracked.json? Existing processes with the same name will be overwritten.", true);
+  if (!confirmed) {
+    console.error(`  ${pc19.dim("Cancelled")}
+`);
+    return;
+  }
+  const merged = [...existing];
+  for (const proc of imported) {
+    const idx = merged.findIndex((t) => t.name === proc.name);
+    if (idx !== -1) {
+      merged[idx] = { ...merged[idx], ...proc };
+    } else {
+      merged.push(proc);
+    }
+  }
+  saveTracked(merged);
+  console.error(`  ${pc19.green("\u2713")} ${pc19.bold(`Imported ${imported.length} process(es)`)} ${pc19.dim(`(${merged.length} total)`)}
+`);
+}
+
 // src/index.ts
 var [, , command, ...args] = process.argv;
 async function main() {
@@ -3581,10 +4188,26 @@ async function main() {
     await statusCommand(args);
   } else if (command === "log") {
     await logCommand(args);
+  } else if (command === "spawn") {
+    await spawnCommand(args);
+  } else if (command === "stop") {
+    await stopCommand(args);
   } else if (command === "kill") {
     await killCommand(args);
   } else if (command === "restart") {
     await restartCommand(args);
+  } else if (command === "info") {
+    printBanner();
+    await infoCommand(args);
+  } else if (command === "cleanup") {
+    printBanner();
+    await cleanupCommand();
+  } else if (command === "rename") {
+    await renameCommand(args);
+  } else if (command === "export") {
+    await exportCommand(args);
+  } else if (command === "import") {
+    await importCommand(args);
   } else if (command === "attach") {
     await attachCommand(args);
   } else if (command === "pipe") {