@plumpslabs/fennec-cli 1.13.3 → 1.13.5

package/dist/index.js

@@ -129,14 +129,14 @@ var require_emoji_regex = __commonJS({
 var require_string_width = __commonJS({
   "../../node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js"(exports, module) {
     "use strict";
-    var stripAnsi = require_strip_ansi();
+    var stripAnsi2 = require_strip_ansi();
     var isFullwidthCodePoint = require_is_fullwidth_code_point();
     var emojiRegex = require_emoji_regex();
     var stringWidth = (string) => {
       if (typeof string !== "string" || string.length === 0) {
         return 0;
       }
-      string = stripAnsi(string);
+      string = stripAnsi2(string);
       if (string.length === 0) {
         return 0;
       }
@@ -181,23 +181,23 @@ var require_utils = __commonJS({
     function repeat(str, times) {
       return Array(times + 1).join(str);
     }
-    function pad(str, len, pad2, dir) {
+    function pad2(str, len, pad3, dir) {
       let length = strlen(str);
       if (len + 1 >= length) {
         let padlen = len - length;
         switch (dir) {
           case "right": {
-            str = repeat(pad2, padlen) + str;
+            str = repeat(pad3, padlen) + str;
             break;
           }
           case "center": {
             let right = Math.ceil(padlen / 2);
             let left = padlen - right;
-            str = repeat(pad2, left) + str + repeat(pad2, right);
+            str = repeat(pad3, left) + str + repeat(pad3, right);
             break;
           }
           default: {
-            str = str + repeat(pad2, padlen);
+            str = str + repeat(pad3, padlen);
             break;
           }
         }
@@ -455,7 +455,7 @@ var require_utils = __commonJS({
     module.exports = {
       strlen,
       repeat,
-      pad,
+      pad: pad2,
       truncate,
       mergeOptions,
       wordWrap: multiLineWordWrap,
@@ -1902,7 +1902,7 @@ var symbols = {
   ears: "\u23DC"
 };
 function renderTable(columns, rows, options) {
-  const pad = options?.padding ?? 1;
+  const pad2 = options?.padding ?? 1;
   if (rows.length === 0) {
     return pc.dim("  (no data)");
   }
@@ -1910,8 +1910,8 @@ function renderTable(columns, rows, options) {
     head: columns.map((c) => pc.bold(c.label)),
     colAligns: columns.map((c) => c.align ?? "left"),
     style: {
-      "padding-left": pad,
-      "padding-right": pad,
+      "padding-left": pad2,
+      "padding-right": pad2,
       head: [],
       // reset default styles; our pc.bold is already applied
       border: [],
@@ -1955,8 +1955,8 @@ function renderTable(columns, rows, options) {
 function renderKV(key, value, options) {
   const indent = options?.indent ?? 2;
   const sep = options?.separator ?? ":";
-  const pad = " ".repeat(indent);
-  return `${pad}${pc.dim(key + sep)} ${value}`;
+  const pad2 = " ".repeat(indent);
+  return `${pad2}${pc.dim(key + sep)} ${value}`;
 }
 function renderKVColor(key, value, color = pc.bold) {
   return `  ${pc.dim(key + ":")} ${color(value)}`;
@@ -2013,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((resolve12) => {
+  const answer = await new Promise((resolve13) => {
     rl.question(`  ${pc.bold("Enter number")} ${pc.dim("(0-" + options.length + ")")}: `, (ans) => {
       rl.close();
-      resolve12(ans.trim());
+      resolve13(ans.trim());
     });
   });
   const num = parseInt(answer, 10);
@@ -2031,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((resolve12) => {
+  const answer = await new Promise((resolve13) => {
     rl.question(`
   ${message} ${pc.dim("(" + hint + ")")}: `, (ans) => {
       rl.close();
-      resolve12(ans.trim().toLowerCase());
+      resolve13(ans.trim().toLowerCase());
     });
   });
   if (!answer) return defaultValue;
@@ -2091,7 +2091,7 @@ function hexColor(color) {
 }
 var fennecOrange2 = hexColor("#FF6432");
 var fennecGold = hexColor("#FFB347");
-var VERSION = "1.13.3";
+var VERSION = "1.13.5";
 var cachedBanner = null;
 var cachedCompact = null;
 function generateBanner() {
@@ -2135,91 +2135,373 @@ var FOX_COMPACT = generateCompactBanner();
 // src/utils/help.ts
 import pc3 from "picocolors";
 var fennecOrange3 = hexColor("#FF6432");
+var COMMANDS = {
+  "start-server": {
+    name: "start",
+    usage: "start [options]",
+    summary: "Start the Fennec MCP server (default when no app command is given)",
+    description: "Boots the Fennec MCP server so AI agents can connect. Also auto-resurrects tracked apps that died since the last session.",
+    options: [
+      ["--config <path>", "Path to a fennec.config.yaml file"],
+      ["--sse", "Use SSE (HTTP) transport instead of stdio"]
+    ],
+    examples: ["start", "start --sse", "start --config ./fennec.config.yaml"]
+  },
+  start: {
+    name: "start",
+    usage: "start <command> --name <name> [options]",
+    short: "start <command>",
+    summary: "Start an app as a background daemon (like)",
+    description: "Launches <command> as a detached daemon. Its output is written directly to ~/.fennec/logs/<name>.log, so Fennec confirms the app is really running and then exits \u2014 no Ctrl+C needed.",
+    aliases: ["run"],
+    options: [
+      ["--name <name>", "App name used for tracking (recommended)"],
+      ["--port <port>", "Port the app listens on \u2014 Fennec waits until it accepts connections"],
+      ["--cwd <dir>", "Working directory to run the command in"],
+      ["--restart", "Auto-restart if it crashes or its port stops listening (detached supervisor, survives terminal close)"]
+    ],
+    examples: [
+      'start "npm run dev" --name web --port 3000',
+      "start node server.js --name api --cwd ./backend --restart"
+    ]
+  },
+  run: {
+    name: "run",
+    usage: "run <command> --name <name> [options]",
+    short: "run <command>",
+    summary: "Alias of `start <command>` \u2014 run an app under Fennec",
+    aliases: ["start"],
+    options: [
+      ["--name <name>", "App name used for tracking (recommended)"],
+      ["--port <port>", "Port the app listens on"],
+      ["--cwd <dir>", "Working directory"],
+      ["--restart", "Auto-restart if it crashes or its port stops listening"]
+    ],
+    examples: ["run npm start --name web --port 8080"]
+  },
+  ps: {
+    name: "ps",
+    usage: "ps [options]",
+    summary: "List Fennec-tracked apps with live status",
+    description: "Shows tracked apps and whether they are genuinely running (PID + command identity are verified to avoid false positives from PID reuse).",
+    options: [
+      ["--system, -a, --all", "Show all system processes instead of tracked apps"],
+      ["--name <name>", "Filter system processes by name"],
+      ["--sort <field>", "Sort by cpu | mem | pid | name (default: name)"],
+      ["--json", "Output tracked apps as JSON"],
+      ["-w, --watch", "Watch mode \u2014 refresh every 3s (with --system)"]
+    ],
+    examples: ["ps", "ps --json", "ps --system --sort cpu -w"]
+  },
+  status: {
+    name: "status",
+    usage: "status [name] [options]",
+    summary: "Show system overview & top processes",
+    options: [["-w, --watch", "Watch mode \u2014 refresh every 3s"]],
+    examples: ["status", "status -w"]
+  },
+  log: {
+    name: "log",
+    usage: "log <name|pid> [options]",
+    summary: "Show (and follow) logs for a tracked app",
+    description: "Prints the app's status (running/stopped) then its recent logs. Run without an app name to list all tracked apps to choose from. Secrets (API keys, tokens, connection strings, private keys) are redacted by default \u2014 safe to pipe to an AI assistant. Use --json for a bounded, machine-readable view (AI mode).",
+    aliases: ["logs"],
+    options: [
+      ["--lines <n>", "Number of lines to show (default: 30, capped at 500)"],
+      ["-f, --follow", "Follow mode \u2014 stream new log lines live (Ctrl+C to stop)"],
+      ["--level <level>", "Filter by level: error | warn | info | debug"],
+      ["--since <dur>", "Only show lines from the last duration (e.g. 10m, 1h, 30s)"],
+      ["--json", "Machine-readable JSON (AI mode) \u2014 bounded, redacted, no ANSI"],
+      ["--no-redact", "Disable secret redaction (use with care)"],
+      ["--clear", "Delete the log file for this app"]
+    ],
+    examples: ["logs", "log web", "log web -f", "log api --level error --lines 100"]
+  },
+  spawn: {
+    name: "spawn",
+    usage: "spawn [name] [--all]",
+    summary: "Re-spawn a stopped tracked app from its saved config",
+    description: "Revives a previously stopped app using its saved command/args/cwd. With no name, shows an interactive list of stopped apps.",
+    options: [["--all, -a", "Re-spawn all stopped apps that have a saved command"]],
+    examples: ["spawn", "spawn web", "spawn --all"]
+  },
+  stop: {
+    name: "stop",
+    usage: "stop <name|--all>",
+    summary: "Stop (pause) a tracked app but keep it in the registry",
+    description: "Sends SIGTERM but keeps the entry in tracked.json so it can be revived later with `fennec spawn`.",
+    options: [["--all, -a", "Stop all running tracked apps"]],
+    examples: ["stop web", "stop --all"]
+  },
+  restart: {
+    name: "restart",
+    usage: "restart <name|pid>",
+    summary: "Stop and re-spawn a tracked app from its saved config",
+    examples: ["restart web"]
+  },
+  kill: {
+    name: "kill",
+    usage: "kill <pid|name|all>",
+    summary: "Kill a process by PID, name, or kill all user processes",
+    description: "Permanently removes a tracked app (unlike `stop`, which keeps it). Prompts before killing.",
+    options: [
+      ["--signal <sig>", "Signal to send (default: SIGTERM). e.g. SIGKILL, SIGINT"],
+      ["--all, -a", "Kill all user processes (asks for confirmation)"]
+    ],
+    examples: ["kill web", "kill 12345 --signal SIGKILL", "kill all"]
+  },
+  supervisor: {
+    name: "supervisor",
+    usage: "supervisor <start|stop|status|restart>",
+    short: "supervisor <action>",
+    summary: "Manage the background daemon that keeps --restart apps alive",
+    description: "The supervisor is a detached daemon that auto-restarts apps started with --restart, even after you close the terminal. It polls every few seconds, health-checks each app's port (restarting ones that are alive but not listening) and has crash-loop backoff. `fennec start --restart` starts it automatically.",
+    options: [
+      ["start", "Start the supervisor daemon"],
+      ["stop", "Stop the supervisor daemon"],
+      ["status", "Show supervisor status and managed apps"],
+      ["restart", "Restart the supervisor daemon"]
+    ],
+    examples: ["supervisor status", "supervisor start", "supervisor stop"]
+  },
+  persist: {
+    name: "persist",
+    usage: "persist <enable|disable|status>",
+    short: "persist <action>",
+    summary: "Make fennec survive reboots (auto-start apps after login)",
+    description: "Installs a boot unit (systemd user service on Linux, launchd agent on macOS, a startup script on Windows) that starts the supervisor at login. The supervisor then resurrects every app started with --restart, so your whole fleet comes back after a reboot \u2014 like `startup` + `save`. `fennec start --restart` enables this automatically.",
+    options: [
+      ["enable", "Install the boot unit for the current user"],
+      ["disable", "Remove the boot unit"],
+      ["status", "Show whether boot persistence is active"]
+    ],
+    examples: ["persist enable", "persist status", "persist disable"]
+  },
+  inspect: {
+    name: "inspect",
+    usage: "inspect <name|pid> [--plain] [--tail N] [--since 10m]",
+    short: "inspect <name|pid>",
+    summary: "Compact, AI-safe snapshot of an app (status + logs + errors)",
+    description: "Returns a single bounded, machine-readable (JSON) view of one app: liveness, port health, uptime, memory, recent log lines and an error scan. Output is capped (token budget), secrets are redacted by default, and the shape is stable \u2014 so an AI assistant can observe a real running app (BE, FE, worker, console, ...) cheaply and predictably. Add --plain for a short human summary.",
+    options: [
+      ["--plain", "Short human-readable summary instead of JSON"],
+      ["--tail N", "Max recent log lines (default 40, cap 200)"],
+      ["--since 10m|1h", "Only consider log lines from the last duration"]
+    ],
+    examples: ["inspect web --plain", "inspect web --since 10m", "inspect api --tail 20"]
+  },
+  dev: {
+    name: "dev",
+    usage: "dev <up|down|status> [--config fennec.config.yaml]",
+    short: "dev <action>",
+    summary: "Orchestrate a whole dev stack from fennec.config.yaml",
+    description: "Declarative dev-environment orchestration. `fennec dev up` reads fennec.config.yaml, starts every app (BE/FE/DB/worker) like `fennec start --restart`, respects dependencies (waits for a dependent's port), and brings the whole stack up as one unit. Apps are supervised (auto-restart + port health-check) and boot-persistent. `fennec dev down` stops them (disabling auto-restart). `fennec dev status` shows the stack. This is the AI-friendly way to boot an entire project and then observe it with `fennec observe` / `inspect`.",
+    options: [
+      ["up", "Start the whole stack from fennec.config.yaml"],
+      ["down", "Stop the whole stack (auto-restart disabled)"],
+      ["status", "Show stack status (running/stopped, last restart cause)"],
+      ["--config <path>", "Path to the config file (default: ./fennec.config.yaml)"]
+    ],
+    examples: ["dev up", "dev up --config ./stack.yaml", "dev down", "dev status"]
+  },
+  info: {
+    name: "info",
+    usage: "info <name>",
+    summary: "Show detailed info for a tracked app",
+    examples: ["info web"]
+  },
+  rename: {
+    name: "rename",
+    usage: "rename <old-name> <new-name>",
+    summary: "Rename a tracked app",
+    examples: ["rename web frontend"]
+  },
+  attach: {
+    name: "attach",
+    usage: "attach <port> --name <name>",
+    short: "attach <port>",
+    summary: "Observe a running process by the port it listens on",
+    options: [["--name <name>", "Name to track the observed process under"]],
+    examples: ["attach 3000 --name web"]
+  },
+  "attach-pid": {
+    name: "attach-pid",
+    usage: "attach-pid <pid>",
+    summary: "Attach to and observe a process by its PID",
+    examples: ["attach-pid 12345"]
+  },
+  "attach-port": {
+    name: "attach-port",
+    usage: "attach-port <port>",
+    summary: "Attach to and observe a process by its port",
+    examples: ["attach-port 8080"]
+  },
+  pipe: {
+    name: "pipe",
+    usage: "pipe --name <name>",
+    summary: "Pipe stdin into a Fennec log watcher",
+    options: [["--name <name>", "Watcher name (required)"]],
+    examples: ["npm run dev | fennec pipe --name web"]
+  },
+  watch: {
+    name: "watch",
+    usage: "watch --file <path> [--name <name>]",
+    short: "watch --file <path>",
+    summary: "Watch an existing log file",
+    options: [
+      ["--file <path>", "Path to the log file (required)"],
+      ["--name <name>", "Watcher name"]
+    ],
+    examples: ["watch --file ./app.log --name web"]
+  },
+  export: {
+    name: "export",
+    usage: "export --file <path>",
+    summary: "Export tracked apps to a file",
+    options: [["--file <path>", "Destination file path (required)"]],
+    examples: ["export --file ./fennec-apps.json"]
+  },
+  import: {
+    name: "import",
+    usage: "import <file>",
+    summary: "Import tracked apps from a file",
+    examples: ["import ./fennec-apps.json"]
+  },
+  cleanup: {
+    name: "cleanup",
+    usage: "cleanup",
+    summary: "Remove dead/stale entries from the tracked registry",
+    examples: ["cleanup"]
+  },
+  init: {
+    name: "init",
+    usage: "init",
+    summary: "Generate a fennec.config.yaml in the current directory",
+    examples: ["init"]
+  },
+  setup: {
+    name: "setup",
+    usage: "setup",
+    summary: "Interactively configure your MCP client for Fennec",
+    examples: ["setup"]
+  },
+  "install-browsers": {
+    name: "install-browsers",
+    usage: "install-browsers",
+    summary: "Install Playwright browser engines",
+    examples: ["install-browsers"]
+  },
+  sessions: {
+    name: "sessions",
+    usage: "sessions",
+    summary: "List saved browser auth sessions",
+    examples: ["sessions"]
+  },
+  health: {
+    name: "health",
+    usage: "health",
+    summary: "Run a health check of the Fennec environment",
+    examples: ["health"]
+  },
+  help: {
+    name: "help",
+    usage: "help [command]",
+    summary: "Show this help, or detailed help for a command",
+    examples: ["help", "help start", "start --help"]
+  },
+  version: {
+    name: "version",
+    usage: "version",
+    summary: "Show the installed Fennec version",
+    examples: ["version"]
+  }
+};
+var LOOKUP = {
+  logs: "log",
+  "-v": "version",
+  "--version": "version",
+  "-h": "help",
+  "--help": "help"
+};
+function findCommandDoc(cmd) {
+  if (COMMANDS[cmd]) return COMMANDS[cmd];
+  const alias = LOOKUP[cmd];
+  return alias ? COMMANDS[alias] : void 0;
+}
+var GROUPS = [
+  { title: "Server", keys: ["start-server"] },
+  { title: "Apps & Processes", keys: ["start", "run", "ps", "status", "log", "spawn", "stop", "restart", "kill", "supervisor", "persist", "dev", "inspect", "info", "rename"] },
+  { title: "Observation", keys: ["attach", "attach-pid", "attach-port", "pipe", "watch"] },
+  { title: "Data", keys: ["export", "import", "cleanup"] },
+  { title: "Configuration", keys: ["init", "setup", "install-browsers", "sessions"] },
+  { title: "Other", keys: ["health", "help", "version"] }
+];
+function pad(s, width) {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
 function showHelp() {
-  const sep = fennecOrange3("\u2500".repeat(50));
-  console.error(`
-
-  ${pc3.bold("Usage:")} fennec ${pc3.dim("<command>")} ${pc3.dim("[options]")}
-
-  ${sep}
-  ${pc3.bold("Server")}
-  ${sep}
-
-    ${pc3.cyan("start")}            ${pc3.dim("Start Fennec MCP server (default)")}
-                     ${pc3.dim("--config")}    Path to config file
-                     ${pc3.dim("--transport")} Transport type ${pc3.dim("(stdio | sse) [default: stdio]")}
-                     ${pc3.dim("--api-port")}  Management API port ${pc3.dim("[default: 3456]")}
-
-    ${pc3.cyan("start")} ${pc3.dim("<command>")}         ${pc3.dim("Start an app under Fennec observation (new!)")}
-                     ${pc3.dim("--name")}    App name ${pc3.dim("(required for tracking)")}
-                     ${pc3.dim("--port")}    Port the app listens on ${pc3.dim("(optional)")}
-                     ${pc3.dim("--cwd")}     Working directory
-                     ${pc3.dim("--restart")}  Auto-restart on crash
-
-  ${sep}
-  ${pc3.bold("Process Management")}
-  ${sep}
-
-    ${pc3.cyan("ps")} ${pc3.dim("[options]")}          ${pc3.dim("List Fennec-tracked apps (like PM2)")}
-                     ${pc3.dim("--system, -a")}  Show all system processes
-                     ${pc3.dim("--name")}    Filter by app name
-                     ${pc3.dim("-w, --watch")}  Watch mode ${pc3.dim("(system processes refresh every 3s)")}
-
-    ${pc3.cyan("run")} ${pc3.dim("<command>")}        ${pc3.dim("Run a command under Fennec observation")}
-                     ${pc3.dim("--name")}    Process name ${pc3.dim("(required)")}
-                     ${pc3.dim("--cwd")}     Working directory
-                     ${pc3.dim("--restart")}  Auto-restart on crash
-
-    ${pc3.cyan("status")} ${pc3.dim("[name]")}        ${pc3.dim("Show system overview & top processes")}
-                     ${pc3.dim("-w, --watch")}  Watch mode ${pc3.dim("(refresh every 3s)")}
-
-    ${pc3.cyan("log")} ${pc3.dim("<pid|name>")}       ${pc3.dim("Show logs for a process")}
-                     ${pc3.dim("--lines")}   Number of lines ${pc3.dim("[default: 30]")}
-                     ${pc3.dim("-f, --follow")}  Follow mode ${pc3.dim("(journalctl --follow)")}
-
-    ${pc3.cyan("kill")} ${pc3.dim("<pid|name|all>")}  ${pc3.dim("Kill process(es) by PID, name, or all")}
-                     ${pc3.dim("--signal")}  Signal to send ${pc3.dim("[default: SIGTERM]")}
-                     ${pc3.dim("--all")}     Kill all user processes
-
-    ${pc3.cyan("restart")} ${pc3.dim("<pid|name>")}   ${pc3.dim("Kill + show re-run command")}
-
-  ${sep}
-  ${pc3.bold("Observation")}
-  ${sep}
-
-    ${pc3.cyan("attach")} ${pc3.dim("<port>")}         ${pc3.dim("Observe a process by port")}
-                     ${pc3.dim("--name")}    Process name
-
-    ${pc3.cyan("pipe")}             ${pc3.dim("Pipe stdin to log watcher")}
-                     ${pc3.dim("--name")}    Watcher name ${pc3.dim("(required)")}
-
-    ${pc3.cyan("watch")}            ${pc3.dim("Watch a log file")}
-                     ${pc3.dim("--file")}    File path ${pc3.dim("(required)")}
-                     ${pc3.dim("--name")}    Watcher name
-
-    ${pc3.cyan("attach-pid")} ${pc3.dim("<pid>")}      ${pc3.dim("Attach to process by PID")}
-    ${pc3.cyan("attach-port")} ${pc3.dim("<port>")}    ${pc3.dim("Attach to process by port")}
-
-  ${sep}
-  ${pc3.bold("Configuration")}
-  ${sep}
-
-    ${pc3.cyan("init")}             ${pc3.dim("Generate fennec.config.yaml")}
-    ${pc3.cyan("setup")}            ${pc3.dim("Configure MCP client")}
-    ${pc3.cyan("install-browsers")} ${pc3.dim("Install Playwright browser engines")}
-    ${pc3.cyan("sessions")}         ${pc3.dim("List saved auth sessions")}
-
-  ${sep}
-  ${pc3.bold("Other")}
-  ${sep}
-
-    ${pc3.cyan("help")}             ${pc3.dim("Show this help message")}
-    ${pc3.cyan("version")}          ${pc3.dim("Show version")}
-
-  ${pc3.dim("\u2500".repeat(50))}
-
-  ${pc3.dim("Learn more:")} ${pc3.cyan("https://github.com/plumpslabs/fennec")}
-  `);
+  const sep = fennecOrange3("\u2500".repeat(56));
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${pc3.bold("Usage:")} fennec ${pc3.dim("<command>")} ${pc3.dim("[options]")}`);
+  lines.push(`  ${pc3.dim("Run")} ${pc3.cyan("fennec <command> --help")} ${pc3.dim("for details on any command.")}`);
+  for (const group of GROUPS) {
+    lines.push("");
+    lines.push(`  ${sep}`);
+    lines.push(`  ${pc3.bold(group.title)}`);
+    lines.push(`  ${sep}`);
+    lines.push("");
+    for (const key of group.keys) {
+      const doc = COMMANDS[key];
+      if (!doc) continue;
+      const usageLabel = key === "start-server" ? "start" : doc.short ?? doc.usage;
+      lines.push(`    ${pc3.cyan(pad(usageLabel, 24))}  ${pc3.dim(doc.summary)}`);
+    }
+  }
+  lines.push("");
+  lines.push(`  ${pc3.dim("\u2500".repeat(56))}`);
+  lines.push(`  ${pc3.dim("Learn more:")} ${pc3.cyan("https://github.com/plumpslabs/fennec")}`);
+  lines.push("");
+  console.error(lines.join("\n"));
+}
+function showCommandHelp(cmd) {
+  const doc = findCommandDoc(cmd);
+  if (!doc) {
+    console.error(`
+  ${pc3.yellow("\u26A0")} Unknown command: ${pc3.bold(cmd)}`);
+    console.error(`  ${pc3.dim("Run")} ${pc3.cyan("fennec help")} ${pc3.dim("to see all commands.")}
+`);
+    return;
+  }
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${pc3.bold(fennecOrange3(doc.name))} ${pc3.dim("\u2014")} ${doc.summary}`);
+  lines.push("");
+  lines.push(`  ${pc3.bold("Usage:")} ${pc3.cyan(`fennec ${doc.usage}`)}`);
+  if (doc.aliases?.length) {
+    lines.push(`  ${pc3.bold("Aliases:")} ${doc.aliases.map((a) => pc3.cyan(a)).join(", ")}`);
+  }
+  if (doc.description) {
+    lines.push("");
+    lines.push(`  ${doc.description}`);
+  }
+  if (doc.options?.length) {
+    lines.push("");
+    lines.push(`  ${pc3.bold("Options:")}`);
+    const width = Math.max(...doc.options.map(([f]) => f.length));
+    for (const [flag, desc] of doc.options) {
+      lines.push(`    ${pc3.cyan(pad(flag, width))}  ${pc3.dim(desc)}`);
+    }
+  }
+  if (doc.examples?.length) {
+    lines.push("");
+    lines.push(`  ${pc3.bold("Examples:")}`);
+    for (const ex of doc.examples) {
+      lines.push(`    ${pc3.dim("$")} ${fennecOrange3(`fennec ${ex}`)}`);
+    }
+  }
+  lines.push("");
+  console.error(lines.join("\n"));
 }
 
 // src/commands/pipe.ts
@@ -2330,105 +2612,22 @@ async function watchCommand(args2) {
 }
 
 // src/commands/start.ts
-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 { mkdirSync as mkdirSync4 } from "fs";
+import { resolve as resolve4, dirname as dirname4 } from "path";
 import { FennecServer } from "@plumpslabs/fennec-core";
-import pc5 from "picocolors";
+import pc7 from "picocolors";
 
 // src/commands/tracker.ts
-import { existsSync as existsSync2, writeFileSync, readFileSync, mkdirSync, renameSync, statSync, rmSync } from "fs";
+import { existsSync as existsSync3, writeFileSync, readFileSync as readFileSync2, mkdirSync, renameSync, statSync, rmSync, openSync, closeSync, writeSync } from "fs";
+import { spawn } from "child_process";
 import { resolve as resolve2, dirname, basename } from "path";
 import { homedir } from "os";
-function getTrackedPath() {
-  const dir = process.env.FENNEC_DATA_DIR ? resolve2(process.env.FENNEC_DATA_DIR) : resolve2(homedir(), ".fennec");
-  return resolve2(dir, "tracked.json");
-}
-function readTracked() {
-  try {
-    const path = getTrackedPath();
-    if (!existsSync2(path)) return [];
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return [];
-  }
-}
-function saveTracked(processes) {
-  try {
-    const path = getTrackedPath();
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(processes, null, 2), "utf-8");
-  } catch (err) {
-    console.error("[fennec] Failed to save tracked processes:", err instanceof Error ? err.message : String(err));
-  }
-}
-function addTracked(proc) {
-  const tracked = readTracked();
-  const filtered = tracked.filter((t) => t.name !== proc.name);
-  filtered.push(proc);
-  saveTracked(filtered);
-}
-function removeTracked(name) {
-  const tracked = readTracked();
-  saveTracked(tracked.filter((t) => t.name !== name));
-}
-function removeTrackedByPid(pid) {
-  const tracked = readTracked();
-  saveTracked(tracked.filter((t) => t.pid !== pid));
-}
-function formatUptime(seconds) {
-  if (seconds < 60) return `${seconds}s`;
-  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-  const h = Math.floor(seconds / 3600);
-  const m = Math.floor(seconds % 3600 / 60);
-  if (h >= 24) {
-    const d = Math.floor(h / 24);
-    return `${d}d ${h % 24}h ${m}m`;
-  }
-  return `${h}h ${m}m`;
-}
-var DEFAULT_MAX_LOG_SIZE = 10 * 1024 * 1024;
-var DEFAULT_MAX_LOG_FILES = 3;
-function rotateLogFile(filePath, maxSize = DEFAULT_MAX_LOG_SIZE, maxFiles = DEFAULT_MAX_LOG_FILES) {
-  try {
-    if (!existsSync2(filePath)) return false;
-    const stats = statSync(filePath);
-    if (stats.size < maxSize) return false;
-    const dir = dirname(filePath);
-    const base = basename(filePath);
-    const oldestPath = resolve2(dir, `${base}.${maxFiles}`);
-    if (existsSync2(oldestPath)) {
-      try {
-        rmSync(oldestPath);
-      } catch {
-      }
-    }
-    for (let i = maxFiles - 1; i >= 1; i--) {
-      const src = resolve2(dir, `${base}.${i}`);
-      const dst = resolve2(dir, `${base}.${i + 1}`);
-      if (existsSync2(src)) {
-        try {
-          renameSync(src, dst);
-        } catch {
-        }
-      }
-    }
-    try {
-      renameSync(filePath, resolve2(dir, `${base}.1`));
-    } catch {
-    }
-    return true;
-  } catch (err) {
-    console.error("[fennec] Log rotation failed:", err instanceof Error ? err.message : String(err));
-    return false;
-  }
-}
 
 // src/utils/system-process.ts
-import { readdirSync, readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { readdirSync, readFileSync, existsSync as existsSync2, readlinkSync } from "fs";
 import { execSync } from "child_process";
 import { cpus } from "os";
+import net from "net";
 function readProcProcesses() {
   const processes = [];
   const currentUid = process.getuid?.();
@@ -2453,7 +2652,7 @@ function readSingleProcProcess(pid, currentUid, totalMemKb) {
   const statPath = `/proc/${pid}/stat`;
   const statusPath = `/proc/${pid}/status`;
   const cmdlinePath = `/proc/${pid}/cmdline`;
-  if (!existsSync3(statPath)) return null;
+  if (!existsSync2(statPath)) return null;
   const statusText = readSafe(statusPath);
   if (!statusText) return null;
   const nameMatch = statusText.match(/Name:\s+(.+)/);
@@ -2539,6 +2738,36 @@ function runPsProcesses() {
     return [];
   }
 }
+function runTasklistProcesses() {
+  try {
+    const output = execSync("tasklist /fo csv /nh 2>nul", { encoding: "utf-8", timeout: 5e3 });
+    const result = [];
+    for (const raw of output.split("\n")) {
+      if (!raw.trim()) continue;
+      const parts = raw.split('","').map((p) => p.replace(/^"|"$/g, ""));
+      const pid = parseInt(parts[1] ?? "", 10);
+      if (isNaN(pid)) continue;
+      const image = parts[0] ?? "";
+      const name = image.replace(/\.[a-z0-9]+$/i, "");
+      const memKb = parseInt((parts[4] ?? "").replace(/[^\d]/g, ""), 10) || 0;
+      result.push({
+        pid,
+        name,
+        command: image,
+        cpuPercent: 0,
+        memPercent: 0,
+        memRss: memKb,
+        state: "R",
+        startedAt: null,
+        ports: [],
+        isUserProcess: false
+      });
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
 function mapBsdState(s) {
   switch (s) {
     case "R":
@@ -2560,127 +2789,1033 @@ function detectListeningPorts(_pid) {
 }
 function readSafe(path) {
   try {
-    return readFileSync2(path, "utf-8");
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function readTotalMem() {
+  try {
+    const memInfo = readSafe("/proc/meminfo");
+    if (memInfo) {
+      const match = memInfo.match(/MemTotal:\s+(\d+)/);
+      if (match) return parseInt(match[1], 10);
+    }
+  } catch {
+  }
+  return 16e6;
+}
+function readUptime() {
+  try {
+    const data = readSafe("/proc/uptime");
+    if (data) {
+      return parseFloat(data.split(/\s+/)[0] ?? "0");
+    }
+  } catch {
+  }
+  return 0;
+}
+function formatStartTime(starttime, uptimeSeconds, hertz) {
+  try {
+    const bootTime = Date.now() / 1e3 - uptimeSeconds;
+    const processStart = bootTime + starttime / hertz;
+    return new Date(processStart * 1e3).toISOString();
+  } catch {
+    return null;
+  }
+}
+function getSystemProcesses(filter) {
+  let processes;
+  if (process.platform === "win32") {
+    processes = runTasklistProcesses();
+  } else if (existsSync2("/proc")) {
+    processes = readProcProcesses();
+  } else {
+    processes = runPsProcesses();
+  }
+  if (filter) {
+    if (filter.userOnly) {
+      processes = processes.filter((p) => p.isUserProcess);
+    }
+    if (filter.name) {
+      const nameLower = filter.name.toLowerCase();
+      processes = processes.filter(
+        (p) => p.name.toLowerCase().includes(nameLower) || p.command.toLowerCase().includes(nameLower)
+      );
+    }
+    if (filter.pid) {
+      processes = processes.filter((p) => p.pid === filter.pid);
+    }
+    if (filter.port) {
+      processes = processes.filter((p) => p.ports.includes(filter.port));
+    }
+    if (filter.sortBy) {
+      processes.sort((a, b) => {
+        switch (filter.sortBy) {
+          case "cpu":
+            return b.cpuPercent - a.cpuPercent;
+          case "mem":
+            return b.memPercent - a.memPercent;
+          case "pid":
+            return a.pid - b.pid;
+          case "name":
+            return a.name.localeCompare(b.name);
+          default:
+            return b.cpuPercent - a.cpuPercent;
+        }
+      });
+    }
+    if (filter.limit && filter.limit > 0) {
+      processes = processes.slice(0, filter.limit);
+    }
+  }
+  return processes;
+}
+function killProcess(pid, signal = "SIGTERM") {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkPort(port, host = "127.0.0.1", timeout = 1e3) {
+  const tryHost = (h) => new Promise((resolve13) => {
+    const socket = new net.Socket();
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve13(result);
+    };
+    socket.setTimeout(timeout);
+    socket.once("connect", () => finish(true));
+    socket.once("timeout", () => finish(false));
+    socket.once("error", () => finish(false));
+    socket.connect(port, h);
+  });
+  return tryHost(host).then((ok) => ok ? true : tryHost("::1"));
+}
+async function checkHttp(url, timeout = 2e3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const res = await fetch(url, { method: "GET", signal: controller.signal, redirect: "manual" });
+    return res.status >= 200 && res.status < 400;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function resolveHealthUrl(healthCheck, port) {
+  if (/^https?:\/\//i.test(healthCheck)) return healthCheck;
+  if (healthCheck.startsWith("/")) {
+    if (!port) return null;
+    return `http://127.0.0.1:${port}${healthCheck}`;
+  }
+  return null;
+}
+function findPidOnPort(port) {
+  if (process.platform === "win32") return findPidOnPortWindows(port);
+  if (process.platform === "darwin") return findPidOnPortMac(port);
+  return findPidOnPortLinux(port);
+}
+function findPidOnPortLinux(port) {
+  try {
+    const hexPort = port.toString(16).toUpperCase().padStart(4, "0");
+    const inodes = /* @__PURE__ */ new Set();
+    for (const f of ["/proc/net/tcp", "/proc/net/tcp6"]) {
+      if (!existsSync2(f)) continue;
+      for (const line of readFileSync(f, "utf-8").split("\n").slice(1)) {
+        const cols = line.trim().split(/\s+/);
+        if (cols.length < 10) continue;
+        if (cols[3] !== "0A") continue;
+        const localPort = cols[1]?.split(":")[1];
+        const inode = parseInt(cols[9] ?? "", 10);
+        if (localPort === hexPort && !Number.isNaN(inode)) inodes.add(inode);
+      }
+    }
+    if (inodes.size === 0) return null;
+    for (const pidStr of readdirSync("/proc").filter((d) => /^\d+$/.test(d))) {
+      const pid = parseInt(pidStr, 10);
+      try {
+        const fdDir = `/proc/${pid}/fd`;
+        for (const fd of readdirSync(fdDir)) {
+          const link = readlinkSync(`${fdDir}/${fd}`);
+          const m = link.match(/socket:\[(\d+)\]/);
+          if (m && inodes.has(parseInt(m[1], 10))) {
+            return { pid, command: getProcessCmdline(pid) ?? "" };
+          }
+        }
+      } catch {
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function findPidOnPortMac(port) {
+  try {
+    const out = execSync(`lsof -i :${port} -sTCP:LISTEN -P -n 2>/dev/null`, { encoding: "utf-8", timeout: 5e3 });
+    for (const line of out.split("\n")) {
+      if (!line.includes("LISTEN")) continue;
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 2) {
+        const pid = parseInt(parts[1], 10);
+        if (!isNaN(pid)) return { pid, command: parts[0] ?? "" };
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function findPidOnPortWindows(port) {
+  try {
+    const out = execSync(`netstat -ano -p tcp 2>nul`, { encoding: "utf-8", timeout: 5e3 });
+    const target = `:${port} `;
+    for (const line of out.split("\n")) {
+      const upper = line.toUpperCase();
+      if (!upper.includes("LISTENING")) continue;
+      if (!upper.includes(target)) continue;
+      const pid = parseInt(line.trim().split(/\s+/).pop() ?? "", 10);
+      if (!isNaN(pid)) return { pid, command: getProcessCmdline(pid) ?? "" };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getProcessCmdline(pid) {
+  if (process.platform === "win32") return getProcessCmdlineWindows(pid);
+  if (process.platform === "darwin") return getProcessCmdlineMac(pid);
+  return getProcessCmdlineLinux(pid);
+}
+function getProcessCmdlineLinux(pid) {
+  try {
+    const raw = readFileSync(`/proc/${pid}/cmdline`, "utf-8");
+    const joined = raw.split("\0").filter(Boolean).join(" ").trim();
+    return joined.length > 0 ? joined : null;
+  } catch {
+    return null;
+  }
+}
+function getProcessCmdlineMac(pid) {
+  try {
+    const out = execSync(`ps -p ${pid} -o command=`, { encoding: "utf-8", timeout: 3e3 });
+    const trimmed = out.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
+function getProcessCmdlineWindows(pid) {
+  try {
+    const out = execSync(`wmic process where ProcessId=${pid} get CommandLine /value 2>nul`, { encoding: "utf-8", timeout: 3e3 });
+    const line = out.split("\n").find((l) => l.includes("="));
+    const value = line?.split("=")[1]?.trim();
+    return value ? value : null;
+  } catch {
+    return null;
+  }
+}
+function getProcessCwd(pid) {
+  if (process.platform === "linux") {
+    try {
+      return readlinkSync(`/proc/${pid}/cwd`) || null;
+    } catch {
+      return null;
+    }
+  }
+  if (process.platform === "darwin") {
+    try {
+      const out = execSync(`lsof -p ${pid} -a -d cwd -F n 2>/dev/null`, { encoding: "utf-8", timeout: 3e3 });
+      const line = out.split("\n").find((l) => l.startsWith("n"));
+      return line ? line.slice(1) : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function getProcessEnviron(pid) {
+  try {
+    const raw = readFileSync(`/proc/${pid}/environ`, "utf-8");
+    const env = {};
+    for (const pair of raw.split("\0")) {
+      if (!pair) continue;
+      const eq = pair.indexOf("=");
+      if (eq === -1) continue;
+      env[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+    return env;
   } catch {
     return null;
   }
 }
-function readTotalMem() {
-  try {
-    const memInfo = readSafe("/proc/meminfo");
-    if (memInfo) {
-      const match = memInfo.match(/MemTotal:\s+(\d+)/);
-      if (match) return parseInt(match[1], 10);
-    }
-  } catch {
+function formatProcessState(state) {
+  switch (state) {
+    case "R":
+      return "Running";
+    case "S":
+      return "Sleeping";
+    case "D":
+      return "Disk Sleep";
+    case "Z":
+      return "Zombie";
+    case "T":
+      return "Stopped";
+    case "t":
+      return "Tracing";
+    case "X":
+      return "Dead";
+    case "I":
+      return "Idle";
+    default:
+      return state;
+  }
+}
+
+// src/commands/tracker.ts
+var RESTART_CAUSE = "fennec:restart";
+function getFennecDir() {
+  return process.env.FENNEC_DATA_DIR ? resolve2(process.env.FENNEC_DATA_DIR) : resolve2(homedir(), ".fennec");
+}
+function getTrackedPath() {
+  return resolve2(getFennecDir(), "tracked.json");
+}
+function getSupervisorPidPath() {
+  return resolve2(getFennecDir(), "supervisor.pid");
+}
+function logFilePathFor(name) {
+  return resolve2(getFennecDir(), "logs", `${name}.log`);
+}
+function readTracked() {
+  try {
+    const path = getTrackedPath();
+    if (!existsSync3(path)) return [];
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveTracked(processes) {
+  try {
+    const path = getTrackedPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(processes, null, 2), "utf-8");
+  } catch (err) {
+    console.error("[fennec] Failed to save tracked processes:", err instanceof Error ? err.message : String(err));
+  }
+}
+function addTracked(proc) {
+  const tracked = readTracked();
+  const filtered = tracked.filter((t) => t.name !== proc.name);
+  filtered.push(proc);
+  saveTracked(filtered);
+}
+function removeTracked(name) {
+  const tracked = readTracked();
+  saveTracked(tracked.filter((t) => t.name !== name));
+}
+function setAutoRestart(name, value) {
+  const tracked = readTracked();
+  let changed = false;
+  for (const t of tracked) {
+    if (t.name === name) {
+      t.autoRestart = value;
+      changed = true;
+    }
+  }
+  if (changed) saveTracked(tracked);
+}
+function removeTrackedByPid(pid) {
+  const tracked = readTracked();
+  saveTracked(tracked.filter((t) => t.pid !== pid));
+}
+function resolveArgs(proc) {
+  if (proc.args && proc.args.length > 0) return proc.args;
+  return proc.command.split(/\s+/).filter(Boolean);
+}
+function adoptProcess(pid, opts = {}) {
+  if (!isProcessRunning(pid)) return null;
+  const command2 = opts.command ?? getProcessCmdline(pid) ?? `pid ${pid}`;
+  const cwd = opts.cwd ?? getProcessCwd(pid) ?? void 0;
+  const name = opts.name ?? `pid_${pid}`;
+  const entry = {
+    name,
+    pid,
+    command: command2,
+    port: opts.port,
+    cwd,
+    env: opts.env,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    autoRestart: opts.autoRestart ?? true,
+    flapping: false
+  };
+  addTracked(entry);
+  return entry;
+}
+function adoptExternalOnPort(port, name) {
+  const occ = findPidOnPort(port);
+  if (!occ) return null;
+  const tracked = readTracked();
+  if (tracked.some((t) => t.pid === occ.pid)) return null;
+  return adoptProcess(occ.pid, { port, name });
+}
+function isTrackedRunning(proc) {
+  if (!isProcessRunning(proc.pid)) return false;
+  const environ = getProcessEnviron(proc.pid);
+  if (environ && "FENNEC_APP_NAME" in environ) {
+    return environ.FENNEC_APP_NAME === proc.name;
+  }
+  const cmdline = getProcessCmdline(proc.pid);
+  if (!cmdline) return true;
+  const argv = resolveArgs(proc);
+  const exe = argv[0];
+  if (!exe) return true;
+  const exeBase = basename(exe);
+  if (exeBase.length === 0) return true;
+  return cmdline.includes(exeBase);
+}
+function formatUptime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  if (h >= 24) {
+    const d = Math.floor(h / 24);
+    return `${d}d ${h % 24}h ${m}m`;
+  }
+  return `${h}h ${m}m`;
+}
+var DEFAULT_MAX_LOG_SIZE = 10 * 1024 * 1024;
+var DEFAULT_MAX_LOG_FILES = 3;
+function rotateLogFile(filePath, maxSize = DEFAULT_MAX_LOG_SIZE, maxFiles = DEFAULT_MAX_LOG_FILES) {
+  try {
+    if (!existsSync3(filePath)) return false;
+    const stats = statSync(filePath);
+    if (stats.size < maxSize) return false;
+    const dir = dirname(filePath);
+    const base = basename(filePath);
+    const oldestPath = resolve2(dir, `${base}.${maxFiles}`);
+    if (existsSync3(oldestPath)) {
+      try {
+        rmSync(oldestPath);
+      } catch {
+      }
+    }
+    for (let i = maxFiles - 1; i >= 1; i--) {
+      const src = resolve2(dir, `${base}.${i}`);
+      const dst = resolve2(dir, `${base}.${i + 1}`);
+      if (existsSync3(src)) {
+        try {
+          renameSync(src, dst);
+        } catch {
+        }
+      }
+    }
+    try {
+      renameSync(filePath, resolve2(dir, `${base}.1`));
+    } catch {
+    }
+    return true;
+  } catch (err) {
+    console.error("[fennec] Log rotation failed:", err instanceof Error ? err.message : String(err));
+    return false;
+  }
+}
+function buildSpawnEnv(stored) {
+  const merged = { ...process.env };
+  for (const [k, v] of Object.entries(stored ?? {})) {
+    if (v !== void 0) merged[k] = v;
+  }
+  if (process.env.FENNEC_DATA_DIR) merged.FENNEC_DATA_DIR = process.env.FENNEC_DATA_DIR;
+  if (process.env.HOME) merged.HOME = process.env.HOME;
+  return merged;
+}
+function respawnTracked(proc, cause) {
+  const cmdParts = resolveArgs(proc);
+  const logFilePath = logFilePathFor(proc.name);
+  mkdirSync(dirname(logFilePath), { recursive: true });
+  if (cause) annotateRestart(logFilePath, cause);
+  if (isProcessRunning(proc.pid)) {
+    try {
+      process.kill(proc.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  const child = spawnDaemon({
+    cmdParts,
+    name: proc.name,
+    cwd: proc.cwd,
+    logFilePath,
+    env: buildSpawnEnv(proc.env),
+    logMode: proc.logMode
+  });
+  const pid = child.pid ?? 0;
+  addTracked({
+    ...proc,
+    pid,
+    args: cmdParts,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    restartCause: cause
+  });
+  return pid;
+}
+function spawnDaemon(opts) {
+  rotateLogFile(opts.logFilePath);
+  const env = { ...opts.env ?? buildSpawnEnv(), FENNEC_APP_NAME: opts.name };
+  if (opts.logMode === "jsonl") {
+    return spawnDaemonJsonl(opts, env);
+  }
+  const fd = openSync(opts.logFilePath, "a");
+  const child = spawn(opts.cmdParts[0], opts.cmdParts.slice(1), {
+    cwd: opts.cwd,
+    env,
+    stdio: ["ignore", fd, fd],
+    detached: true
+  });
+  child.unref();
+  child.once("spawn", () => {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+  });
+  return child;
+}
+function spawnDaemonJsonl(opts, env) {
+  const relay = spawn(
+    process.execPath,
+    ["-e", JSONL_RELAY],
+    {
+      env: { ...process.env, FENNEC_RELAY_LOG: opts.logFilePath },
+      stdio: ["pipe", "ignore", "ignore"],
+      detached: true
+    }
+  );
+  relay.unref();
+  const child = spawn(opts.cmdParts[0], opts.cmdParts.slice(1), {
+    cwd: opts.cwd,
+    env,
+    stdio: ["ignore", relay.stdin, relay.stdin],
+    detached: true
+  });
+  child.unref();
+  try {
+    relay.stdin?.destroy();
+  } catch {
+  }
+  return child;
+}
+var JSONL_RELAY = `
+const fs = require('fs');
+const fd = fs.openSync(process.env.FENNEC_RELAY_LOG, 'a');
+let buf = '';
+const SECRET = new RegExp('(password|passwd|token|secret|api[_-]?key|access[_-]?key).{0,60}', 'gi');
+function redact(s){ return s.replace(SECRET, '$1***'); }
+function level(s){
+  const t = s.toLowerCase();
+  if (t.indexOf('error')>=0 || t.indexOf('fail')>=0 || t.indexOf('fatal')>=0 || t.indexOf('exception')>=0 || t.indexOf('denied')>=0 || t.indexOf('refused')>=0 || t.indexOf('cannot')>=0 || t.indexOf('panic')>=0) return 'error';
+  if (t.indexOf('warn')>=0) return 'warn';
+  return 'info';
+}
+function flush(){
+  const parts = buf.split('\\n');
+  buf = parts.pop() || '';
+  for (const r of parts){
+    if (!r) continue;
+    const line = redact(r);
+    try { fs.writeSync(fd, JSON.stringify({ ts: new Date().toISOString(), level: level(line), source: 'app', line }) + '\\n'); } catch (e) {}
+  }
+}
+process.stdin.on('data', (c) => { buf += c.toString('utf8'); flush(); });
+process.stdin.on('end', () => { flush(); try { fs.closeSync(fd); } catch (e) {} process.exit(0); });
+process.stdin.on('error', () => { process.exit(0); });
+`;
+function annotateRestart(logFilePath, cause) {
+  try {
+    const fd = openSync(logFilePath, "a");
+    try {
+      writeSync(fd, `
+${RESTART_CAUSE} cause=${cause} at=${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+  }
+}
+
+// src/commands/supervisor.ts
+import pc4 from "picocolors";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { spawn as spawn2 } from "child_process";
+import { dirname as dirname2 } from "path";
+var POLL_INTERVAL_MS = 3e3;
+var CRASH_WINDOW_MS = 6e4;
+var MAX_RESTARTS_IN_WINDOW = 5;
+var FLAPPING_THRESHOLD = 3;
+var PORT_GRACE_MS = 15e3;
+var LOG_ROTATE_CHECK_MS = 60 * 60 * 1e3;
+function getSupervisorPid() {
+  const path = getSupervisorPidPath();
+  if (!existsSync4(path)) return null;
+  const pid = parseInt(readFileSync3(path, "utf-8").trim(), 10);
+  if (isNaN(pid)) return null;
+  return isProcessRunning(pid) ? pid : null;
+}
+function ensureSupervisorRunning() {
+  const existing = getSupervisorPid();
+  if (existing) return existing;
+  return startSupervisorDaemon();
+}
+function startSupervisorDaemon() {
+  const logFilePath = logFilePathFor("supervisor");
+  mkdirSync2(dirname2(logFilePath), { recursive: true });
+  const fd = openSync2(logFilePath, "a");
+  const child = spawn2(process.execPath, [process.argv[1], "__supervisor"], {
+    env: { ...process.env },
+    stdio: ["ignore", fd, fd],
+    detached: true
+  });
+  child.unref();
+  child.once("spawn", () => {
+    try {
+      closeSync2(fd);
+    } catch {
+    }
+  });
+  return child.pid ?? 0;
+}
+async function supervisorCommand(args2) {
+  const sub = args2[0] ?? "status";
+  switch (sub) {
+    case "start":
+      return supervisorStart();
+    case "stop":
+      return supervisorStop();
+    case "restart":
+      await supervisorStop();
+      return supervisorStart();
+    case "status":
+      return supervisorStatus();
+    default:
+      console.error(renderError("Unknown sub-command", `"${sub}" \u2014 use: start | stop | status | restart`));
+      process.exit(1);
+  }
+}
+function supervisorStart() {
+  const existing = getSupervisorPid();
+  if (existing) {
+    console.error(`
+  ${pc4.yellow("\u26A0")} Supervisor already running ${pc4.dim(`(PID ${existing})`)}
+`);
+    return;
   }
-  return 16e6;
+  const pid = startSupervisorDaemon();
+  console.error(`
+  ${pc4.green("\u2713")} ${pc4.bold("Supervisor started")} ${pc4.dim(`(PID ${pid})`)}`);
+  console.error(`  ${renderKV("Logs", pc4.cyan("fennec log supervisor"))}`);
+  console.error(`  ${pc4.dim("It will auto-restart apps started with")} ${pc4.cyan("--restart")} ${pc4.dim("even if you close this terminal.")}
+`);
 }
-function readUptime() {
+function supervisorStop() {
+  const pid = getSupervisorPid();
+  if (!pid) {
+    console.error(`
+  ${pc4.dim("Supervisor is not running.")}
+`);
+    return;
+  }
   try {
-    const data = readSafe("/proc/uptime");
-    if (data) {
-      return parseFloat(data.split(/\s+/)[0] ?? "0");
-    }
-  } catch {
+    process.kill(pid, "SIGTERM");
+    console.error(`
+  ${pc4.green("\u2713")} ${pc4.bold("Supervisor stopped")} ${pc4.dim(`(PID ${pid})`)}
+`);
+  } catch (err) {
+    console.error(renderError("Failed to stop supervisor", String(err)));
   }
-  return 0;
-}
-function formatStartTime(starttime, uptimeSeconds, hertz) {
   try {
-    const bootTime = Date.now() / 1e3 - uptimeSeconds;
-    const processStart = bootTime + starttime / hertz;
-    return new Date(processStart * 1e3).toISOString();
+    unlinkSync(getSupervisorPidPath());
   } catch {
-    return null;
   }
 }
-function getSystemProcesses(filter) {
-  let processes;
-  if (existsSync3("/proc")) {
-    processes = readProcProcesses();
+function supervisorStatus() {
+  const pid = getSupervisorPid();
+  const tracked = readTracked();
+  const managed = tracked.filter((t) => t.autoRestart);
+  console.error(`
+  ${symbols.fox} ${pc4.bold("Fennec Supervisor")}`);
+  if (pid) {
+    console.error(`  ${pc4.green("\u25CF")} running ${pc4.dim(`(PID ${pid})`)}`);
   } else {
-    processes = runPsProcesses();
+    console.error(`  ${pc4.red("\u25CB")} not running ${pc4.dim("\u2014 start with")} ${pc4.cyan("fennec supervisor start")}`);
   }
-  if (filter) {
-    if (filter.userOnly) {
-      processes = processes.filter((p) => p.isUserProcess);
-    }
-    if (filter.name) {
-      const nameLower = filter.name.toLowerCase();
-      processes = processes.filter(
-        (p) => p.name.toLowerCase().includes(nameLower) || p.command.toLowerCase().includes(nameLower)
-      );
+  console.error(`
+  ${pc4.bold("Managed apps")} ${pc4.dim(`(${managed.length} with auto-restart)`)}`);
+  if (managed.length === 0) {
+    console.error(`  ${pc4.dim("None. Start one with")} ${pc4.cyan("fennec start <cmd> --name <name> --restart")}`);
+  } else {
+    for (const t of managed) {
+      const running = isTrackedRunning(t);
+      const dot = running ? pc4.green("\u25CF") : pc4.red("\u25CB");
+      const state = running ? pc4.green(`running (PID ${t.pid})`) : pc4.red("stopped");
+      console.error(`  ${dot} ${pc4.bold(t.name)} ${pc4.dim("\u2014")} ${state}`);
     }
-    if (filter.pid) {
-      processes = processes.filter((p) => p.pid === filter.pid);
+  }
+  console.error();
+}
+var PORT_FAIL_THRESHOLD = 2;
+async function runSupervisor() {
+  const pidPath = getSupervisorPidPath();
+  mkdirSync2(dirname2(pidPath), { recursive: true });
+  const existing = getSupervisorPid();
+  if (existing && existing !== process.pid) {
+    log(`supervisor already running (PID ${existing}); exiting`);
+    return;
+  }
+  writeFileSync2(pidPath, String(process.pid), "utf-8");
+  log(`supervisor started (PID ${process.pid}), polling every ${POLL_INTERVAL_MS}ms`);
+  const crashes = /* @__PURE__ */ new Map();
+  let stopped = false;
+  const cleanup = () => {
+    stopped = true;
+    try {
+      unlinkSync(pidPath);
+    } catch {
     }
-    if (filter.port) {
-      processes = processes.filter((p) => p.ports.includes(filter.port));
+    log("supervisor stopping");
+    process.exit(0);
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+  const tick = async () => {
+    if (stopped) return;
+    let tracked;
+    try {
+      tracked = readTracked();
+    } catch (err) {
+      log(`failed to read tracked.json: ${String(err)}`);
+      return;
     }
-    if (filter.sortBy) {
-      processes.sort((a, b) => {
-        switch (filter.sortBy) {
-          case "cpu":
-            return b.cpuPercent - a.cpuPercent;
-          case "mem":
-            return b.memPercent - a.memPercent;
-          case "pid":
-            return a.pid - b.pid;
-          case "name":
-            return a.name.localeCompare(b.name);
-          default:
-            return b.cpuPercent - a.cpuPercent;
+    for (const t of tracked) {
+      if (!t.autoRestart) continue;
+      if (t.port && isTrackedRunning(t)) {
+        const startedAt = Date.parse(t.startedAt);
+        const ageMs = Number.isNaN(startedAt) ? Number.POSITIVE_INFINITY : Date.now() - startedAt;
+        if (ageMs >= PORT_GRACE_MS) {
+          let rec2 = crashes.get(t.name);
+          if (!rec2) {
+            rec2 = { windowStart: Date.now(), count: 0, gaveUp: false, portFails: 0 };
+            crashes.set(t.name, rec2);
+          }
+          let listening = false;
+          const healthUrl = t.healthCheck ? resolveHealthUrl(t.healthCheck, t.port) : null;
+          try {
+            listening = healthUrl ? await checkHttp(healthUrl) : await checkPort(t.port);
+          } catch {
+            listening = false;
+          }
+          if (listening) {
+            rec2.portFails = 0;
+            if (t.flapping && Date.now() - rec2.windowStart > CRASH_WINDOW_MS) setFlapping(t, false);
+          } else {
+            rec2.portFails++;
+            const probe = healthUrl ? `health check ${healthUrl}` : `port ${t.port}`;
+            if (rec2.portFails >= PORT_FAIL_THRESHOLD) {
+              rec2.portFails = 0;
+              rec2.count++;
+              if (rec2.count >= FLAPPING_THRESHOLD) setFlapping(t, true);
+              log(`${t.name}: alive but ${probe} not responding ${PORT_FAIL_THRESHOLD}x \u2014 restarting`);
+              try {
+                const newPid = respawnTracked(t, "port-down");
+                log(`${t.name}: restarted (PID ${newPid}) after ${probe} failure`);
+              } catch (err) {
+                log(`${t.name}: restart failed: ${String(err)}`);
+              }
+            } else {
+              log(`${t.name}: ${probe} not responding (${rec2.portFails}/${PORT_FAIL_THRESHOLD})`);
+            }
+          }
         }
-      });
+        continue;
+      }
+      if (isTrackedRunning(t)) continue;
+      const now = Date.now();
+      let rec = crashes.get(t.name);
+      if (rec?.gaveUp && now - rec.windowStart > CRASH_WINDOW_MS) rec = void 0;
+      if (!rec || now - rec.windowStart > CRASH_WINDOW_MS) {
+        rec = { windowStart: now, count: 0, gaveUp: false, portFails: 0 };
+        crashes.set(t.name, rec);
+        if (t.flapping) setFlapping(t, false);
+      }
+      if (rec.gaveUp) continue;
+      if (rec.count >= MAX_RESTARTS_IN_WINDOW) {
+        rec.gaveUp = true;
+        log(`${t.name}: crashed ${rec.count}x in <60s \u2014 giving up (will retry after window resets)`);
+        continue;
+      }
+      rec.count++;
+      if (rec.count >= FLAPPING_THRESHOLD) setFlapping(t, true);
+      try {
+        const newPid = respawnTracked(t, "crash");
+        log(`${t.name}: restarted (PID ${newPid}) [${rec.count}/${MAX_RESTARTS_IN_WINDOW} in window]`);
+      } catch (err) {
+        log(`${t.name}: restart failed: ${String(err)}`);
+      }
     }
-    if (filter.limit && filter.limit > 0) {
-      processes = processes.slice(0, filter.limit);
+  };
+  tick();
+  setInterval(tick, POLL_INTERVAL_MS);
+  setInterval(rotateAllLogs, LOG_ROTATE_CHECK_MS);
+  await new Promise(() => {
+  });
+}
+function rotateAllLogs() {
+  try {
+    for (const t of readTracked()) {
+      try {
+        rotateLogFile(logFilePathFor(t.name));
+      } catch {
+      }
     }
+  } catch (err) {
+    log(`log rotation pass failed: ${String(err)}`);
   }
-  return processes;
 }
-function killProcess(pid, signal = "SIGTERM") {
+function setFlapping(t, val) {
+  if (!!t.flapping === val) return;
+  t.flapping = val;
   try {
-    process.kill(pid, signal);
-    return true;
+    addTracked({ ...t, flapping: val });
   } catch {
-    return false;
   }
 }
-function isProcessRunning(pid) {
+function log(msg) {
+  process.stdout.write(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`);
+}
+
+// src/commands/persist.ts
+import pc5 from "picocolors";
+import { existsSync as existsSync5, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3 } from "fs";
+import { resolve as resolve3, dirname as dirname3 } from "path";
+import { homedir as homedir2, platform } from "os";
+import { execFileSync } from "child_process";
+function detectBackend() {
+  const p = platform();
+  if (p === "linux" || p === "freebsd") {
+    return "systemd";
+  }
+  if (p === "darwin") return "launchd";
+  if (p === "win32") return "windows";
+  return "unsupported";
+}
+function unitPaths(backend) {
+  const fennecDir = getFennecDir();
+  switch (backend) {
+    case "systemd":
+      return { unit: resolve3(homedir2(), ".config", "systemd", "user", "fennec-supervisor.service") };
+    case "launchd":
+      return { unit: resolve3(homedir2(), "Library", "LaunchAgents", "io.fennec.supervisor.plist") };
+    case "windows":
+      return { unit: resolve3(homedir2(), "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "fennec-supervisor.bat") };
+    default:
+      return { unit: resolve3(fennecDir, "persist.unit") };
+  }
+}
+function buildUnit(backend, dataDir) {
+  const nodeBin = process.execPath;
+  const cli = process.argv[1] ?? "fennec";
+  const envLine = `FENNEC_DATA_DIR=${dataDir}`;
+  if (backend === "systemd") {
+    return `[Unit]
+Description=Fennec process supervisor (auto-restarts managed apps)
+After=network.target
+
+[Service]
+Type=simple
+Environment=${envLine}
+ExecStart=${nodeBin} ${cli} supervisor start
+Restart=on-failure
+
+[Install]
+WantedBy=default.target
+`;
+  }
+  if (backend === "launchd") {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>io.fennec.supervisor</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodeBin}</string>
+    <string>${cli}</string>
+    <string>supervisor</string>
+    <string>start</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>FENNEC_DATA_DIR</key>
+    <string>${dataDir}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+</dict>
+</plist>
+`;
+  }
+  return `@echo off
+set FENNEC_DATA_DIR=${dataDir}
+"${nodeBin}" "${cli}" supervisor start
+`;
+}
+function run(cmd, args2) {
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+    const out = execFileSync(cmd, args2, { stdio: ["ignore", "pipe", "pipe"] }).toString().trim();
+    return { ok: true, out };
+  } catch (err) {
+    const e = err;
+    const out = (e.stdout ?? e.stderr ?? Buffer.from("")).toString().trim();
+    return { ok: false, out };
   }
 }
-function formatProcessState(state) {
-  switch (state) {
-    case "R":
-      return "Running";
-    case "S":
-      return "Sleeping";
-    case "D":
-      return "Disk Sleep";
-    case "Z":
-      return "Zombie";
-    case "T":
-      return "Stopped";
-    case "t":
-      return "Tracing";
-    case "X":
-      return "Dead";
-    case "I":
-      return "Idle";
+function persistEnabled(backend = detectBackend()) {
+  const { unit } = unitPaths(backend);
+  return existsSync5(unit);
+}
+function ensurePersistEnabled() {
+  const backend = detectBackend();
+  if (backend === "unsupported") return false;
+  if (persistEnabled(backend)) return false;
+  persistEnable(backend);
+  return true;
+}
+async function persistCommand(args2) {
+  const sub = args2[0] ?? "status";
+  const backend = detectBackend();
+  if (backend === "unsupported") {
+    console.error(renderError("Unsupported platform", `Boot persistence isn't available on ${platform()}. You can still run "fennec supervisor start" manually.`));
+    process.exit(1);
+  }
+  switch (sub) {
+    case "enable":
+      return persistEnable(backend);
+    case "disable":
+      return persistDisable(backend);
+    case "status":
+      return persistStatus(backend);
     default:
-      return state;
+      console.error(renderError("Unknown sub-command", `"${sub}" \u2014 use: enable | disable | status`));
+      process.exit(1);
+  }
+}
+function persistEnable(backend) {
+  const dataDir = getFennecDir();
+  const { unit } = unitPaths(backend);
+  mkdirSync3(dirname3(unit), { recursive: true });
+  writeFileSync3(unit, buildUnit(backend, dataDir), "utf-8");
+  if (backend === "windows") {
+    console.error(`
+  ${pc5.green("\u2713")} ${pc5.bold("Boot script installed")} ${pc5.dim(`(runs at next login)`)}`);
+    console.error(`  ${renderKV("Path", pc5.cyan(unit))}`);
+    console.error(`  ${pc5.dim("Supervisor will start automatically when you log in.")}
+`);
+    return;
+  }
+  if (backend === "systemd") {
+    const reg = run("systemctl", ["--user", "enable", "--now", resolve3(unit)]);
+    if (!reg.ok) {
+      run("systemctl", ["--user", "enable", resolve3(unit)]);
+      run("systemctl", ["--user", "start", "fennec-supervisor.service"]);
+    }
+    const linger = run("loginctl", ["enable-linger"]);
+    if (!linger.ok) {
+      console.error(`  ${pc5.yellow("\u26A0")} ${pc5.dim("Could not enable user linger \u2014 the supervisor may stop when you log out.")}`);
+    }
+    console.error(`
+  ${pc5.green("\u2713")} ${pc5.bold("Boot persistence enabled")} ${pc5.dim("(systemd user service)")}`);
+    console.error(`  ${renderKV("Unit", pc5.cyan("fennec-supervisor.service"))}`);
+    console.error(`  ${renderKV("Data dir", pc5.cyan(dataDir))}`);
+    console.error(`  ${pc5.dim("The supervisor (and all --restart apps) will start at login and keep running after logout.")}
+`);
+    return;
+  }
+  if (backend === "launchd") {
+    run("launchctl", ["load", resolve3(unit)]);
+    console.error(`
+  ${pc5.green("\u2713")} ${pc5.bold("Boot persistence enabled")} ${pc5.dim("(launchd agent)")}`);
+    console.error(`  ${renderKV("Label", pc5.cyan("io.fennec.supervisor"))}`);
+    console.error(`  ${renderKV("Data dir", pc5.cyan(dataDir))}`);
+    console.error(`  ${pc5.dim("The supervisor will start at login.")}
+`);
+    return;
+  }
+}
+function persistDisable(backend) {
+  const { unit } = unitPaths(backend);
+  if (backend === "systemd") {
+    run("systemctl", ["--user", "disable", "--now", "fennec-supervisor.service"]);
+  } else if (backend === "launchd") {
+    run("launchctl", ["unload", resolve3(unit)]);
+  }
+  try {
+    if (existsSync5(unit)) unlinkSync2(unit);
+  } catch {
+  }
+  console.error(`
+  ${pc5.green("\u2713")} ${pc5.bold("Boot persistence disabled")}
+`);
+}
+function persistStatus(backend) {
+  const { unit } = unitPaths(backend);
+  const installed = existsSync5(unit);
+  const label = backend === "systemd" ? "fennec-supervisor.service" : backend === "launchd" ? "io.fennec.supervisor" : "fennec-supervisor.bat";
+  console.error(`
+  ${pc5.bold("Fennec Boot Persistence")} ${pc5.dim(`(${backend})`)}`);
+  if (!installed) {
+    console.error(`  ${pc5.red("\u25CB")} ${pc5.dim("not installed \u2014 run ")}${pc5.cyan("fennec persist enable")}${pc5.dim(" to auto-start apps after reboot")}`);
+    console.error();
+    return;
+  }
+  if (backend === "systemd") {
+    const en = run("systemctl", ["--user", "is-enabled", "fennec-supervisor.service"]).out;
+    const ac = run("systemctl", ["--user", "is-active", "fennec-supervisor.service"]).out;
+    console.error(`  ${pc5.green("\u25CF")} ${pc5.bold("installed")}`);
+    console.error(`  ${renderKV("Enabled", en || "?")}`);
+    console.error(`  ${renderKV("Active", ac || "?")}`);
+  } else if (backend === "launchd") {
+    const loaded = run("launchctl", ["list", "io.fennec.supervisor"]).ok;
+    console.error(`  ${pc5.green("\u25CF")} ${pc5.bold("installed")}`);
+    console.error(`  ${renderKV("Loaded", loaded ? pc5.green("yes") : pc5.red("no"))}`);
+  } else {
+    console.error(`  ${pc5.green("\u25CF")} ${pc5.bold("installed")} ${pc5.dim("(runs at login)")}`);
   }
+  console.error(`  ${renderKV("Unit", pc5.cyan(label))}`);
+  console.error(`  ${renderKV("Path", pc5.cyan(unit))}`);
+  console.error();
 }
 
 // src/commands/ps.ts
-import pc4 from "picocolors";
+import pc6 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");
@@ -2703,32 +3838,32 @@ async function psCommand(args2) {
       process.stdout.write("\r\x1B[K");
       if (processes.length === 0) {
         console.error(`
-  ${pc4.dim("No system processes found.")}
+  ${pc6.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: "pid", label: "PID", align: "right", format: (v) => pc6.dim(String(v).padStart(6)) },
+        { key: "name", label: "Name", format: (v) => pc6.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));
+          return n > 10 ? pc6.red(String(n)) : n > 5 ? pc6.yellow(String(n)) : pc6.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));
+          return n > 10 ? pc6.red(String(n)) : n > 5 ? pc6.yellow(String(n)) : pc6.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);
+          if (s === "R" || s === "Running") return pc6.green(s);
+          if (s === "Z" || s === "Zombie") return pc6.red(s);
+          if (s === "S" || s === "Sleeping") return pc6.cyan(s);
+          return pc6.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})`)}
+  ${symbols.fox} ${pc6.bold("System Processes")} ${pc6.dim(`(top ${processes.length} by ${sortBy})`)}
 `);
       console.error(renderTable(columns2, rows2));
       console.error();
@@ -2741,49 +3876,49 @@ async function psCommand(args2) {
   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>")}
+  ${pc6.dim("No tracked processes.")}`);
+    console.error(`  ${pc6.dim("Start an app with:")} ${pc6.cyan("fennec start <command> --name <name>")}
 `);
     return;
   }
   const columns = [
-    { key: "name", label: "App", format: (v) => pc4.bold(String(v)) },
+    { key: "name", label: "App", format: (v) => pc6.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");
+      return s === "running" ? pc6.green("\u25CF running") : pc6.red("\u25CB stopped");
     } },
     { key: "port", label: "Port", format: (v) => {
       const p = v;
-      return p ? pc4.yellow(`:${p}`) : pc4.dim("-");
+      return p ? pc6.yellow(`:${p}`) : pc6.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)) }
+    { key: "uptime", label: "Uptime", format: (v) => pc6.dim(String(v)) }
   ];
   const rows = tracked.map((t) => {
-    const running = isProcessRunning(t.pid);
+    const running = isTrackedRunning(t);
     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 };
+    return { name: t.name, pid: running ? String(t.pid) : pc6.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;
+  const runningCount = tracked.filter((t) => isTrackedRunning(t)).length;
   console.error(`
-  ${symbols.fox} ${pc4.bold("Fennec Apps")} ${pc4.dim(`(${runningCount}/${tracked.length} running)`)}
+  ${symbols.fox} ${pc6.bold("Fennec Apps")} ${pc6.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(`  ${pc6.dim("Use")} ${pc6.cyan("fennec start <command> --name <name> --port <port>")} ${pc6.dim("to add more apps.")}`);
+  console.error(`  ${pc6.dim("Use")} ${pc6.cyan("fennec log <name>")} ${pc6.dim("to view logs.")}`);
+  console.error(`  ${pc6.dim("Use")} ${pc6.cyan("fennec stop <name>")} ${pc6.dim("to pause an app.")}`);
+  console.error(`  ${pc6.dim("Use")} ${pc6.cyan("fennec spawn <name>")} ${pc6.dim("to resume a paused app.")}`);
+  console.error(`  ${pc6.dim("Use")} ${pc6.cyan("fennec kill <name>")} ${pc6.dim("to permanently remove an app.")}`);
   console.error();
 }
 async function psJson() {
   const tracked = readTracked();
   const data = tracked.map((t) => {
-    const running = isProcessRunning(t.pid);
+    const running = isTrackedRunning(t);
     return {
       name: t.name,
       pid: t.pid,
@@ -2803,54 +3938,54 @@ async function statusCommand(_args) {
   const topSystem = getSystemProcesses({ userOnly: true, sortBy: "cpu", limit: 5 });
   const totalUserProcs = getSystemProcesses({ userOnly: true }).length;
   console.error(`
-  ${symbols.fox} ${pc4.bold("Fennec Status")}
+  ${symbols.fox} ${pc6.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)`)}
+    const runningCount = tracked.filter((t) => isTrackedRunning(t)).length;
+    console.error(`  ${pc6.bold("Managed Apps")} ${pc6.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}`);
+      const running = isTrackedRunning(t);
+      const statusIcon = running ? pc6.green("\u25CF") : pc6.red("\u25CB");
+      const portStr = t.port ? ` ${pc6.yellow(`:${t.port}`)}` : "";
+      const uptime = running ? pc6.dim(formatUptime(Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3))) : pc6.red("stopped");
+      console.error(`  ${statusIcon} ${pc6.bold(t.name)}${portStr} ${pc6.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(`  ${pc6.dim("No managed apps.")} ${pc6.cyan("fennec start <command> --name <name>")}
 `);
   }
-  console.error(`  ${pc4.bold("System")} ${pc4.dim(`(${totalUserProcs} user processes)`)}`);
+  console.error(`  ${pc6.bold("System")} ${pc6.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}`);
+    const cpuStr = p.cpuPercent > 10 ? pc6.red(`${p.cpuPercent}%`) : p.cpuPercent > 5 ? pc6.yellow(`${p.cpuPercent}%`) : pc6.dim(`${p.cpuPercent}%`);
+    const memStr = p.memPercent > 10 ? pc6.red(`${p.memPercent}%`) : p.memPercent > 5 ? pc6.yellow(`${p.memPercent}%`) : pc6.dim(`${p.memPercent}%`);
+    console.error(`  ${pc6.dim(`PID ${p.pid}`)} ${pc6.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)")}
+  ${pc6.bold("Watching system processes")} ${pc6.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: "pid", label: "PID", align: "right", format: (v) => pc6.dim(String(v).padStart(6)) },
+      { key: "name", label: "Name", format: (v) => pc6.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));
+        return n > 10 ? pc6.red(String(n)) : n > 5 ? pc6.yellow(String(n)) : pc6.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));
+        return n > 10 ? pc6.red(String(n)) : n > 5 ? pc6.yellow(String(n)) : pc6.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`)}
+    return `  ${timestamp()} ${pc6.dim(`${processes.length} processes`)}
 ${renderTable(columns, rows, { compact: true })}`;
   };
   console.error(render());
@@ -2858,33 +3993,67 @@ ${renderTable(columns, rows, { compact: true })}`;
     process.stdout.write("\x1B[J");
     console.error(render());
   }, 3e3);
-  await new Promise((resolve12) => {
+  await new Promise((resolve13) => {
     process.once("SIGINT", () => {
       clearInterval(interval);
       process.stdout.write("\x1B[J");
-      resolve12();
+      resolve13();
     });
   });
 }
 
 // src/commands/start.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitForReady(pid, port, timeoutMs = 8e3) {
+  const start = Date.now();
+  const graceMs = 700;
+  while (Date.now() - start < timeoutMs) {
+    if (!isProcessRunning(pid)) return { running: false, portReady: false };
+    if (port !== void 0) {
+      if (await checkPort(port)) return { running: true, portReady: true };
+      await sleep(250);
+      continue;
+    }
+    if (Date.now() - start >= graceMs) return { running: true, portReady: false };
+    await sleep(150);
+  }
+  return { running: isProcessRunning(pid), portReady: port === void 0 ? false : false };
+}
 async function startServer(args2) {
   printBanner();
-  console.error(`  ${pc5.dim("Starting Fennec MCP server...")}
+  console.error(`  ${pc7.dim("Starting Fennec MCP server...")}
 `);
   const configIndex = args2.indexOf("--config");
   const configPath = configIndex !== -1 ? args2[configIndex + 1] : void 0;
+  const useSse = args2.includes("--sse");
+  if (useSse) {
+    process.env.FENNEC_TRANSPORT_TYPE = "sse";
+  }
   try {
     const server = new FennecServer(configPath);
     await resurrectTracked();
     await server.start();
-    console.error(`
-  ${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(`
-  ${pc5.dim("Press Ctrl+C to stop")}
+    if (useSse) {
+      const port = server.getConfig().transport.port;
+      console.error(`
+  ${pc7.green("\u2713")} ${pc7.bold("Fennec server is running")}`);
+      console.error(`  ${renderKV("Transport", pc7.cyan("SSE (HTTP)"))}`);
+      console.error(`  ${renderKV("URL", pc7.cyan(`http://localhost:${port}/sse`))}`);
+      console.error(`  ${renderKV("MCP Config", pc7.cyan(`{ "type": "remote", "url": "http://localhost:${port}/sse" }`))}`);
+      console.error(`  ${renderKV("OpenCode", pc7.cyan(`type: remote, url: http://localhost:${port}/sse`))}`);
+      console.error(`
+  ${pc7.dim("Press Ctrl+C to stop")}
 `);
+    } else {
+      console.error(`
+  ${pc7.green("\u2713")} ${pc7.bold("Fennec server is running")}`);
+      console.error(`  ${renderKV("Transport", "stdio")}`);
+      console.error(`  ${renderKV("AI Agent", "Connect via MCP protocol")}`);
+      console.error(`  ${renderKV("Tip", pc7.dim("For SSE mode: fennec start --sse"))}`);
+      console.error(`
+  ${pc7.dim("Press Ctrl+C to stop")}
+`);
+    }
   } catch (error) {
     console.error(renderError("Failed to start server", String(error)));
     process.exit(1);
@@ -2892,7 +4061,7 @@ async function startServer(args2) {
 }
 async function startCommand(args2) {
   printBanner();
-  console.error(`  ${pc5.dim("Starting app...")}
+  console.error(`  ${pc7.dim("Starting app...")}
 `);
   await runCommand(args2);
 }
@@ -2902,8 +4071,9 @@ async function runCommand(args2) {
   const portIndex = args2.indexOf("--port");
   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 cwd = cwdIndex !== -1 ? resolve4(args2[cwdIndex + 1]) : process.cwd();
   const restartFlag = args2.includes("--restart");
+  const jsonlFlag = args2.includes("--jsonl");
   const stopFlags = [nameIndex, portIndex, cwdIndex].filter((i) => i !== -1);
   const cmdEnd = Math.min(...stopFlags, Infinity);
   const cmdParts = args2.slice(0, cmdEnd);
@@ -2913,87 +4083,82 @@ async function runCommand(args2) {
     process.exit(1);
   }
   const appName = name ?? cmdParts[0] ?? "app";
+  if (port !== void 0) {
+    const adopted = adoptExternalOnPort(port, appName);
+    if (adopted) {
+      console.error(`
+  ${pc7.green("\u2713")} ${pc7.bold("Adopted")} ${pc7.bold(adopted.name)} ${pc7.dim(`(PID ${adopted.pid}) \u2014 already listening on :${port}`)}`);
+      console.error(`  ${renderKV("Logs", pc7.cyan(`fennec log ${adopted.name}`))}`);
+      console.error();
+      return;
+    }
+  }
   const tracked = readTracked();
   const existing = tracked.find((t) => t.name === appName);
-  if (existing && isProcessRunning(existing.pid)) {
+  if (existing && isTrackedRunning(existing)) {
     console.error();
-    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(`  ${pc7.yellow("\u26A0")} ${pc7.bold(appName)} ${pc7.dim(`is already running (PID: ${existing.pid})`)}`);
+    console.error(`  ${renderKV("Logs", pc7.cyan(`fennec log ${appName}`))}`);
+    console.error(`  ${renderKV("Stop", pc7.cyan(`fennec kill ${appName}`))}`);
     console.error();
     process.exit(0);
   }
-  const logDir = resolve3(homedir2(), ".fennec", "logs");
-  mkdirSync2(logDir, { recursive: true });
-  const logFilePath = resolve3(logDir, `${appName}.log`);
+  const logDir = dirname4(logFilePathFor(appName));
+  mkdirSync4(logDir, { recursive: true });
+  const logFilePath = logFilePathFor(appName);
   console.error(`
-  ${symbols.fox} ${pc5.bold("Starting")} ${renderAppName(appName)} ${pc5.dim("(daemon)")}
+  ${symbols.fox} ${pc7.bold("Starting")} ${renderAppName(appName)} ${pc7.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"))}`);
+  if (restartFlag) console.error(`  ${renderKV("Auto-restart", pc7.green("enabled"))}`);
   console.error(`  ${divider()}`);
   try {
-    let currentChild = spawn(cmdParts[0], cmdParts.slice(1), {
-      cwd,
-      env: { ...process.env },
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: true
-    });
+    const startEnv = {};
+    for (const [k, v] of Object.entries(process.env)) {
+      if (v !== void 0) startEnv[k] = v;
+    }
+    const currentChild = spawnDaemon({ cmdParts, name: appName, cwd, logFilePath, env: buildSpawnEnv(startEnv), logMode: jsonlFlag ? "jsonl" : "text" });
     const pid = currentChild.pid ?? 0;
-    rotateLogFile(logFilePath);
-    const logStream = createWriteStream(logFilePath, { flags: "a" });
-    if (currentChild.stdout) currentChild.stdout.pipe(logStream);
-    if (currentChild.stderr) currentChild.stderr.pipe(logStream);
-    currentChild.unref();
     addTracked({
       name: appName,
       pid,
       command: cmd,
+      args: cmdParts,
       port,
       cwd,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      env: startEnv,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      autoRestart: restartFlag,
+      logMode: jsonlFlag ? "jsonl" : "text"
     });
-    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);
-          }
-        });
-      };
-      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();
-        });
-      });
+    console.error(`  ${pc7.green("\u2713")} ${pc7.bold(appName)} ${pc7.dim(`started (PID: ${pid})`)}`);
+    const spinner = createSpinner(port ? `Waiting for ${appName} on port ${port}...` : `Confirming ${appName} is running...`);
+    const ready = await waitForReady(pid, port);
+    spinner.stop();
+    process.stdout.write("\r\x1B[K");
+    if (!ready.running) {
+      removeTracked(appName);
+      console.error(`  ${pc7.red("\u2717")} ${pc7.bold(appName)} ${pc7.dim("exited immediately after start")}`);
+      console.error(`  ${renderKV("Logs", pc7.cyan(`fennec log ${appName}`))}`);
+      console.error();
+      process.exit(1);
+    }
+    if (port) {
+      if (ready.portReady) {
+        console.error(`  ${pc7.green("\u2713")} ${pc7.bold(appName)} ${pc7.dim(`is listening on port ${port}`)}`);
+      } else {
+        console.error(`  ${pc7.yellow("\u26A0")} ${pc7.bold(appName)} ${pc7.dim(`is running but port ${port} is not accepting connections yet`)}`);
+      }
     }
-    if (!restartFlag) {
-      await psCommand([]);
+    if (restartFlag) {
+      const supPid = ensureSupervisorRunning();
+      ensurePersistEnabled();
+      console.error(`  ${pc7.green("\u2713")} ${pc7.bold("Auto-restart")} ${pc7.dim(`managed by supervisor (PID ${supPid}) \u2014 survives terminal close`)}`);
+      console.error(`  ${renderKV("Supervisor", pc7.cyan("fennec supervisor status"))}`);
     }
+    await psCommand([]);
   } catch (error) {
     console.error(renderError(`Failed to start ${appName}`, String(error)));
     process.exit(1);
@@ -3002,7 +4167,7 @@ async function runCommand(args2) {
 async function resurrectTracked() {
   const tracked = readTracked();
   if (tracked.length === 0) return;
-  const dead = tracked.filter((t) => !isProcessRunning(t.pid));
+  const dead = tracked.filter((t) => !isTrackedRunning(t));
   if (dead.length === 0) return;
   const spinner = createSpinner(`Resurrecting ${dead.length} stopped process(es)...`);
   let resurrected = 0;
@@ -3013,28 +4178,21 @@ async function resurrectTracked() {
       continue;
     }
     try {
-      const cmdParts = proc.command.split(/\s+/);
-      const logDir = resolve3(homedir2(), ".fennec", "logs");
-      mkdirSync2(logDir, { recursive: true });
-      const logFilePath = resolve3(logDir, `${proc.name}.log`);
-      const child = spawn(cmdParts[0], cmdParts.slice(1), {
-        cwd: proc.cwd,
-        env: { ...process.env },
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: true
-      });
-      rotateLogFile(logFilePath);
-      const logStream = createWriteStream(logFilePath, { flags: "a" });
-      if (child.stdout) child.stdout.pipe(logStream);
-      if (child.stderr) child.stderr.pipe(logStream);
-      child.unref();
+      const cmdParts = resolveArgs(proc);
+      const logFilePath = logFilePathFor(proc.name);
+      const child = spawnDaemon({ cmdParts, name: proc.name, cwd: proc.cwd, logFilePath, env: buildSpawnEnv(proc.env), logMode: proc.logMode });
       addTracked({
         name: proc.name,
         pid: child.pid ?? 0,
         command: proc.command,
+        args: cmdParts,
         port: proc.port,
         cwd: proc.cwd,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        env: proc.env,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        autoRestart: proc.autoRestart,
+        restartCause: proc.restartCause,
+        logMode: proc.logMode
       });
       resurrected++;
     } catch {
@@ -3044,15 +4202,15 @@ async function resurrectTracked() {
   spinner.stop();
   process.stdout.write("\r\x1B[K");
   if (resurrected > 0) {
-    console.error(`  ${pc5.green("\u25CF")} ${pc5.bold(`Resurrected ${resurrected} process(es)`)}`);
+    console.error(`  ${pc7.green("\u25CF")} ${pc7.bold(`Resurrected ${resurrected} process(es)`)}`);
   }
   if (failed > 0) {
-    console.error(`  ${pc5.red("\u25CF")} ${pc5.bold(`${failed} process(es) failed to resurrect`)}`);
+    console.error(`  ${pc7.red("\u25CF")} ${pc7.bold(`${failed} process(es) failed to resurrect`)}`);
   }
 }
 
 // src/commands/kill.ts
-import pc6 from "picocolors";
+import pc8 from "picocolors";
 async function killCommand(args2) {
   const rawTarget = args2[0];
   const signalIndex = args2.indexOf("--signal");
@@ -3079,21 +4237,29 @@ async function killCommand(args2) {
   } else {
     const tracked = readTracked();
     const trackedMatch = tracked.find((t) => t.name === rawTarget);
-    if (trackedMatch && isProcessRunning(trackedMatch.pid)) {
+    if (trackedMatch) {
+      if (!isTrackedRunning(trackedMatch)) {
+        console.error(`
+  ${pc8.yellow("\u26A0")} ${pc8.bold(rawTarget)} ${pc8.dim("is already stopped (no running process to kill)")}`);
+        console.error(`  ${pc8.dim("Use")} ${pc8.cyan("fennec spawn")} ${pc8.dim("to resume")}`);
+        process.exit(0);
+      }
       targetPid = trackedMatch.pid;
       displayName = `${trackedMatch.name} (PID ${targetPid})`;
     } else {
-      const matches = getSystemProcesses({ name: rawTarget, userOnly: true, sortBy: "cpu" });
+      const currentPid = process.pid;
+      let matches = getSystemProcesses({ name: rawTarget, userOnly: true, sortBy: "cpu" });
+      matches = matches.filter((m) => m.pid !== currentPid);
       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}":`)}`);
+  ${pc8.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")}`);
+          console.error(`  ${pc8.dim("Cancelled")}`);
           return;
         }
         const idx = parseInt(selected, 10);
@@ -3105,9 +4271,10 @@ async function killCommand(args2) {
       }
     }
   }
-  const confirmed = await confirmPrompt(`Kill ${pc6.bold(displayName)} with ${pc6.yellow(signal)}?`, false);
+  const force = args2.includes("-y") || args2.includes("--yes");
+  const confirmed = force || await confirmPrompt(`Kill ${pc8.bold(displayName)} with ${pc8.yellow(signal)}?`, false);
   if (!confirmed) {
-    console.error(`  ${pc6.dim("Cancelled")}`);
+    console.error(`  ${pc8.dim("Cancelled")}`);
     return;
   }
   const spinner = createSpinner(`Sending ${signal} to ${displayName}...`);
@@ -3117,16 +4284,16 @@ async function killCommand(args2) {
     const stillRunning = isProcessRunning(targetPid);
     if (stillRunning && signal !== "SIGKILL") {
       spinner.warn(`${displayName} did not respond to ${signal}`);
-      const forceKill = await confirmPrompt(`Send ${pc6.red("SIGKILL")} to force stop?`, true);
+      const forceKill = force || await confirmPrompt(`Send ${pc8.red("SIGKILL")} to force stop?`, true);
       if (forceKill) {
         const forceSpinner = createSpinner(`Sending SIGKILL to ${displayName}...`);
         killProcess(targetPid, "SIGKILL");
         await new Promise((r) => setTimeout(r, 300));
         isProcessRunning(targetPid) ? forceSpinner.fail(`${displayName} could not be stopped (permission denied?)`) : forceSpinner.succeed(`${displayName} force stopped`);
       } else {
-        console.error(`  ${pc6.dim("Retrying with SIGTERM...")}`);
+        console.error(`  ${pc8.dim("Retrying with SIGTERM...")}`);
         killProcess(targetPid, "SIGTERM");
-        console.error(`  ${pc6.yellow("\u26A0")} ${displayName} ${pc6.dim("may still be running")}`);
+        console.error(`  ${pc8.yellow("\u26A0")} ${displayName} ${pc8.dim("may still be running")}`);
       }
     } else {
       removeTrackedByPid(targetPid);
@@ -3140,17 +4307,17 @@ async function killCommand(args2) {
 async function killAll(signal) {
   const userProcs = getSystemProcesses({ userOnly: true, sortBy: "cpu", limit: 200 });
   if (userProcs.length === 0) {
-    console.error(`  ${pc6.dim("No user processes to kill.")}`);
+    console.error(`  ${pc8.dim("No user processes to kill.")}`);
     return;
   }
   console.error(`
-  ${pc6.bold(`Kill ${userProcs.length} user processes?`)}`);
-  console.error(`  ${pc6.dim("This will stop ALL your running processes.")}`);
-  console.error(`  ${pc6.yellow("\u26A0 System processes will not be affected.")}
+  ${pc8.bold(`Kill ${userProcs.length} user processes?`)}`);
+  console.error(`  ${pc8.dim("This will stop ALL your running processes.")}`);
+  console.error(`  ${pc8.yellow("\u26A0 System processes will not be affected.")}
 `);
-  const confirmed = await confirmPrompt(`${pc6.red("Are you sure?")} ${pc6.dim("This cannot be undone")}`, false);
+  const confirmed = await confirmPrompt(`${pc8.red("Are you sure?")} ${pc8.dim("This cannot be undone")}`, false);
   if (!confirmed) {
-    console.error(`  ${pc6.dim("Cancelled.")}`);
+    console.error(`  ${pc8.dim("Cancelled.")}`);
     return;
   }
   const spinner = createSpinner(`Killing ${userProcs.length} processes...`);
@@ -3166,15 +4333,15 @@ async function killAll(signal) {
   }
   await new Promise((r) => setTimeout(r, 500));
   killed > 0 ? spinner.succeed(`${killed} process(es) killed`) : spinner.fail("Failed to kill processes");
-  if (failed > 0) console.error(`  ${pc6.yellow(`${failed} process(es) could not be killed`)} ${pc6.dim("(try with sudo)")}`);
+  if (failed > 0) console.error(`  ${pc8.yellow(`${failed} process(es) could not be killed`)} ${pc8.dim("(try with sudo)")}`);
 }
 
 // src/commands/stop.ts
-import pc7 from "picocolors";
+import pc9 from "picocolors";
 async function stopCommand(args2) {
   const stopAll = args2.includes("--all") || args2.includes("-a");
   if (stopAll) {
-    await stopAllTracked();
+    await stopAllTracked(args2);
     return;
   }
   const rawTarget = args2[0];
@@ -3185,42 +4352,45 @@ async function stopCommand(args2) {
   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.`));
+    console.error(renderError("Not found", `No tracked process named "${rawTarget}". Use ${pc9.cyan("fennec kill <pid>")} to kill a system process.`));
     process.exit(1);
   }
-  if (!isProcessRunning(trackedMatch.pid)) {
+  if (!isTrackedRunning(trackedMatch)) {
     console.error(`
-  ${pc7.yellow("\u26A0")} ${pc7.bold(rawTarget)} ${pc7.dim("is already stopped")}`);
+  ${pc9.yellow("\u26A0")} ${pc9.bold(rawTarget)} ${pc9.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);
+  const force = args2.includes("-y") || args2.includes("--yes");
+  const confirmed = force || await confirmPrompt(`Stop ${pc9.bold(displayName)}? ${pc9.dim("It can be re-spawned later via fennec spawn")}`, false);
   if (!confirmed) {
-    console.error(`  ${pc7.dim("Cancelled")}`);
+    console.error(`  ${pc9.dim("Cancelled")}`);
     return;
   }
+  setAutoRestart(trackedMatch.name, false);
   await stopSingleProcess(trackedMatch.pid, trackedMatch.name);
 }
-async function stopAllTracked() {
+async function stopAllTracked(args2) {
   const tracked = readTracked();
-  const running = tracked.filter((t) => isProcessRunning(t.pid));
+  const running = tracked.filter((t) => isTrackedRunning(t));
   if (running.length === 0) {
     console.error(`
-  ${pc7.dim("No running tracked processes to stop.")}
+  ${pc9.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)")}
+  ${pc9.yellow("\u26A0")} ${pc9.bold(`Stop all ${running.length} running process(es)?`)} ${pc9.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(`  ${pc9.green("\u25CF")} ${pc9.bold(t.name)} ${pc9.dim(`(PID ${t.pid})`)}`);
   }
   console.error();
-  const confirmed = await confirmPrompt("Stop all?", false);
+  const forceAll = args2.includes("-y") || args2.includes("--yes");
+  const confirmed = forceAll || await confirmPrompt("Stop all?", false);
   if (!confirmed) {
-    console.error(`  ${pc7.dim("Cancelled")}
+    console.error(`  ${pc9.dim("Cancelled")}
 `);
     return;
   }
@@ -3228,6 +4398,7 @@ async function stopAllTracked() {
   let stopped = 0;
   let failed = 0;
   for (const t of running) {
+    setAutoRestart(t.name, false);
     if (killProcess(t.pid, "SIGTERM")) {
       stopped++;
     } else {
@@ -3238,10 +4409,10 @@ async function stopAllTracked() {
   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)")}`);
+    console.error(`  ${pc9.green("\u2713")} ${pc9.bold(`Stopped ${stopped} process(es)`)} ${pc9.dim("(kept in tracked.json)")}`);
   }
   if (failed > 0) {
-    console.error(`  ${pc7.red("\u2717")} ${pc7.bold(`${failed} process(es) failed to stop`)}`);
+    console.error(`  ${pc9.red("\u2717")} ${pc9.bold(`${failed} process(es) failed to stop`)}`);
   }
   console.error();
   await psCommand([]);
@@ -3255,14 +4426,14 @@ async function stopSingleProcess(pid, name) {
     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);
+      const forceKill = await confirmPrompt(`Send ${pc9.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")}`);
+        console.error(`  ${pc9.yellow("\u26A0")} ${displayName} ${pc9.dim("may still be running")}`);
       }
     } else {
       spinner.succeed(`${displayName} stopped`);
@@ -3276,11 +4447,10 @@ async function stopSingleProcess(pid, name) {
 }
 
 // src/commands/spawn.ts
-import pc8 from "picocolors";
-import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync3 } from "fs";
-import { resolve as resolve4 } from "path";
+import pc10 from "picocolors";
+import { mkdirSync as mkdirSync5 } from "fs";
+import { resolve as resolve5 } 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];
@@ -3295,13 +4465,13 @@ async function spawnCommand(args2) {
   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.`));
+    console.error(renderError("Not found", `No tracked process named "${name}". Use ${pc10.cyan("fennec spawn")} to see available processes, or ${pc10.cyan("fennec start <command> --name <name>")} to create a new one.`));
     process.exit(1);
   }
-  if (isProcessRunning(match.pid)) {
+  if (isTrackedRunning(match)) {
     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.")}`);
+  ${pc10.yellow("\u26A0")} ${pc10.bold(name)} ${pc10.dim("is already running (PID:")} ${match.pid}${pc10.dim(")")}`);
+    console.error(`  ${pc10.dim("Use")} ${pc10.cyan(`fennec stop ${name}`)} ${pc10.dim("to stop it first.")}`);
     console.error();
     process.exit(0);
   }
@@ -3313,18 +4483,18 @@ async function spawnCommand(args2) {
 }
 async function spawnAllStopped() {
   const tracked = readTracked();
-  const toSpawn = tracked.filter((t) => !isProcessRunning(t.pid) && t.command);
+  const toSpawn = tracked.filter((t) => !isTrackedRunning(t) && t.command);
   if (toSpawn.length === 0) {
     console.error(`
-  ${pc8.dim("No stopped processes with saved commands to spawn.")}
+  ${pc10.dim("No stopped processes with saved commands to spawn.")}
 `);
     return;
   }
   console.error(`
-  ${symbols.fox} ${pc8.bold(`Spawning ${toSpawn.length} process(es)...`)}
+  ${symbols.fox} ${pc10.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(`  ${pc10.dim("\xB7")} ${pc10.bold(t.name)} ${pc10.dim(`(${t.command})`)}`);
   }
   console.error();
   const spinner = createSpinner("Spawning...");
@@ -3332,30 +4502,28 @@ async function spawnAllStopped() {
   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 cmdParts = resolveArgs(proc);
+      const logDir = resolve5(homedir3(), ".fennec", "logs");
+      mkdirSync5(logDir, { recursive: true });
+      const logFilePath = resolve5(logDir, `${proc.name}.log`);
+      const child = spawnDaemon({ cmdParts, name: proc.name, cwd: proc.cwd, logFilePath, env: buildSpawnEnv(proc.env), logMode: proc.logMode });
       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,
+        args: cmdParts,
         port: proc.port,
         cwd: proc.cwd,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        env: proc.env,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        autoRestart: proc.autoRestart,
+        logMode: proc.logMode
       });
+      if (proc.autoRestart) {
+        ensureSupervisorRunning();
+        ensurePersistEnabled();
+      }
       spawned++;
     } catch {
       failed++;
@@ -3364,10 +4532,10 @@ async function spawnAllStopped() {
   spinner.stop();
   process.stdout.write("\r\x1B[K");
   if (spawned > 0) {
-    console.error(`  ${pc8.green("\u2713")} ${pc8.bold(`Spawned ${spawned} process(es)`)}`);
+    console.error(`  ${pc10.green("\u2713")} ${pc10.bold(`Spawned ${spawned} process(es)`)}`);
   }
   if (failed > 0) {
-    console.error(`  ${pc8.red("\u2717")} ${pc8.bold(`${failed} process(es) failed to spawn`)}`);
+    console.error(`  ${pc10.red("\u2717")} ${pc10.bold(`${failed} process(es) failed to spawn`)}`);
   }
   console.error();
   await psCommand([]);
@@ -3376,25 +4544,25 @@ 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>")}`);
+  ${pc10.dim("No tracked processes found.")}`);
+    console.error(`  ${pc10.dim("Start an app first:")} ${pc10.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));
+  const stopped = tracked.filter((t) => !isTrackedRunning(t));
+  const running = tracked.filter((t) => isTrackedRunning(t));
   if (stopped.length === 0) {
     console.error(`
-  ${pc8.dim("All tracked processes are running. Nothing to spawn.")}`);
+  ${pc10.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)`)}`);
+  ${symbols.fox} ${pc10.bold("Available to spawn")} ${pc10.dim(`(${stopped.length}/${tracked.length} stopped)`)}`);
   if (running.length > 0) {
-    console.error(`  ${pc8.dim("Running (use stop first):")}`);
+    console.error(`  ${pc10.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(`    ${pc10.green("\u25CF")} ${pc10.bold(r.name)} ${pc10.dim(`(PID ${r.pid})`)}`);
     }
     console.error();
   }
@@ -3404,7 +4572,7 @@ async function spawnList() {
     description: t.command.length > 80 ? t.command.slice(0, 80) + "..." : t.command
   })));
   if (selected === null) {
-    console.error(`  ${pc8.dim("Cancelled")}`);
+    console.error(`  ${pc10.dim("Cancelled")}`);
     return;
   }
   const match = stopped.find((t) => t.name === selected);
@@ -3413,38 +4581,36 @@ async function spawnList() {
   }
 }
 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`);
+  const cmdParts = resolveArgs(proc);
+  const logDir = resolve5(homedir3(), ".fennec", "logs");
+  mkdirSync5(logDir, { recursive: true });
+  const logFilePath = resolve5(logDir, `${proc.name}.log`);
   console.error(`
-  ${symbols.fox} ${pc8.bold("Spawning")} ${renderAppName(proc.name)} ${pc8.dim("(from saved config)")}
+  ${symbols.fox} ${pc10.bold("Spawning")} ${renderAppName(proc.name)} ${pc10.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 child = spawnDaemon({ cmdParts, name: proc.name, cwd: proc.cwd, logFilePath, env: buildSpawnEnv(proc.env), logMode: proc.logMode });
     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,
+      args: cmdParts,
       port: proc.port,
       cwd: proc.cwd,
-      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      env: proc.env,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      autoRestart: proc.autoRestart,
+      logMode: proc.logMode
     });
-    console.error(`  ${pc8.green("\u2713")} ${pc8.bold(proc.name)} ${pc8.dim(`spawned (PID: ${pid})`)}`);
+    if (proc.autoRestart) {
+      ensureSupervisorRunning();
+      ensurePersistEnabled();
+    }
+    console.error(`  ${pc10.green("\u2713")} ${pc10.bold(proc.name)} ${pc10.dim(`spawned (PID: ${pid})`)}`);
     await psCommand([]);
   } catch (error) {
     console.error(renderError(`Failed to spawn ${proc.name}`, String(error)));
@@ -3453,11 +4619,10 @@ async function respawnProcess(proc) {
 }
 
 // src/commands/restart.ts
-import pc9 from "picocolors";
-import { mkdirSync as mkdirSync4, createWriteStream as createWriteStream3 } from "fs";
-import { resolve as resolve5 } from "path";
+import pc11 from "picocolors";
+import { mkdirSync as mkdirSync6 } from "fs";
+import { resolve as resolve6 } 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) {
@@ -3482,9 +4647,9 @@ async function restartCommand(args2) {
       targetPid = processes[0].pid;
     }
   }
-  const confirmed = await confirmPrompt(`Restart ${pc9.bold(`${name} (PID ${targetPid})`)}?`, false);
+  const confirmed = await confirmPrompt(`Restart ${pc11.bold(`${name} (PID ${targetPid})`)}?`, false);
   if (!confirmed) {
-    console.error(`  ${pc9.dim("Cancelled")}`);
+    console.error(`  ${pc11.dim("Cancelled")}`);
     return;
   }
   const spinner = createSpinner(`Stopping PID ${targetPid}...`);
@@ -3503,86 +4668,581 @@ async function restartCommand(args2) {
   if (trackedEntry) {
     const respawnSpinner = createSpinner(`Re-spawning ${trackedEntry.name}...`);
     try {
-      const cmdParts = trackedEntry.command.split(" ");
-      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 = createWriteStream3(logFilePath, { flags: "a" });
-      if (child.stdout) child.stdout.pipe(logStream);
-      if (child.stderr) child.stderr.pipe(logStream);
-      child.unref();
+      const cmdParts = resolveArgs(trackedEntry);
+      const logDir = resolve6(homedir4(), ".fennec", "logs");
+      mkdirSync6(logDir, { recursive: true });
+      const logFilePath = resolve6(logDir, `${trackedEntry.name}.log`);
+      const child = spawnDaemon({ cmdParts, name: trackedEntry.name, cwd: trackedEntry.cwd, logFilePath, env: buildSpawnEnv(trackedEntry.env), logMode: trackedEntry.logMode });
       removeTrackedByPid(targetPid);
       addTracked({
         name: trackedEntry.name,
         pid: child.pid ?? 0,
         command: trackedEntry.command,
+        args: cmdParts,
         port: trackedEntry.port,
         cwd: trackedEntry.cwd,
-        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        env: trackedEntry.env,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        autoRestart: trackedEntry.autoRestart,
+        logMode: trackedEntry.logMode
       });
       respawnSpinner.succeed(`${trackedEntry.name} restarted (PID: ${child.pid})`);
     } catch (error) {
       respawnSpinner.fail(`Failed to re-spawn ${trackedEntry.name}: ${String(error)}`);
-      console.error(`  ${pc9.dim("Config preserved. Re-run manually:")} ${renderCommand(trackedEntry.command)}`);
+      console.error(`  ${pc11.dim("Config preserved. Re-run manually:")} ${renderCommand(trackedEntry.command)}`);
+    }
+  } else {
+    console.error(`  ${pc11.dim("No tracked config found. Re-run manually:")} ${renderCommand(name)}`);
+  }
+}
+
+// src/commands/adopt.ts
+import pc12 from "picocolors";
+function adoptCommand(args2) {
+  const pidArg = args2.find((a) => /^\d+$/.test(a));
+  if (!pidArg) {
+    console.error(renderError("Missing PID", `Usage: fennec adopt <pid> [--name <name>] [--port <port>]`));
+    process.exit(1);
+  }
+  const pid = parseInt(pidArg, 10);
+  const nameIdx = args2.indexOf("--name");
+  const name = nameIdx !== -1 ? args2[nameIdx + 1] : void 0;
+  const portIdx = args2.indexOf("--port");
+  const port = portIdx !== -1 ? parseInt(args2[portIdx + 1] ?? "", 10) : void 0;
+  const entry = adoptProcess(pid, { name, port: Number.isNaN(port) ? void 0 : port });
+  if (!entry) {
+    console.error(renderError("Cannot adopt", `No running process with PID ${pid}`));
+    process.exit(1);
+  }
+  console.error(`
+  ${symbols.fox} ${pc12.green("\u2713")} ${pc12.bold("Adopted")} ${pc12.bold(entry.name)} ${pc12.dim(`(PID ${pid})`)}`);
+  if (entry.port) console.error(`  ${pc12.dim("port")}     ${pc12.yellow(`:${entry.port}`)}`);
+  if (entry.command) console.error(`  ${pc12.dim("command")}  ${entry.command}`);
+  console.error(`  ${pc12.dim("status")}   now tracked + supervised by the supervisor`);
+  console.error(`  ${pc12.dim("logs")}     ${pc12.cyan(logFilePathFor(entry.name))}
+`);
+}
+
+// src/commands/inspect.ts
+import { readFileSync as readFileSync6 } from "fs";
+import pc13 from "picocolors";
+
+// src/utils/redact.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+var SECRET_PATTERNS = [
+  // Bearer / auth tokens
+  { name: "bearer", re: /\bBearer\s+[A-Za-z0-9._\-]+/gi },
+  // Authorization: <scheme> <token>
+  { name: "authorization", re: /\bAuthorization\s*:\s*\S+/gi },
+  // Generic API keys
+  { name: "apikey", re: /\b(api[_-]?key|apikey|access[_-]?key|secret[_-]?key|private[_-]?key)\s*[:=]\s*\S+/gi },
+  // AWS
+  { name: "aws", re: /\b(AKIA|ASIA)[0-9A-Z]{16}\b/g },
+  // Slack tokens
+  { name: "slack", re: /\bxox[baprs]-[0-9A-Za-z\-]{10,}/g },
+  // Stripe
+  { name: "stripe", re: /\b(sk|rk|pk)_(live|test)_[0-9A-Za-z]{16,}\b/g },
+  // JWT
+  { name: "jwt", re: /\beyJ[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]*/g },
+  // Google API
+  { name: "google", re: /\bAIza[0-9A-Za-z_\-]{35}\b/g },
+  // GitHub PAT
+  { name: "github", re: /\bgh[pousr]_[0-9A-Za-z]{36,}\b/g },
+  // Generic long hex/alpha tokens (>=32 chars) in common contexts
+  { name: "token", re: /\b(token|secret|password|passwd|pwd|client[_-]?secret)\s*[:=]\s*\S+/gi },
+  // Connection strings with credentials
+  { name: "connstr", re: /\b(mongodb(\+srv)?|postgres(ql)?|mysql|redis|amqp|sqlserver):\/\/[^\s:]+:[^\s@]+@/gi },
+  // Private key blocks
+  { name: "pem", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g }
+];
+function redactLine(line, opts = {}) {
+  if (opts.enabled === false) return line;
+  let out = line;
+  for (const { name, re } of SECRET_PATTERNS) {
+    out = out.replace(re, (m) => {
+      const head = m.slice(0, Math.min(m.length, name.length + 4));
+      return `${head}\u2026[REDACTED]`;
+    });
+  }
+  return out;
+}
+function redactionCount(line) {
+  let n = 0;
+  for (const { re } of SECRET_PATTERNS) {
+    const m = line.match(re);
+    if (m) n += m.length;
+  }
+  return n;
+}
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+var LEVEL_RE = [
+  { level: "error", re: /\b(ERROR|FATAL|CRITICAL|EXCEPTION|UNCAUGHT)\b/i },
+  { level: "warn", re: /\b(WARN|WARNING)\b/i },
+  { level: "info", re: /\b(INFO|NOTICE)\b/i },
+  { level: "debug", re: /\b(DEBUG|TRACE)\b/i }
+];
+function classifyLevel(line) {
+  for (const { level, re } of LEVEL_RE) {
+    if (re.test(line)) return level;
+  }
+  if (/\b(error|fail|failed|failure|denied|reject)\b/i.test(line)) return "error";
+  if (/\b(warn)\b/i.test(line)) return "warn";
+  return "other";
+}
+function extractTimestamp(line) {
+  const m = line.match(/^\s*\[?(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)\]?/);
+  if (m) return m[1];
+  const trimmed = line.trimStart();
+  if (trimmed.startsWith("{")) {
+    try {
+      const obj = JSON.parse(line);
+      const ts = obj.ts ?? obj.time ?? obj.timestamp;
+      if (typeof ts === "string") return ts;
+      if (typeof ts === "number") return new Date(ts).toISOString();
+    } catch {
     }
+  }
+  return null;
+}
+function readLogLines(path, opts = {}) {
+  if (!existsSync6(path)) return [];
+  const raw = readFileSync5(path, "utf-8");
+  let lines = raw.split("\n").filter(Boolean);
+  const now = Date.now();
+  if (opts.sinceMs && opts.parseTimestamp) {
+    lines = lines.filter((l) => {
+      const ts = extractTimestamp(l);
+      if (ts === null) return true;
+      const t = Date.parse(ts);
+      return !isNaN(t) && now - t <= opts.sinceMs;
+    });
+  }
+  if (opts.redact === false) {
+    lines = lines.map(stripAnsi);
   } else {
-    console.error(`  ${pc9.dim("No tracked config found. Re-run manually:")} ${renderCommand(name)}`);
+    lines = lines.map((l) => stripAnsi(redactLine(l)));
+  }
+  if (opts.tail && opts.tail > 0 && lines.length > opts.tail) {
+    lines = lines.slice(-opts.tail);
+  }
+  return lines;
+}
+function parseDuration(input) {
+  const m = input.trim().match(/^(\d+)\s*(s|m|h|d)$/i);
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  const unit = m[2].toLowerCase();
+  const mul = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return n * mul;
+}
+
+// src/commands/inspect.ts
+var DEFAULT_TAIL = 40;
+var MAX_TAIL = 200;
+function readMetrics(pid) {
+  const m = {};
+  try {
+    const status = readFileSync6(`/proc/${pid}/status`, "utf-8");
+    const rssLine = status.split("\n").find((l) => l.startsWith("VmRSS:"));
+    if (rssLine) {
+      const kb = parseInt(rssLine.replace(/[^\d]/g, ""), 10);
+      if (!isNaN(kb)) m.rssMb = Math.round(kb / 1024 * 10) / 10;
+    }
+  } catch {
+  }
+  return m;
+}
+async function inspectCommand(args2) {
+  const target = args2[0];
+  if (!target || target.startsWith("--")) {
+    console.error(pc13.dim(`Usage: fennec inspect <name|pid> [--plain] [--tail N] [--since 10m]`));
+    process.exit(1);
+  }
+  const plain = args2.includes("--plain");
+  const tailIndex = args2.indexOf("--tail");
+  const tail = tailIndex !== -1 ? Math.min(parseInt(args2[tailIndex + 1], 10) || DEFAULT_TAIL, MAX_TAIL) : DEFAULT_TAIL;
+  const sinceIndex = args2.indexOf("--since");
+  const sinceMs = sinceIndex !== -1 ? parseDuration(args2[sinceIndex + 1]) : void 0;
+  if (sinceIndex !== -1 && sinceMs === void 0) {
+    console.error(pc13.red(`Invalid --since. Use e.g. 10m, 1h, 30s.`));
+    process.exit(1);
+  }
+  const tracked = readTracked();
+  const proc = tracked.find((t) => t.name === target || parseInt(target, 10) === t.pid && !isNaN(parseInt(target, 10)));
+  if (!proc) {
+    console.error(pc13.red(`No tracked app named "${target}".`));
+    process.exit(1);
+  }
+  const running = isTrackedRunning(proc);
+  const logPath = logFilePathFor(proc.name);
+  const lines = readLogLines(logPath, { tail: Math.max(tail, sinceMs ? MAX_TAIL : 0), sinceMs: sinceMs ?? void 0, redact: true, parseTimestamp: true });
+  const recent = lines.slice(-tail);
+  const errorLines = lines.filter((l) => classifyLevel(l) === "error").slice(-15);
+  const redactedLines = recent.reduce((acc, l) => acc + (redactionCount(stripAnsi(l)) > 0 ? 1 : 0), 0);
+  const metrics = running ? readMetrics(proc.pid) : {};
+  let portHealthy = null;
+  if (proc.port) {
+    try {
+      portHealthy = await checkPort(proc.port);
+    } catch {
+      portHealthy = false;
+    }
+  }
+  const startedAt = Date.parse(proc.startedAt);
+  const uptimeSec = running && !isNaN(startedAt) ? Math.floor((Date.now() - startedAt) / 1e3) : 0;
+  if (plain) {
+    const dot = running ? pc13.green("\u25CF") : pc13.red("\u25CB");
+    const portStr = proc.port ? ` :${proc.port}${portHealthy === false ? pc13.red(" (port down!)") : portHealthy ? pc13.green(" (up)") : ""}` : "";
+    console.error(`
+  ${symbols.fox} ${renderAppName(proc.name)}${portStr} ${dot} ${running ? pc13.green(`running PID ${proc.pid}`) : pc13.red("stopped")}`);
+    console.error(`  ${pc13.dim("uptime")} ${pc13.cyan(uptimeSec ? formatUptime(uptimeSec) : "\u2014")}  ${pc13.dim("rss")} ${pc13.cyan(metrics.rssMb ? `${metrics.rssMb}MB` : "\u2014")}  ${pc13.dim("errors(last)")} ${pc13.cyan(String(errorLines.length))}  ${pc13.dim("redacted")} ${pc13.cyan(String(redactedLines))}`);
+    if (errorLines.length) {
+      console.error(`
+  ${pc13.bold(pc13.red("Recent errors:"))}`);
+      for (const l of errorLines.slice(-8)) console.error(`  ${pc13.red(stripAnsi(l).slice(0, 300))}`);
+    }
+    console.error();
+    return;
+  }
+  const payload = {
+    name: proc.name,
+    running,
+    pid: running ? proc.pid ?? null : null,
+    port: proc.port ?? null,
+    portHealthy,
+    autoRestart: proc.autoRestart ?? false,
+    uptimeSec,
+    metrics,
+    logTail: recent,
+    errorCount: errorLines.length,
+    errors: errorLines,
+    redacted: true,
+    redactedLines,
+    note: "Secrets redacted by default. Bounded snapshot for AI observation."
+  };
+  process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+}
+
+// src/commands/dev.ts
+import pc14 from "picocolors";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve7, dirname as dirname5 } from "path";
+import "os";
+import yaml from "js-yaml";
+function loadConfig(path) {
+  if (!existsSync8(path)) {
+    console.error(renderError("Config not found", path));
+    process.exit(1);
+  }
+  try {
+    const raw = readFileSync7(path, "utf-8");
+    const parsed = yaml.load(raw);
+    return parsed ?? {};
+  } catch (err) {
+    console.error(renderError("Failed to parse config", String(err)));
+    process.exit(1);
+  }
+}
+function resolveCwd(baseDir, cwd) {
+  if (!cwd) return baseDir;
+  return resolve7(baseDir, cwd);
+}
+async function waitForPort(port, timeoutMs = 3e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      if (await checkPort(port)) return true;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+function configMatches(existing, desired) {
+  if (existing.command !== desired.command) return false;
+  if (JSON.stringify(existing.args ?? []) !== JSON.stringify(desired.args)) return false;
+  if (existing.cwd !== desired.cwd) return false;
+  if ((existing.port ?? null) !== (desired.port ?? null)) return false;
+  if (existing.logMode !== desired.logMode) return false;
+  if ((existing.autoRestart ?? true) !== desired.autoRestart) return false;
+  if ((existing.healthCheck ?? null) !== (desired.healthCheck ?? null)) return false;
+  if (JSON.stringify(existing.env ?? {}) !== JSON.stringify(desired.env)) return false;
+  return true;
+}
+async function startApp(app, baseDir) {
+  const cwd = resolveCwd(baseDir, app.cwd);
+  const cmdParts = [app.command, ...app.args ?? []];
+  const logFilePath = logFilePathFor(app.name);
+  const env = { ...app.env ?? {} };
+  const port = app.waitForPort ?? app.port;
+  const restart = app.restart ?? true;
+  const logMode = app.jsonl ? "jsonl" : "text";
+  const desired = {
+    command: cmdParts.join(" "),
+    args: cmdParts,
+    cwd,
+    port,
+    env,
+    logMode,
+    autoRestart: restart,
+    healthCheck: app.healthCheck
+  };
+  const existing = readTracked().find((t) => t.name === app.name);
+  if (existing && isTrackedRunning(existing) && configMatches(existing, desired)) {
+    return "skipped";
+  }
+  const wasRunning = !!(existing && isTrackedRunning(existing));
+  if (wasRunning) {
+    try {
+      process.kill(existing.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  if (port && !(existing && isTrackedRunning(existing))) {
+    const adopted = adoptExternalOnPort(port, app.name);
+    if (adopted) {
+      return "adopted";
+    }
+    if (await checkPort(port)) {
+      console.error(
+        `  ${pc14.yellow("\u26A0")} ${pc14.dim(`port :${port} already responding \u2014 ${app.name} may fail to bind (EADDRINUSE)`)}`
+      );
+    }
+  }
+  const child = spawnDaemon({
+    cmdParts,
+    name: app.name,
+    cwd,
+    logFilePath,
+    env: buildSpawnEnv(env),
+    logMode
+  });
+  addTracked({
+    name: app.name,
+    pid: child.pid ?? 0,
+    command: desired.command,
+    args: cmdParts,
+    port,
+    cwd,
+    env,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    autoRestart: restart,
+    logMode,
+    flapping: false,
+    healthCheck: app.healthCheck
+  });
+  return wasRunning ? "restarted" : "started";
+}
+async function devCommand(args2) {
+  const sub = args2[0] ?? "up";
+  const configIndex = args2.indexOf("--config");
+  const configPath = configIndex !== -1 ? resolve7(args2[configIndex + 1]) : resolve7(process.cwd(), "fennec.config.yaml");
+  if (sub === "down") {
+    return devDown();
+  }
+  if (sub === "status") {
+    return devStatus();
+  }
+  if (sub === "restart") {
+    return devRestart(args2.slice(1));
+  }
+  if (sub !== "up") {
+    console.error(renderError("Unknown sub-command", `"${sub}" \u2014 use: up | down | status | restart`));
+    process.exit(1);
+  }
+  const config = loadConfig(configPath);
+  const apps = config.apps ?? [];
+  if (apps.length === 0) {
+    console.error(renderError("No apps defined", `Add an "apps:" list to ${configPath}`));
+    process.exit(1);
+  }
+  const baseDir = dirname5(configPath);
+  const started = /* @__PURE__ */ new Set();
+  const ordered = topoOrder(apps);
+  const portOwner = /* @__PURE__ */ new Map();
+  for (const a of apps) {
+    const p = a.waitForPort ?? a.port;
+    if (p) {
+      const prev = portOwner.get(p);
+      if (prev) {
+        console.error(renderError("Port conflict", `apps "${prev}" and "${a.name}" both declare port :${p}`));
+        process.exit(1);
+      }
+      portOwner.set(p, a.name);
+    }
+  }
+  console.error(`
+  ${symbols.fox} ${pc14.bold("fennec dev up")} ${pc14.dim(`\u2014 ${apps.length} app(s) from ${configPath}`)}`);
+  ensureSupervisorRunning();
+  ensurePersistEnabled();
+  for (const app of ordered) {
+    for (const dep of app.dependsOn ?? []) {
+      const depApp = apps.find((a) => a.name === dep);
+      const port = depApp?.waitForPort ?? depApp?.port;
+      if (port) {
+        const sp = createSpinner(`Waiting for ${dep} :${port}...`);
+        const ok = await waitForPort(port);
+        sp.stop();
+        if (!ok) console.error(`  ${pc14.yellow("\u26A0")} ${pc14.dim(`${dep} :${port} not ready in time (continuing)`)}`);
+      }
+    }
+    const res = await startApp(app, baseDir);
+    const pid = readTracked().find((t) => t.name === app.name)?.pid ?? "?";
+    const tag = res === "skipped" ? pc14.dim("already running (skipped)") : res === "restarted" ? pc14.yellow(`restarted (PID ${pid})`) : res === "adopted" ? pc14.cyan(`adopted external process on :${app.port ?? app.waitForPort}`) : pc14.dim(`started (PID ${pid})`);
+    console.error(`  ${pc14.green("\u2713")} ${pc14.bold(app.name)} ${tag}`);
+  }
+  console.error(`
+  ${pc14.green("\u2713")} Stack up. Observe with ${pc14.cyan("fennec observe")} or ${pc14.cyan("fennec dev status")}.`);
+  console.error(`  ${pc14.dim("Apps auto-restart (supervisor) + survive reboot (persist).")}
+`);
+}
+function devDown() {
+  const tracked = readTracked().filter((t) => t.autoRestart);
+  if (tracked.length === 0) {
+    console.error(`
+  ${pc14.dim("No supervised apps to stop.")}
+`);
+    return;
+  }
+  console.error(`
+  ${symbols.fox} ${pc14.bold("fennec dev down")} ${pc14.dim(`\u2014 stopping ${tracked.length} app(s)`)}`);
+  for (const t of tracked) {
+    try {
+      if (isTrackedRunning(t)) process.kill(t.pid, "SIGTERM");
+    } catch {
+    }
+    t.autoRestart = false;
+    addTracked({ ...t, autoRestart: false });
+    console.error(`  ${pc14.red("\u25A0")} ${pc14.bold(t.name)}`);
+  }
+  console.error(`
+  ${pc14.green("\u2713")} Stack stopped (auto-restart disabled). Use ${pc14.cyan("fennec dev up")} to bring it back.
+`);
+}
+function devRestart(names) {
+  ensureSupervisorRunning();
+  ensurePersistEnabled();
+  const tracked = readTracked();
+  const targets = names.length ? tracked.filter((t) => names.includes(t.name)) : tracked.filter((t) => t.autoRestart);
+  const missing = names.filter((n) => !tracked.some((t) => t.name === n));
+  if (missing.length) {
+    console.error(renderError("Not tracked", `No such app(s): ${missing.join(", ")} \u2014 run "fennec dev status" to list tracked apps.`));
+  }
+  if (targets.length === 0) {
+    console.error(`
+  ${pc14.dim("Nothing to restart.")}
+`);
+    return;
+  }
+  console.error(`
+  ${symbols.fox} ${pc14.bold("fennec dev restart")} ${pc14.dim(`\u2014 ${targets.length} app(s)`)}`);
+  for (const t of targets) {
+    try {
+      const newPid = respawnTracked(t, "manual");
+      console.error(`  ${pc14.green("\u2713")} ${pc14.bold(t.name)} ${pc14.dim(`restarted (PID ${newPid})`)}`);
+    } catch (err) {
+      console.error(`  ${pc14.red("\u2717")} ${pc14.bold(t.name)} ${pc14.dim(`restart failed: ${String(err)}`)}`);
+    }
+  }
+  console.error();
+}
+function devStatus() {
+  const tracked = readTracked();
+  console.error(`
+  ${symbols.fox} ${pc14.bold("fennec dev status")}`);
+  if (tracked.length === 0) {
+    console.error(`  ${pc14.dim("Nothing tracked.")}
+`);
+    return;
+  }
+  for (const t of tracked) {
+    const running = isTrackedRunning(t);
+    const dot = running ? pc14.green("\u25CF") : pc14.red("\u25CB");
+    const state = running ? pc14.green(`running (PID ${t.pid})`) : pc14.red("stopped");
+    const portStr = t.port ? ` ${pc14.yellow(`:${t.port}`)}` : "";
+    const cause = t.restartCause ? pc14.dim(` \xB7 last-restart: ${t.restartCause}`) : "";
+    const flap = t.flapping ? pc14.red(" \xB7 \u26A0 flapping") : "";
+    console.error(`  ${dot} ${pc14.bold(t.name)}${portStr} ${pc14.dim("\u2014")} ${state}${cause}${flap}`);
   }
+  console.error();
+}
+function topoOrder(apps) {
+  const byName = new Map(apps.map((a) => [a.name, a]));
+  const visited = /* @__PURE__ */ new Set();
+  const out = [];
+  const visit = (app, stack) => {
+    if (visited.has(app.name)) return;
+    if (stack.has(app.name)) return;
+    stack.add(app.name);
+    for (const dep of app.dependsOn ?? []) {
+      const d = byName.get(dep);
+      if (d) visit(d, stack);
+    }
+    stack.delete(app.name);
+    visited.add(app.name);
+    out.push(app);
+  };
+  for (const app of apps) visit(app, /* @__PURE__ */ new Set());
+  return out;
 }
 
 // src/commands/log.ts
-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";
+import { existsSync as existsSync9, unlinkSync as unlinkSync3, statSync as statSync2, openSync as openSync3, fstatSync, readSync, closeSync as closeSync3 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import pc15 from "picocolors";
+var MAX_LOG_LINES = 500;
 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] [--clear] [--level error|warn|info|debug]"));
-    process.exit(1);
+  if (!target || target.startsWith("--")) {
+    listAvailableApps();
+    return;
   }
   const clearFlag = args2.includes("--clear");
+  const jsonFlag = args2.includes("--json");
+  const noRedact = args2.includes("--no-redact");
   const linesIndex = args2.indexOf("--lines");
-  const lineCount = linesIndex !== -1 ? parseInt(args2[linesIndex + 1], 10) : 30;
+  const lineCount = linesIndex !== -1 ? Math.min(parseInt(args2[linesIndex + 1], 10), MAX_LOG_LINES) : 30;
   const followFlag = args2.includes("-f") || args2.includes("--follow");
   const levelFilter = args2.includes("--level") ? args2[args2.indexOf("--level") + 1]?.toLowerCase() : void 0;
+  const sinceIndex = args2.indexOf("--since");
+  const sinceMs = sinceIndex !== -1 ? parseDuration(args2[sinceIndex + 1]) : void 0;
+  if (sinceIndex !== -1 && sinceMs === void 0) {
+    console.error(renderError("Invalid --since", `Use a duration like 10m, 1h, 30s, 2d`));
+    process.exit(1);
+  }
   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);
   }
+  const redact = !noRedact;
   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 = resolve6(homedir5(), ".fennec", "logs", `${trackedMatch.name}.log`);
+    logFilePath = logFilePathFor(trackedMatch.name);
   } else {
     const pid = parseInt(target, 10);
     if (!isNaN(pid) && String(pid) === target) {
       const procPath = `/proc/${pid}/fd/1`;
-      if (existsSync4(procPath)) logFilePath = procPath;
+      if (existsSync9(procPath)) logFilePath = procPath;
     }
   }
   if (clearFlag) {
-    if (!logFilePath || !existsSync4(logFilePath)) {
+    if (!logFilePath || !existsSync9(logFilePath)) {
       console.error(`
-  ${pc10.yellow("\u26A0")} ${pc10.dim("No log file found for")} ${pc10.bold(displayName)}
+  ${pc15.yellow("\u26A0")} ${pc15.dim("No log file found for")} ${pc15.bold(displayName)}
 `);
       process.exit(0);
     }
     try {
-      unlinkSync(logFilePath);
+      unlinkSync3(logFilePath);
       console.error(`
-  ${pc10.green("\u2713")} ${pc10.bold("Log cleared")} ${pc10.dim(`\u2014 ${logFilePath}`)}
+  ${pc15.green("\u2713")} ${pc15.bold("Log cleared")} ${pc15.dim(`\u2014 ${logFilePath}`)}
 `);
     } catch (err) {
       console.error(renderError("Failed to clear log", String(err)));
@@ -3590,18 +5250,75 @@ async function logCommand(args2) {
     }
     return;
   }
+  if (jsonFlag) {
+    let logLines = [];
+    if (logFilePath && existsSync9(logFilePath)) {
+      logLines = readLogLines(logFilePath, {
+        tail: Math.max(lineCount, sinceMs ? MAX_LOG_LINES : 0),
+        sinceMs: sinceMs ?? void 0,
+        redact,
+        parseTimestamp: true
+      });
+    } else {
+      const pid = trackedMatch?.pid ?? parseInt(target, 10);
+      if (!isNaN(pid)) {
+        try {
+          const output = execSync2(`journalctl --no-pager -n ${Math.max(lineCount, 500)} _PID=${pid} 2>/dev/null || echo ""`, { encoding: "utf-8", timeout: 3e3 });
+          logLines = output.trim().split("\n").filter(Boolean).map((l) => redact ? redactLine(stripAnsi(l)) : stripAnsi(l));
+        } catch {
+          logLines = ["(no logs available)"];
+        }
+      } else {
+        logLines = ["(no logs available)"];
+      }
+    }
+    if (levelFilter) {
+      const levelRegex = new RegExp(`\\b(${levelFilter.toUpperCase()})\\b`, "i");
+      logLines = logLines.filter((line) => levelRegex.test(line));
+    }
+    const running = trackedMatch ? isTrackedRunning(trackedMatch) : false;
+    const sliced = logLines.slice(-lineCount);
+    const redactedHits = sliced.reduce((acc, l) => acc + (redactionCount(stripAnsi(l)) > 0 ? 1 : 0), 0);
+    const payload = {
+      app: displayName,
+      running,
+      pid: trackedMatch?.pid != null ? trackedMatch.pid : null,
+      port: trackedMatch?.port != null ? trackedMatch.port : null,
+      lines: sliced,
+      count: sliced.length,
+      redacted: redact,
+      redactedLines: redactedHits,
+      note: "Secrets are redacted by default; use --no-redact to disable."
+    };
+    process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+    return;
+  }
+  if (trackedMatch) {
+    const running = isTrackedRunning(trackedMatch);
+    const statusStr = running ? pc15.green(`\u25CF running (PID ${trackedMatch.pid})`) : pc15.red("\u25CB stopped");
+    const portStr = trackedMatch.port ? ` ${pc15.yellow(`:${trackedMatch.port}`)}` : "";
+    console.error(`
+  ${symbols.fox} ${renderAppName(displayName)}${portStr} \u2014 ${statusStr}`);
+    if (!running) {
+      console.error(`  ${pc15.dim("This app is not running. Showing last captured logs.")} ${pc15.cyan(`fennec spawn ${displayName}`)} ${pc15.dim("to restart.")}`);
+    }
+  }
   const spinner = createSpinner(`Reading logs for ${displayName}...`);
   try {
     let logLines = [];
-    if (logFilePath && existsSync4(logFilePath)) {
-      const content = readFileSync3(logFilePath, "utf-8");
-      logLines = content.split("\n").filter(Boolean);
+    if (logFilePath && existsSync9(logFilePath)) {
+      logLines = readLogLines(logFilePath, {
+        tail: Math.max(lineCount, sinceMs ? MAX_LOG_LINES : 0),
+        sinceMs: sinceMs ?? void 0,
+        redact,
+        parseTimestamp: true
+      });
     } else {
       const pid = trackedMatch?.pid ?? parseInt(target, 10);
       if (!isNaN(pid)) {
         try {
-          const output = execSync2(`journalctl --no-pager -n ${lineCount} _PID=${pid} 2>/dev/null || echo ""`, { encoding: "utf-8", timeout: 3e3 });
-          logLines = output.trim().split("\n").filter(Boolean);
+          const output = execSync2(`journalctl --no-pager -n ${Math.max(lineCount, 500)} _PID=${pid} 2>/dev/null || echo ""`, { encoding: "utf-8", timeout: 3e3 });
+          logLines = output.trim().split("\n").filter(Boolean).map((l) => redact ? redactLine(stripAnsi(l)) : stripAnsi(l));
         } catch {
           logLines = ["(no logs available)"];
         }
@@ -3616,48 +5333,22 @@ async function logCommand(args2) {
     spinner.stop();
     process.stdout.write("\r\x1B[K");
     console.error(`
-  ${symbols.fox} ${pc10.bold("Logs")} ${renderAppName(displayName)} ${pc10.dim(`(last ${logLines.length} line${logLines.length !== 1 ? "s" : ""})`)}`);
+  ${symbols.fox} ${pc15.bold("Logs")} ${renderAppName(displayName)} ${pc15.dim(`(last ${logLines.length} line${logLines.length !== 1 ? "s" : ""})${redact ? pc15.dim(" \xB7 secrets redacted") : ""})`)}`);
     const sliced = logLines.slice(-lineCount);
     for (const line of sliced) {
       const display = line.length > 300 ? line.slice(0, 300) + "\u2026" : line;
-      const prefix = followFlag ? `${timestamp()} ` : "";
       if (line.toLowerCase().includes("error") || line.toLowerCase().includes("fail") || line.toLowerCase().includes("fatal")) {
-        console.error(`  ${pc10.red(prefix + display)}`);
+        console.error(`  ${pc15.red(display)}`);
       } else if (line.toLowerCase().includes("warn")) {
-        console.error(`  ${pc10.yellow(prefix + display)}`);
+        console.error(`  ${pc15.yellow(display)}`);
       } else if (line.toLowerCase().includes("info") || line.includes("[")) {
-        console.error(`  ${pc10.cyan(prefix + display)}`);
+        console.error(`  ${pc15.cyan(display)}`);
       } else {
-        console.error(`  ${prefix}${display}`);
+        console.error(`  ${display}`);
       }
     }
     if (followFlag && logFilePath) {
-      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 = spawn4("tail", tailArgs.concat([logFilePath]), { stdio: "inherit" });
-        await new Promise((resolve12) => {
-          tail.on("exit", () => resolve12());
-          process.once("SIGINT", () => {
-            tail.kill("SIGTERM");
-            resolve12();
-          });
-        });
-      }
+      await followLog(logFilePath, { redact, levelFilter, json: jsonFlag });
     }
     console.error();
   } catch (error) {
@@ -3665,10 +5356,97 @@ async function logCommand(args2) {
     console.error(renderError("Log read failed", String(error)));
   }
 }
+async function followLog(logFilePath, opts) {
+  let lastSize = 0;
+  try {
+    lastSize = statSync2(logFilePath).size;
+  } catch {
+  }
+  console.error(`
+  ${pc15.dim("Following... (Ctrl+C to stop)")}
+`);
+  const levelRe = opts.levelFilter ? new RegExp(`\\b(${opts.levelFilter.toUpperCase()})\\b`, "i") : null;
+  const emit = (raw) => {
+    const line = opts.redact ? redactLine(raw) : raw;
+    if (levelRe && !levelRe.test(line)) return;
+    if (opts.json) {
+      try {
+        process.stdout.write(JSON.stringify(JSON.parse(line)) + "\n");
+        return;
+      } catch {
+      }
+    }
+    const display = line.length > 300 ? line.slice(0, 300) + "\u2026" : line;
+    if (line.toLowerCase().includes("error") || line.toLowerCase().includes("fail") || line.toLowerCase().includes("fatal")) {
+      console.error(`  ${pc15.red(display)}`);
+    } else if (line.toLowerCase().includes("warn")) {
+      console.error(`  ${pc15.yellow(display)}`);
+    } else if (line.toLowerCase().includes("info") || line.includes("[")) {
+      console.error(`  ${pc15.cyan(display)}`);
+    } else {
+      console.error(`  ${display}`);
+    }
+  };
+  const timer = setInterval(() => {
+    let fd;
+    try {
+      fd = openSync3(logFilePath, "r");
+    } catch {
+      return;
+    }
+    try {
+      const size = fstatSync(fd).size;
+      if (size < lastSize) lastSize = 0;
+      if (size > lastSize) {
+        const buf = Buffer.alloc(size - lastSize);
+        readSync(fd, buf, 0, buf.length, lastSize);
+        lastSize = size;
+        for (const l of buf.toString("utf8").split("\n")) {
+          if (l.length) emit(l);
+        }
+      }
+    } finally {
+      closeSync3(fd);
+    }
+  }, 400);
+  await new Promise((resolve13) => {
+    const stop = () => {
+      clearInterval(timer);
+      resolve13();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+}
+function listAvailableApps() {
+  const tracked = readTracked();
+  if (tracked.length === 0) {
+    console.error(`
+  ${symbols.fox} ${pc15.bold("No tracked apps to show logs for.")}`);
+    console.error(`  ${pc15.dim("Start one with:")} ${pc15.cyan("fennec start <command> --name <name>")}
+`);
+    return;
+  }
+  console.error(`
+  ${symbols.fox} ${pc15.bold("Logs")} ${pc15.dim("\u2014 pick an app:")}
+`);
+  for (const t of tracked) {
+    const running = isTrackedRunning(t);
+    const dot = running ? pc15.green("\u25CF") : pc15.red("\u25CB");
+    const state = running ? pc15.green(`running (PID ${t.pid})`) : pc15.red("stopped");
+    const portStr = t.port ? ` ${pc15.yellow(`:${t.port}`)}` : "";
+    console.error(`  ${dot} ${pc15.bold(t.name)}${portStr} ${pc15.dim("\u2014")} ${state}`);
+    console.error(`      ${pc15.cyan(`fennec log ${t.name}`)} ${pc15.dim("\xB7")} ${pc15.cyan(`fennec log ${t.name} -f`)}`);
+  }
+  console.error(`
+  ${pc15.dim("Flags:")} ${pc15.cyan("-f")} ${pc15.dim("follow")} ${pc15.dim("\xB7")} ${pc15.cyan("--lines N")} ${pc15.dim("\xB7")} ${pc15.cyan("--since 10m|1h")} ${pc15.dim("\xB7")} ${pc15.cyan("--level error|warn|info|debug")} ${pc15.dim("\xB7")} ${pc15.cyan("--json")} ${pc15.dim("(AI)")} ${pc15.dim("\xB7")} ${pc15.cyan("--no-redact")} ${pc15.dim("\xB7")} ${pc15.cyan("--clear")}`);
+  console.error(`  ${pc15.dim("AI mode:")} ${pc15.cyan("fennec log <app> --json --since 10m")} ${pc15.dim("\u2014 bounded, redacted, machine-readable. Secrets are redacted by default.")}
+`);
+}
 
 // src/commands/attach.ts
 import { PortDetector as PortDetector3 } from "@plumpslabs/fennec-core";
-import pc11 from "picocolors";
+import pc16 from "picocolors";
 async function attachCommand(args2) {
   const port = parseInt(args2[0], 10);
   if (isNaN(port)) {
@@ -3686,7 +5464,7 @@ async function attachCommand(args2) {
       spinner.succeed(`Attached to :${port}`);
       console.error(`  ${renderKV("Name", renderAppName(name))}`);
       console.error(`  ${renderKV("PID", String(info.pid))}`);
-      console.error(`  ${renderKV("Command", info.command || pc11.dim("unknown"))}`);
+      console.error(`  ${renderKV("Command", info.command || pc16.dim("unknown"))}`);
     } else {
       spinner.fail(`No process found on port ${port}`);
       process.exit(1);
@@ -3700,35 +5478,35 @@ async function attachCommand(args2) {
 
 // src/commands/sessions.ts
 import { SessionStore } from "@plumpslabs/fennec-core";
-import pc12 from "picocolors";
+import pc17 from "picocolors";
 async function sessionsCommand() {
   const store = new SessionStore("./.fennec/sessions");
   const sessions = store.list();
   if (sessions.length === 0) {
     console.error(`
-  ${pc12.dim("No saved sessions found.")}
+  ${pc17.dim("No saved sessions found.")}
 `);
     return;
   }
   const columns = [
-    { key: "name", label: "Name", format: (v) => pc12.bold(String(v)) },
+    { key: "name", label: "Name", format: (v) => pc17.bold(String(v)) },
     { key: "origin", label: "Origin" },
-    { key: "savedAt", label: "Saved", format: (v) => pc12.dim(String(v)) }
+    { key: "savedAt", label: "Saved", format: (v) => pc17.dim(String(v)) }
   ];
   const rows = sessions.map((s) => ({ name: s.name, origin: s.origin, savedAt: new Date(s.savedAt).toLocaleString() }));
   console.error(`
-  ${symbols.fox} ${pc12.bold("Saved Sessions")}
+  ${symbols.fox} ${pc17.bold("Saved Sessions")}
 `);
   console.error(renderTable(columns, rows));
-  console.error(`  ${pc12.dim(`${sessions.length} session(s)`)}
+  console.error(`  ${pc17.dim(`${sessions.length} session(s)`)}
 `);
 }
 
 // src/commands/setup.ts
-import pc13 from "picocolors";
+import pc18 from "picocolors";
 async function setupCommand() {
   console.error(`
-  ${symbols.fox} ${pc13.bold("Fennec Setup")}
+  ${symbols.fox} ${pc18.bold("Fennec Setup")}
 `);
   const mcpClient = await selectPrompt("Which MCP client are you using?", [
     { value: "claude", label: "Claude Desktop", description: "Anthropic's AI desktop app" },
@@ -3737,12 +5515,12 @@ async function setupCommand() {
     { value: "other", label: "Other MCP client", description: "Any MCP-compatible client" }
   ]);
   if (!mcpClient) {
-    console.error(`  ${pc13.dim("Setup cancelled.")}
+    console.error(`  ${pc18.dim("Setup cancelled.")}
 `);
     return;
   }
   console.error(`
-  ${pc13.green("\u2713")} Selected: ${pc13.bold(mcpClient)}
+  ${pc18.green("\u2713")} Selected: ${pc18.bold(mcpClient)}
 `);
   const configSnippet = `{
   "mcpServers": {
@@ -3752,24 +5530,24 @@ async function setupCommand() {
     }
   }
 }`;
-  console.error(`  ${pc13.bold("Add this to your MCP client config:")}
+  console.error(`  ${pc18.bold("Add this to your MCP client config:")}
 `);
-  console.error(`  ${pc13.dim("```")}`);
+  console.error(`  ${pc18.dim("```")}`);
   console.error(configSnippet.split("\n").map((l) => `  ${l}`).join("\n"));
-  console.error(`  ${pc13.dim("```")}
+  console.error(`  ${pc18.dim("```")}
 `);
-  console.error(`  ${renderSuccess("Setup complete!")} ${pc13.dim("Run")} ${renderCommand("fennec start")} ${pc13.dim("to begin.")}
+  console.error(`  ${renderSuccess("Setup complete!")} ${pc18.dim("Run")} ${renderCommand("fennec start")} ${pc18.dim("to begin.")}
 `);
 }
 
 // src/commands/management.ts
-import { existsSync as existsSync5, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve7 } from "path";
+import { existsSync as existsSync10, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve8 } from "path";
 import { execSync as execSync3 } from "child_process";
-import pc14 from "picocolors";
+import pc19 from "picocolors";
 async function installBrowsersCommand() {
   console.error(`
-  ${pc14.bold("Installing Browser Engines")}
+  ${pc19.bold("Installing Browser Engines")}
 `);
   const spinner = createSpinner("Installing Chromium...");
   try {
@@ -3777,21 +5555,21 @@ async function installBrowsersCommand() {
     spinner.succeed("Chromium installed successfully");
   } catch {
     spinner.fail("Failed to install Chromium");
-    console.error(`  ${pc14.yellow("\u2192")} Try running: ${renderCommand("npx playwright install chromium")}`);
+    console.error(`  ${pc19.yellow("\u2192")} Try running: ${renderCommand("npx playwright install chromium")}`);
   }
   console.error(`
-  ${pc14.green("\u2713")} Browser installation complete.
+  ${pc19.green("\u2713")} Browser installation complete.
 `);
 }
 async function initCommand() {
   console.error(`
-  ${pc14.bold("Initialize Fennec Configuration")}
+  ${pc19.bold("Initialize Fennec Configuration")}
 `);
-  const configFile = resolve7("./fennec.config.yaml");
-  if (existsSync5(configFile)) {
-    const overwrite = await confirmPrompt(`${pc14.yellow("fennec.config.yaml")} already exists. Overwrite?`, false);
+  const configFile = resolve8("./fennec.config.yaml");
+  if (existsSync10(configFile)) {
+    const overwrite = await confirmPrompt(`${pc19.yellow("fennec.config.yaml")} already exists. Overwrite?`, false);
     if (!overwrite) {
-      console.error(`  ${pc14.dim("Cancelled.")}
+      console.error(`  ${pc19.dim("Cancelled.")}
 `);
       return;
     }
@@ -3870,22 +5648,22 @@ logging:
   format: pretty
   file: null
 `;
-  writeFileSync2(configFile, config, "utf-8");
-  spinner.succeed(`Configuration written to ${pc14.bold(configFile)}`);
+  writeFileSync4(configFile, config, "utf-8");
+  spinner.succeed(`Configuration written to ${pc19.bold(configFile)}`);
   console.error(`
-  ${pc14.dim("Edit the file to customize Fennec behavior.")}
+  ${pc19.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 { existsSync as existsSync11, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
 import { execSync as execSync4 } from "child_process";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 import { homedir as homedir6 } from "os";
-import pc15 from "picocolors";
+import pc20 from "picocolors";
 async function healthCommand() {
   printBanner();
-  console.error(`  ${pc15.bold("Fennec Health Check")}
+  console.error(`  ${pc20.bold("Fennec Health Check")}
 `);
   let adbStatus = "unknown";
   try {
@@ -3895,20 +5673,20 @@ async function healthCommand() {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const version = result.split("\n")[0]?.trim() ?? "installed";
-    adbStatus = pc15.green(version);
+    adbStatus = pc20.green(version);
   } catch {
-    adbStatus = pc15.dim("not found") + " (optional)";
+    adbStatus = pc20.dim("not found") + " (optional)";
   }
   const tracked = readTracked();
   const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
-  const logDir = resolve8(homedir6(), ".fennec", "logs");
+  const logDir = resolve9(homedir6(), ".fennec", "logs");
   let logSize = "0 B";
   try {
-    if (existsSync6(logDir)) {
+    if (existsSync11(logDir)) {
       const files = readdirSync2(logDir);
       let totalBytes = 0;
       for (const f of files) {
-        const fStat = statSync2(resolve8(logDir, f));
+        const fStat = statSync3(resolve9(logDir, f));
         totalBytes += fStat.size;
       }
       logSize = totalBytes > 1024 * 1024 ? `${(totalBytes / (1024 * 1024)).toFixed(1)} MB` : `${(totalBytes / 1024).toFixed(1)} KB`;
@@ -3921,7 +5699,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} ${pc15.bold("System")}
+  console.error(`  ${symbols.fox} ${pc20.bold("System")}
 `);
   console.error(`  ${renderKV("Node.js", process.version)}`);
   console.error(`  ${renderKV("Platform", `${process.platform} ${process.arch}`)}`);
@@ -3929,7 +5707,7 @@ async function healthCommand() {
   console.error(`  ${renderKV("ADB", adbStatus)}`);
   console.error(`  ${renderKV("PID", String(process.pid))}`);
   console.error();
-  console.error(`  ${symbols.fox} ${pc15.bold("Processes")}
+  console.error(`  ${symbols.fox} ${pc20.bold("Processes")}
 `);
   console.error(`  ${renderKV("Tracked", String(tracked.length))}`);
   console.error(`  ${renderKV("Running", String(runningCount))}`);
@@ -3937,55 +5715,55 @@ async function healthCommand() {
   console.error();
   const allHealthy = runningCount === tracked.length || tracked.length === 0;
   if (allHealthy) {
-    console.error(`  ${pc15.green("\u2713")} ${pc15.bold("All systems healthy")}
+    console.error(`  ${pc20.green("\u2713")} ${pc20.bold("All systems healthy")}
 `);
   } else {
     const stopped = tracked.length - runningCount;
-    console.error(`  ${pc15.yellow("\u26A0")} ${pc15.bold(`${stopped} process(es) stopped`)}  ${pc15.dim("fennec ps")}
+    console.error(`  ${pc20.yellow("\u26A0")} ${pc20.bold(`${stopped} process(es) stopped`)}  ${pc20.dim("fennec ps")}
 `);
   }
 }
 
 // src/commands/cleanup.ts
-import pc16 from "picocolors";
+import pc21 from "picocolors";
 async function cleanupCommand() {
   const tracked = readTracked();
   if (tracked.length === 0) {
     console.error(`
-  ${pc16.dim("No tracked processes to clean up.")}
+  ${pc21.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.")}
+  ${pc21.green("\u2713")} ${pc21.bold("All clean")} ${pc21.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`)}
+  ${pc21.yellow("\u26A0")} ${pc21.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(`  ${pc21.dim("\xB7")} ${pc21.bold(entry.name)} ${pc21.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")}
+    console.error(`  ${pc21.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)`)}
+  ${pc21.green("\u2713")} ${pc21.bold(`Removed ${toRemove.length} entr${toRemove.length > 1 ? "ies" : "y"}`)} ${pc21.dim(`(${remaining.length} remaining)`)}
 `);
 }
 
 // src/commands/info.ts
-import pc17 from "picocolors";
-import { resolve as resolve9 } from "path";
+import pc22 from "picocolors";
+import { resolve as resolve10 } from "path";
 import { homedir as homedir7 } from "os";
 async function infoCommand(args2) {
   const name = args2[0];
@@ -4000,33 +5778,33 @@ async function infoCommand(args2) {
     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 statusIcon = running ? pc22.green("\u25CF") : pc22.red("\u25CB");
+  const statusText = running ? pc22.green("running") : pc22.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`);
+  const logPath = resolve10(homedir7(), ".fennec", "logs", `${match.name}.log`);
   console.error(`
-  ${symbols.fox} ${pc17.bold(match.name)} ${pc17.dim("\u2014 Process Info")}
+  ${symbols.fox} ${pc22.bold(match.name)} ${pc22.dim("\u2014 Process Info")}
 `);
-  console.error(`  ${renderKVColor("Name", match.name, pc17.bold)}`);
+  console.error(`  ${renderKVColor("Name", match.name, pc22.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)"))}`);
+  console.error(`  ${renderKVColor("Command", match.command || pc22.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}`)}`);
+  ${pc22.dim("Re-spawn with:")} ${pc22.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 pc23 from "picocolors";
+import { existsSync as existsSync12, renameSync as renameSync2 } from "fs";
+import { resolve as resolve11 } from "path";
 import { homedir as homedir8 } from "os";
 async function renameCommand(args2) {
   const [oldName, newName] = args2;
@@ -4036,7 +5814,7 @@ async function renameCommand(args2) {
   }
   if (oldName === newName) {
     console.error(`
-  ${pc18.yellow("\u26A0")} ${pc18.dim("Old and new names are the same.")}
+  ${pc23.yellow("\u26A0")} ${pc23.dim("Old and new names are the same.")}
 `);
     process.exit(0);
   }
@@ -4051,25 +5829,25 @@ async function renameCommand(args2) {
     process.exit(1);
   }
   console.error(`
-  ${symbols.fox} ${pc18.bold("Rename Process")}
+  ${symbols.fox} ${pc23.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(`  ${pc23.yellow("\u26A0")} ${pc23.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);
+  const confirmed = await confirmPrompt(`Rename ${pc23.bold(oldName)} ${pc23.dim("\u2192")} ${pc23.bold(newName)}?`, true);
   if (!confirmed) {
-    console.error(`  ${pc18.dim("Cancelled")}
+    console.error(`  ${pc23.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)) {
+  const logDir = resolve11(homedir8(), ".fennec", "logs");
+  const oldLog = resolve11(logDir, `${oldName}.log`);
+  const newLog = resolve11(logDir, `${newName}.log`);
+  if (existsSync12(oldLog) && !existsSync12(newLog)) {
     try {
       renameSync2(oldLog, newLog);
     } catch {
@@ -4077,14 +5855,14 @@ async function renameCommand(args2) {
   }
   match.name = newName;
   saveTracked(tracked);
-  spinner.succeed(`${pc18.bold(oldName)} ${pc18.dim("\u2192")} ${pc18.bold(newName)}`);
+  spinner.succeed(`${pc23.bold(oldName)} ${pc23.dim("\u2192")} ${pc23.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";
+import pc24 from "picocolors";
+import { existsSync as existsSync13, writeFileSync as writeFileSync5, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve12 } from "path";
 async function exportCommand(args2) {
   const tracked = readTracked();
   const fileIndex = args2.indexOf("--file");
@@ -4095,16 +5873,16 @@ async function exportCommand(args2) {
   }
   if (tracked.length === 0) {
     console.error(`
-  ${pc19.dim("No tracked processes to export.")}
+  ${pc24.dim("No tracked processes to export.")}
 `);
     return;
   }
   const json = JSON.stringify(tracked, null, 2);
   if (filePath) {
     try {
-      writeFileSync3(resolve11(filePath), json, "utf-8");
+      writeFileSync5(resolve12(filePath), json, "utf-8");
       console.error(`
-  ${pc19.green("\u2713")} ${pc19.bold(`Exported ${tracked.length} process(es)`)} ${pc19.dim(`\u2192 ${filePath}`)}
+  ${pc24.green("\u2713")} ${pc24.bold(`Exported ${tracked.length} process(es)`)} ${pc24.dim(`\u2192 ${filePath}`)}
 `);
     } catch (err) {
       console.error(renderError("Export failed", String(err)));
@@ -4120,14 +5898,14 @@ async function importCommand(args2) {
     console.error(renderError("Missing file", "Usage: fennec import <file>"));
     process.exit(1);
   }
-  const resolvedPath = resolve11(filePath);
-  if (!existsSync8(resolvedPath)) {
+  const resolvedPath = resolve12(filePath);
+  if (!existsSync13(resolvedPath)) {
     console.error(renderError("File not found", `"${filePath}" does not exist.`));
     process.exit(1);
   }
   let imported;
   try {
-    imported = JSON.parse(readFileSync4(resolvedPath, "utf-8"));
+    imported = JSON.parse(readFileSync9(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);
@@ -4138,20 +5916,20 @@ async function importCommand(args2) {
   }
   const existing = readTracked();
   console.error(`
-  ${symbols.fox} ${pc19.bold("Import Processes")}
+  ${symbols.fox} ${pc24.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:")}`);
+  ${pc24.bold("Processes to import:")}`);
   for (const p of imported) {
-    console.error(`  ${pc19.green("+")} ${pc19.bold(p.name)} ${pc19.dim(`(${p.command})`)}`);
+    console.error(`  ${pc24.green("+")} ${pc24.bold(p.name)} ${pc24.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")}
+    console.error(`  ${pc24.dim("Cancelled")}
 `);
     return;
   }
@@ -4165,13 +5943,18 @@ async function importCommand(args2) {
     }
   }
   saveTracked(merged);
-  console.error(`  ${pc19.green("\u2713")} ${pc19.bold(`Imported ${imported.length} process(es)`)} ${pc19.dim(`(${merged.length} total)`)}
+  console.error(`  ${pc24.green("\u2713")} ${pc24.bold(`Imported ${imported.length} process(es)`)} ${pc24.dim(`(${merged.length} total)`)}
 `);
 }
 
 // src/index.ts
 var [, , command, ...args] = process.argv;
 async function main() {
+  if (command && command !== "help" && command !== "--help" && command !== "-h" && (args.includes("--help") || args.includes("-h"))) {
+    printBanner();
+    showCommandHelp(command);
+    return;
+  }
   if (!command || command === "start") {
     if (args.length === 0 || args[0]?.startsWith("--")) {
       await startServer(args);
@@ -4186,7 +5969,7 @@ async function main() {
   } else if (command === "status") {
     printBanner();
     await statusCommand(args);
-  } else if (command === "log") {
+  } else if (command === "log" || command === "logs") {
     await logCommand(args);
   } else if (command === "spawn") {
     await spawnCommand(args);
@@ -4196,6 +5979,21 @@ async function main() {
     await killCommand(args);
   } else if (command === "restart") {
     await restartCommand(args);
+  } else if (command === "adopt") {
+    adoptCommand(args);
+  } else if (command === "supervisor") {
+    printBanner();
+    await supervisorCommand(args);
+  } else if (command === "__supervisor") {
+    await runSupervisor();
+  } else if (command === "persist") {
+    printBanner();
+    await persistCommand(args);
+  } else if (command === "inspect") {
+    await inspectCommand(args);
+  } else if (command === "dev") {
+    printBanner();
+    await devCommand(args);
   } else if (command === "info") {
     printBanner();
     await infoCommand(args);
@@ -4234,7 +6032,11 @@ async function main() {
     printBanner();
   } else if (command === "help" || command === "--help" || command === "-h") {
     printBanner();
-    showHelp();
+    if (args[0] && !args[0].startsWith("-")) {
+      showCommandHelp(args[0]);
+    } else {
+      showHelp();
+    }
   } else {
     console.error(renderError(`Unknown command: ${command}`, "Run 'fennec help' for usage information"));
     process.exit(1);