@plumpslabs/fennec-cli 1.14.2 → 1.14.4

package/dist/index.js

@@ -1922,7 +1922,7 @@ function renderTable(columns, rows, options) {
       "top-mid": "\u252C",
       "top-left": "\u250C",
       "top-right": "\u2510",
-      "bottom": "\u2500",
+      bottom: "\u2500",
       "bottom-mid": "\u2534",
       "bottom-left": "\u2514",
       "bottom-right": "\u2518",
@@ -1961,6 +1961,14 @@ function renderKV(key, value, options) {
 function renderKVColor(key, value, color = pc.bold) {
   return `  ${pc.dim(key + ":")} ${color(value)}`;
 }
+function renderSection(title, content) {
+  const line = pc.dim("\u2500".repeat(40));
+  return `
+  ${pc.bold(title)}
+  ${line}
+${content}
+`;
+}
 function createSpinner(text) {
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   let i = 0;
@@ -2013,10 +2021,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((resolve13) => {
+  const answer = await new Promise((resolve12) => {
     rl.question(`  ${pc.bold("Enter number")} ${pc.dim("(0-" + options.length + ")")}: `, (ans) => {
       rl.close();
-      resolve13(ans.trim());
+      resolve12(ans.trim());
     });
   });
   const num = parseInt(answer, 10);
@@ -2031,11 +2039,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((resolve13) => {
+  const answer = await new Promise((resolve12) => {
     rl.question(`
   ${message} ${pc.dim("(" + hint + ")")}: `, (ans) => {
       rl.close();
-      resolve13(ans.trim().toLowerCase());
+      resolve12(ans.trim().toLowerCase());
     });
   });
   if (!answer) return defaultValue;
@@ -2091,7 +2099,7 @@ function hexColor(color) {
 }
 var fennecOrange2 = hexColor("#FF6432");
 var fennecGold = hexColor("#FFB347");
-var VERSION = "1.14.2";
+var VERSION = "1.14.3";
 var cachedBanner = null;
 var cachedCompact = null;
 function generateBanner() {
@@ -2158,11 +2166,15 @@ var COMMANDS = {
       ["--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)"]
+      [
+        "--restart",
+        "Auto-restart if it crashes or its port stops listening (detached supervisor, survives terminal close)"
+      ],
+      ["--group <group>", "Logical group/namespace for bulk ops (kill/spawn/stop --group <group>)"]
     ],
     examples: [
       'start "npm run dev" --name web --port 3000',
-      "start node server.js --name api --cwd ./backend --restart"
+      "start node server.js --name api --cwd ./backend --restart --group backend"
     ]
   },
   run: {
@@ -2175,18 +2187,20 @@ var COMMANDS = {
       ["--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"]
+      ["--restart", "Auto-restart if it crashes or its port stops listening"],
+      ["--group <group>", "Logical group for bulk ops"]
     ],
-    examples: ["run npm start --name web --port 8080"]
+    examples: ["run npm start --name web --port 8080 --group frontend"]
   },
   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).",
+    description: "Shows tracked apps and whether they are genuinely running (PID + command identity are verified to avoid false positives from PID reuse). Includes a cross-platform MEM column (resident RSS) so you can spot leaks from long-lived apps.",
     options: [
       ["--system, -a, --all", "Show all system processes instead of tracked apps"],
       ["--name <name>", "Filter system processes by name"],
+      ["--group <g>, -g <g>", "Show only tracked apps in group <g>"],
       ["--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)"]
@@ -2219,37 +2233,51 @@ var COMMANDS = {
   },
   spawn: {
     name: "spawn",
-    usage: "spawn [name] [--all]",
+    usage: "spawn [name] [name...] [--all] [--group <g>]",
     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"]
+    options: [
+      ["--all, -a", "Re-spawn all stopped apps that have a saved command"],
+      ["--group <g>, -g <g>", "Re-spawn only stopped apps in group <g>"]
+    ],
+    examples: ["spawn", "spawn web", "spawn be-crm fe-crm", "spawn --all", "spawn --group backend"]
   },
   stop: {
     name: "stop",
-    usage: "stop <name|--all>",
+    usage: "stop <name|--all> [name...] [--group <g>]",
     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"]
+    description: "Sends SIGTERM but keeps the entry in tracked.json so it can be revived later with `fennec spawn`. Stops the ENTIRE process tree so no orphaned children are left. Accepts multiple names at once (e.g. `stop be-crm fe-crm`).",
+    options: [
+      ["--all, -a", "Stop all running tracked apps"],
+      ["--group <g>, -g <g>", "Stop only running apps in group <g>"]
+    ],
+    examples: ["stop web", "stop be-crm fe-crm -y", "stop --all", "stop --group backend"]
   },
   restart: {
     name: "restart",
-    usage: "restart <name|pid>",
+    usage: "restart <name|pid> [name...] [--group <g>]",
     summary: "Stop and re-spawn a tracked app from its saved config",
-    examples: ["restart web"]
+    options: [["--group <g>, -g <g>", "Restart all apps in group <g>"]],
+    examples: ["restart web", "restart be-crm fe-crm -y", "restart --group backend"]
   },
   kill: {
     name: "kill",
-    usage: "kill <pid|name|all>",
-    summary: "Kill a Fennec-tracked process (by PID, tracked name, or all tracked)",
-    description: "Permanently removes a tracked app (unlike `stop`, which keeps it). By NAME it only matches Fennec-tracked apps \u2014 use an explicit PID to kill a system process. Prompts before killing.",
+    usage: "kill <pid|name|all> [name...] [--group <g>]",
+    summary: "Kill a process and remove it from the registry",
+    description: "Permanently removes a tracked app (unlike `stop`, which keeps it). By NAME it only matches Fennec-tracked apps \u2014 use an explicit PID to kill a system process. Prompts before killing. Kills the ENTIRE process tree (e.g. npm \u2192 vite \u2192 esbuild) so no orphaned children are left behind. Accepts multiple names at once (e.g. `kill be-crm fe-crm`).",
     options: [
       ["--signal <sig>", "Signal to send (default: SIGTERM). e.g. SIGKILL, SIGINT"],
       ["--all, -a", "Kill ALL tracked apps (asks for confirmation)"],
+      ["--group <g>, -g <g>", "Kill only apps in group <g> (other groups untouched)"],
       ["-y, --yes", "Skip the confirmation prompt"]
     ],
-    examples: ["kill web", "kill 12345 --signal SIGKILL", "kill all -y"]
+    examples: [
+      "kill web",
+      "kill 12345 --signal SIGKILL",
+      "kill be-crm fe-crm -y",
+      "kill all -y",
+      "kill --group backend -y"
+    ]
   },
   supervisor: {
     name: "supervisor",
@@ -2317,6 +2345,18 @@ var COMMANDS = {
     summary: "Rename a tracked app",
     examples: ["rename web frontend"]
   },
+  group: {
+    name: "group",
+    usage: "group [name] [group]",
+    summary: "Assign a logical group to tracked apps (for scoped bulk ops)",
+    description: "Groups let bulk commands (kill/spawn/stop/ps) target a subset instead of everything. Assign a group to an existing tracked app, clear it with --unset, or run with no args to list every app's group. New apps can also be tagged at start time with `fennec start <cmd> --name <n> --group <g>`. Then `fennec kill --group <g>` / `fennec spawn --group <g>` / `fennec stop --group <g>` / `fennec ps --group <g>` only touch that group.",
+    options: [
+      ["<name> <group>", "Assign <group> to the tracked app <name>"],
+      ["<name> --unset", "Remove the group from <name>"],
+      ["(no args)", "List all tracked apps with their group"]
+    ],
+    examples: ["group web backend", "group web --unset", "group", "kill --group backend"]
+  },
   attach: {
     name: "attach",
     usage: "attach <port> --name <name>",
@@ -2431,7 +2471,27 @@ function findCommandDoc(cmd) {
 }
 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: "Apps & Processes",
+    keys: [
+      "start",
+      "run",
+      "ps",
+      "status",
+      "log",
+      "spawn",
+      "stop",
+      "restart",
+      "kill",
+      "group",
+      "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"] },
@@ -2445,7 +2505,9 @@ function showHelp() {
   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.")}`);
+  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}`);
@@ -2470,8 +2532,10 @@ function showCommandHelp(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.")}
-`);
+    console.error(
+      `  ${pc3.dim("Run")} ${pc3.cyan("fennec help")} ${pc3.dim("to see all commands.")}
+`
+    );
     return;
   }
   const lines = [];
@@ -2580,7 +2644,9 @@ async function attachPortCommand(args2) {
   const detector = new PortDetector2();
   const info = detector.detectByPort(port);
   if (info) {
-    console.log(`Found process on port ${port}: PID ${info.pid}${info.command ? ` (${info.command})` : ""}`);
+    console.log(
+      `Found process on port ${port}: PID ${info.pid}${info.command ? ` (${info.command})` : ""}`
+    );
   } else {
     console.error(`No process found listening on port ${port}`);
     process.exit(1);
@@ -2619,7 +2685,18 @@ import { FennecServer } from "@plumpslabs/fennec-core";
 import pc7 from "picocolors";
 
 // src/commands/tracker.ts
-import { existsSync as existsSync3, writeFileSync, readFileSync as readFileSync2, mkdirSync, renameSync, statSync, rmSync, openSync, closeSync, writeSync } 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";
@@ -2681,7 +2758,10 @@ function readSingleProcProcess(pid, currentUid, totalMemKb) {
       if (uptimeSeconds > 0) {
         const elapsedJiffies = uptimeSeconds * hertz;
         const processJiffies = totalJiffies;
-        cpuPercent = Math.min(100, processJiffies / Math.max(1, elapsedJiffies) * 100 * cpus().length);
+        cpuPercent = Math.min(
+          100,
+          processJiffies / Math.max(1, elapsedJiffies) * 100 * cpus().length
+        );
       }
       startedAt = formatStartTime(starttime, uptimeSeconds, hertz);
     }
@@ -2872,12 +2952,32 @@ function getSystemProcesses(filter) {
   }
   return processes;
 }
-function killProcess(pid, signal = "SIGTERM") {
+function killTree(pid, signal = "SIGTERM") {
+  if (process.platform === "win32") {
+    try {
+      execSync(`taskkill /pid ${pid} /T /F`, { stdio: "ignore", timeout: 5e3 });
+      return true;
+    } catch {
+      try {
+        process.kill(pid, signal);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
   try {
-    process.kill(pid, signal);
+    process.kill(-pid, signal);
     return true;
-  } catch {
-    return false;
+  } catch (e) {
+    const code = e.code;
+    if (code === "ESRCH") return false;
+    try {
+      process.kill(pid, signal);
+      return true;
+    } catch {
+      return false;
+    }
   }
 }
 function isProcessRunning(pid) {
@@ -2888,15 +2988,54 @@ function isProcessRunning(pid) {
     return false;
   }
 }
+function getProcessMemRss(pid) {
+  if (process.platform === "win32") {
+    try {
+      const out = execSync(`tasklist /fi "PID eq ${pid}" /fo csv /nh 2>nul`, {
+        encoding: "utf-8",
+        timeout: 3e3
+      });
+      for (const raw of out.split("\n")) {
+        if (!raw.trim()) continue;
+        const parts = raw.split('","').map((p) => p.replace(/^"|"$/g, ""));
+        if (parseInt(parts[1] ?? "", 10) !== pid) continue;
+        const memKb = parseInt((parts[4] ?? "").replace(/[^\d]/g, ""), 10);
+        return isNaN(memKb) ? null : memKb;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  if (process.platform === "darwin" || process.platform === "freebsd" || process.platform === "openbsd" || process.platform === "netbsd") {
+    try {
+      const out = execSync(`ps -o rss= -p ${pid} 2>/dev/null`, {
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim();
+      const kb = parseInt(out, 10);
+      return isNaN(kb) ? null : kb;
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const status = readFileSync(`/proc/${pid}/status`, "utf-8");
+    const m = status.match(/VmRSS:\s+(\d+)/);
+    return m ? parseInt(m[1], 10) : null;
+  } catch {
+    return null;
+  }
+}
 function checkPort(port, host = "127.0.0.1", timeout = 1e3) {
-  const tryHost = (h) => new Promise((resolve13) => {
+  const tryHost = (h) => new Promise((resolve12) => {
     const socket = new net.Socket();
     let settled = false;
     const finish = (result) => {
       if (settled) return;
       settled = true;
       socket.destroy();
-      resolve13(result);
+      resolve12(result);
     };
     socket.setTimeout(timeout);
     socket.once("connect", () => finish(true));
@@ -2968,7 +3107,10 @@ function findPidOnPortLinux(port) {
 }
 function findPidOnPortMac(port) {
   try {
-    const out = execSync(`lsof -i :${port} -sTCP:LISTEN -P -n 2>/dev/null`, { encoding: "utf-8", timeout: 5e3 });
+    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+/);
@@ -3023,7 +3165,10 @@ function getProcessCmdlineMac(pid) {
 }
 function getProcessCmdlineWindows(pid) {
   try {
-    const out = execSync(`wmic process where ProcessId=${pid} get CommandLine /value 2>nul`, { encoding: "utf-8", timeout: 3e3 });
+    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;
@@ -3041,7 +3186,10 @@ function getProcessCwd(pid) {
   }
   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 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 {
@@ -3089,6 +3237,44 @@ function formatProcessState(state) {
 }
 
 // src/commands/tracker.ts
+function extractFlagValue(args2, long, short) {
+  for (let i = 0; i < args2.length; i++) {
+    const a = args2[i];
+    if (a === long || short && a === short) return args2[i + 1];
+    if (a.startsWith(`${long}=`)) return a.slice(long.length + 1);
+    if (short && a.startsWith(`${short}=`)) return a.slice(short.length + 1);
+  }
+  return void 0;
+}
+function getGroups() {
+  const tracked = readTracked();
+  const groups = /* @__PURE__ */ new Set();
+  for (const t of tracked) if (t.group) groups.add(t.group);
+  return [...groups].sort();
+}
+function resolveTargets(args2) {
+  const groupFlag = extractFlagValue(args2, "--group", "-g");
+  const all = args2.includes("--all") || args2.includes("-a");
+  const positionals = args2.filter((a) => !a.startsWith("-") && !a.includes("="));
+  const groups = getGroups();
+  if (groupFlag) return { kind: "group", group: groupFlag };
+  if (positionals.length === 1 && positionals[0] === "all") return { kind: "all" };
+  if (all) return { kind: "all" };
+  if (positionals.length === 1 && groups.includes(positionals[0])) {
+    return { kind: "group", group: positionals[0] };
+  }
+  if (positionals.length === 1) return { kind: "single", value: positionals[0] };
+  if (positionals.length > 1) return { kind: "names", values: positionals };
+  return { kind: "none" };
+}
+function setGroup(name, group) {
+  const tracked = readTracked();
+  const idx = tracked.findIndex((t) => t.name === name);
+  if (idx === -1) return false;
+  tracked[idx] = { ...tracked[idx], group };
+  saveTracked(tracked);
+  return true;
+}
 var RESTART_CAUSE = "fennec:restart";
 function getFennecDir() {
   return process.env.FENNEC_DATA_DIR ? resolve2(process.env.FENNEC_DATA_DIR) : resolve2(homedir(), ".fennec");
@@ -3117,7 +3303,10 @@ function saveTracked(processes) {
     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));
+    console.error(
+      "[fennec] Failed to save tracked processes:",
+      err instanceof Error ? err.message : String(err)
+    );
   }
 }
 function addTracked(proc) {
@@ -3233,7 +3422,10 @@ function rotateLogFile(filePath, maxSize = DEFAULT_MAX_LOG_SIZE, maxFiles = DEFA
     }
     return true;
   } catch (err) {
-    console.error("[fennec] Log rotation failed:", err instanceof Error ? err.message : String(err));
+    console.error(
+      "[fennec] Log rotation failed:",
+      err instanceof Error ? err.message : String(err)
+    );
     return false;
   }
 }
@@ -3253,7 +3445,7 @@ function respawnTracked(proc, cause) {
   if (cause) annotateRestart(logFilePath, cause);
   if (isProcessRunning(proc.pid)) {
     try {
-      process.kill(proc.pid, "SIGTERM");
+      killTree(proc.pid, "SIGTERM");
     } catch {
     }
   }
@@ -3298,15 +3490,11 @@ function spawnDaemon(opts) {
   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
-    }
-  );
+  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,
@@ -3362,7 +3550,16 @@ ${RESTART_CAUSE} cause=${cause} at=${(/* @__PURE__ */ new Date()).toISOString()}
 
 // 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 {
+  existsSync as existsSync4,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2,
+  unlinkSync,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  closeSync as closeSync2,
+  statSync as statSync2
+} from "fs";
 import { spawn as spawn2 } from "child_process";
 import { dirname as dirname2 } from "path";
 var POLL_INTERVAL_MS = 3e3;
@@ -3384,6 +3581,38 @@ function ensureSupervisorRunning() {
   return startSupervisorDaemon();
 }
 function startSupervisorDaemon() {
+  const already = getSupervisorPid();
+  if (already) return already;
+  const lockPath = `${getSupervisorPidPath()}.lock`;
+  const SUPERVISOR_LOCK_STALE_MS = 6e4;
+  const acquireLock = () => {
+    try {
+      const lfd = openSync2(lockPath, "wx");
+      closeSync2(lfd);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (!acquireLock()) {
+    const live = getSupervisorPid();
+    if (live) return live;
+    let stale = false;
+    try {
+      stale = Date.now() - statSync2(lockPath).mtimeMs > SUPERVISOR_LOCK_STALE_MS;
+    } catch {
+      stale = false;
+    }
+    if (stale) {
+      try {
+        unlinkSync(lockPath);
+      } catch {
+      }
+      if (!acquireLock()) return getSupervisorPid() ?? 0;
+    } else {
+      return 0;
+    }
+  }
   const logFilePath = logFilePathFor("supervisor");
   mkdirSync2(dirname2(logFilePath), { recursive: true });
   const fd = openSync2(logFilePath, "a");
@@ -3414,24 +3643,30 @@ async function supervisorCommand(args2) {
     case "status":
       return supervisorStatus();
     default:
-      console.error(renderError("Unknown sub-command", `"${sub}" \u2014 use: start | stop | status | restart`));
+      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(`
+    console.error(
+      `
   ${pc4.yellow("\u26A0")} Supervisor already running ${pc4.dim(`(PID ${existing})`)}
-`);
+`
+    );
     return;
   }
   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.")}
-`);
+  console.error(
+    `  ${pc4.dim("It will auto-restart apps started with")} ${pc4.cyan("--restart")} ${pc4.dim("even if you close this terminal.")}
+`
+  );
 }
 function supervisorStop() {
   const pid = getSupervisorPid();
@@ -3442,10 +3677,12 @@ function supervisorStop() {
     return;
   }
   try {
-    process.kill(pid, "SIGTERM");
-    console.error(`
+    killTree(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)));
   }
@@ -3463,12 +3700,18 @@ function supervisorStatus() {
   if (pid) {
     console.error(`  ${pc4.green("\u25CF")} running ${pc4.dim(`(PID ${pid})`)}`);
   } else {
-    console.error(`  ${pc4.red("\u25CB")} not running ${pc4.dim("\u2014 start with")} ${pc4.cyan("fennec supervisor start")}`);
+    console.error(
+      `  ${pc4.red("\u25CB")} not running ${pc4.dim("\u2014 start with")} ${pc4.cyan("fennec supervisor start")}`
+    );
   }
-  console.error(`
-  ${pc4.bold("Managed apps")} ${pc4.dim(`(${managed.length} with auto-restart)`)}`);
+  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")}`);
+    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);
@@ -3489,6 +3732,10 @@ async function runSupervisor() {
     return;
   }
   writeFileSync2(pidPath, String(process.pid), "utf-8");
+  try {
+    unlinkSync(`${pidPath}.lock`);
+  } catch {
+  }
   log(`supervisor started (PID ${process.pid}), polling every ${POLL_INTERVAL_MS}ms`);
   const crashes = /* @__PURE__ */ new Map();
   let stopped = false;
@@ -3498,6 +3745,10 @@ async function runSupervisor() {
       unlinkSync(pidPath);
     } catch {
     }
+    try {
+      unlinkSync(`${pidPath}.lock`);
+    } catch {
+    }
     log("supervisor stopping");
     process.exit(0);
   };
@@ -3540,7 +3791,9 @@ async function runSupervisor() {
               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`);
+              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`);
@@ -3566,14 +3819,18 @@ async function runSupervisor() {
       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)`);
+        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]`);
+        log(
+          `${t.name}: restarted (PID ${newPid}) [${rec.count}/${MAX_RESTARTS_IN_WINDOW} in window]`
+        );
       } catch (err) {
         log(`${t.name}: restart failed: ${String(err)}`);
       }
@@ -3629,11 +3886,25 @@ function unitPaths(backend) {
   const fennecDir = getFennecDir();
   switch (backend) {
     case "systemd":
-      return { unit: resolve3(homedir2(), ".config", "systemd", "user", "fennec-supervisor.service") };
+      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") };
+      return {
+        unit: resolve3(
+          homedir2(),
+          "AppData",
+          "Roaming",
+          "Microsoft",
+          "Windows",
+          "Start Menu",
+          "Programs",
+          "Startup",
+          "fennec-supervisor.bat"
+        )
+      };
     default:
       return { unit: resolve3(fennecDir, "persist.unit") };
   }
@@ -3714,7 +3985,12 @@ 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.`));
+    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) {
@@ -3725,7 +4001,9 @@ async function persistCommand(args2) {
     case "status":
       return persistStatus(backend);
     default:
-      console.error(renderError("Unknown sub-command", `"${sub}" \u2014 use: enable | disable | status`));
+      console.error(
+        renderError("Unknown sub-command", `"${sub}" \u2014 use: enable | disable | status`)
+      );
       process.exit(1);
   }
 }
@@ -3735,8 +4013,10 @@ function persistEnable(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(
+      `
+  ${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.")}
 `);
@@ -3750,20 +4030,28 @@ function persistEnable(backend) {
     }
     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.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(
+      `
+  ${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.")}
-`);
+    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(
+      `
+  ${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.")}
@@ -3793,7 +4081,9 @@ function persistStatus(backend) {
   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(
+      `  ${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;
   }
@@ -3822,6 +4112,7 @@ async function psCommand(args2) {
   const systemFlag = args2.includes("--system") || args2.includes("-a") || args2.includes("--all");
   const jsonFlag = args2.includes("--json");
   const nameFilter = args2.includes("--name") ? args2[args2.indexOf("--name") + 1] : void 0;
+  const groupFilter = extractFlagValue(args2, "--group", "-g");
   const sortBy = args2.includes("--sort") ? args2[args2.indexOf("--sort") + 1] : "name";
   if (jsonFlag) {
     await psJson();
@@ -3846,26 +4137,48 @@ async function psCommand(args2) {
       const columns2 = [
         { 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 ? 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 ? 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 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);
-        } }
+        {
+          key: "cpu",
+          label: "CPU%",
+          align: "right",
+          format: (v) => {
+            const n = v;
+            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 ? 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 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(`
+      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} ${pc6.bold("System Processes")} ${pc6.dim(`(top ${processes.length} by ${sortBy})`)}
-`);
+`
+      );
       console.error(renderTable(columns2, rows2));
       console.error();
     } catch (error) {
@@ -3874,46 +4187,102 @@ async function psCommand(args2) {
     }
     return;
   }
-  const tracked = readTracked();
+  const trackedAll = readTracked();
+  const tracked = groupFilter ? trackedAll.filter((t) => t.group === groupFilter) : trackedAll;
   if (tracked.length === 0) {
-    console.error(`
-  ${pc6.dim("No tracked processes.")}`);
-    console.error(`  ${pc6.dim("Start an app with:")} ${pc6.cyan("fennec start <command> --name <name>")}
-`);
+    console.error(
+      `
+  ${pc6.dim(groupFilter ? `No tracked processes in group "${groupFilter}".` : "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) => pc6.bold(String(v)) },
     { key: "pid", label: "PID", align: "right" },
-    { key: "status", label: "Status", format: (v) => {
-      const s = v;
-      return s === "running" ? pc6.green("\u25CF running") : pc6.red("\u25CB stopped");
-    } },
-    { key: "port", label: "Port", format: (v) => {
-      const p = v;
-      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: "status",
+      label: "Status",
+      format: (v) => {
+        const s = v;
+        return s === "running" ? pc6.green("\u25CF running") : pc6.red("\u25CB stopped");
+      }
+    },
+    {
+      key: "group",
+      label: "Group",
+      format: (v) => {
+        const g = String(v);
+        return g === "-" ? pc6.dim("-") : pc6.cyan(g);
+      }
+    },
+    {
+      key: "port",
+      label: "Port",
+      format: (v) => {
+        const p = v;
+        return p ? pc6.yellow(`:${p}`) : pc6.dim("-");
+      }
+    },
+    {
+      key: "mem",
+      label: "MEM",
+      align: "right",
+      format: (v) => {
+        const kb = v;
+        return kb && kb > 0 ? pc6.dim(`${(kb / 1024).toFixed(0)}MB`) : 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) => pc6.dim(String(v)) }
   ];
   const rows = tracked.map((t) => {
     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) : pc6.dim(String(t.pid)), status: running ? "running" : "stopped", port: t.port ?? null, command: t.command, uptime };
+    const memKb = running ? getProcessMemRss(t.pid) ?? null : null;
+    return {
+      name: t.name,
+      pid: running ? String(t.pid) : pc6.dim(String(t.pid)),
+      status: running ? "running" : "stopped",
+      group: t.group ?? "-",
+      port: t.port ?? null,
+      mem: memKb,
+      command: t.command,
+      uptime
+    };
   });
   const runningCount = tracked.filter((t) => isTrackedRunning(t)).length;
-  console.error(`
-  ${symbols.fox} ${pc6.bold("Fennec Apps")} ${pc6.dim(`(${runningCount}/${tracked.length} running)`)}
-`);
+  const scope = groupFilter ? ` in group ${pc6.cyan(groupFilter)}` : "";
+  console.error(
+    `
+  ${symbols.fox} ${pc6.bold("Fennec Apps")} ${pc6.dim(`(${runningCount}/${tracked.length} running${scope})`)}
+`
+  );
   console.error(renderTable(columns, rows));
-  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 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(
+    `  ${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(`  ${pc6.dim("Filter by group with:")} ${pc6.cyan("fennec ps --group <group>")}`);
   console.error();
 }
 async function psJson() {
@@ -3927,6 +4296,11 @@ async function psJson() {
       port: t.port ?? null,
       command: t.command,
       cwd: t.cwd ?? null,
+      group: t.group ?? null,
+      memMB: running ? (() => {
+        const kb = getProcessMemRss(t.pid);
+        return kb ? Math.round(kb / 1024) : null;
+      })() : null,
       startedAt: t.startedAt,
       uptime: running ? Math.floor((Date.now() - new Date(t.startedAt).getTime()) / 1e3) : null
     };
@@ -3943,19 +4317,25 @@ async function statusCommand(_args) {
 `);
   if (tracked.length > 0) {
     const runningCount = tracked.filter((t) => isTrackedRunning(t)).length;
-    console.error(`  ${pc6.bold("Managed Apps")} ${pc6.dim(`(${runningCount}/${tracked.length} running)`)}
-`);
+    console.error(
+      `  ${pc6.bold("Managed Apps")} ${pc6.dim(`(${runningCount}/${tracked.length} running)`)}
+`
+    );
     for (const t of tracked) {
       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(
+        `  ${statusIcon} ${pc6.bold(t.name)}${portStr} ${pc6.dim(`(PID ${t.pid})`)} \u2014 ${uptime}`
+      );
     }
     console.error();
   } else {
-    console.error(`  ${pc6.dim("No managed apps.")} ${pc6.cyan("fennec start <command> --name <name>")}
-`);
+    console.error(
+      `  ${pc6.dim("No managed apps.")} ${pc6.cyan("fennec start <command> --name <name>")}
+`
+    );
   }
   console.error(`  ${pc6.bold("System")} ${pc6.dim(`(${totalUserProcs} user processes)`)}`);
   for (const p of topSystem) {
@@ -3967,25 +4347,47 @@ async function statusCommand(_args) {
   console.error();
 }
 async function watchSystemProcesses(sortBy, limit) {
-  console.error(`
+  console.error(
+    `
   ${pc6.bold("Watching system processes")} ${pc6.dim("(Ctrl+C to stop, refreshes every 3s)")}
-`);
+`
+  );
   const render = () => {
-    const processes = getSystemProcesses({ userOnly: true, sortBy, limit });
+    const processes = getSystemProcesses({
+      userOnly: true,
+      sortBy,
+      limit
+    });
     const columns = [
       { 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 ? 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 ? pc6.red(String(n)) : n > 5 ? pc6.yellow(String(n)) : pc6.dim(String(n));
-      } },
+      {
+        key: "cpu",
+        label: "CPU%",
+        align: "right",
+        format: (v) => {
+          const n = v;
+          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 ? 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 }));
+    const rows = processes.map((p) => ({
+      pid: p.pid,
+      name: p.name,
+      cpu: p.cpuPercent,
+      mem: p.memPercent,
+      state: p.state
+    }));
     return `  ${timestamp()} ${pc6.dim(`${processes.length} processes`)}
 ${renderTable(columns, rows, { compact: true })}`;
   };
@@ -3994,11 +4396,11 @@ ${renderTable(columns, rows, { compact: true })}`;
     process.stdout.write("\x1B[J");
     console.error(render());
   }, 3e3);
-  await new Promise((resolve13) => {
+  await new Promise((resolve12) => {
     process.once("SIGINT", () => {
       clearInterval(interval);
       process.stdout.write("\x1B[J");
-      resolve13();
+      resolve12();
     });
   });
 }
@@ -4040,8 +4442,12 @@ async function startServer(args2) {
   ${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(
+        `  ${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")}
 `);
@@ -4075,20 +4481,28 @@ async function runCommand(args2) {
   const cwd = cwdIndex !== -1 ? resolve4(args2[cwdIndex + 1]) : process.cwd();
   const restartFlag = args2.includes("--restart");
   const jsonlFlag = args2.includes("--jsonl");
+  const group = extractFlagValue(args2, "--group", "-g");
   const stopFlags = [nameIndex, portIndex, cwdIndex].filter((i) => i !== -1);
   const cmdEnd = Math.min(...stopFlags, Infinity);
   const cmdParts = args2.slice(0, cmdEnd);
   const cmd = cmdParts.join(" ");
   if (!cmd) {
-    console.error(renderError("Missing command", "Usage: fennec start|run <command> --name <name> [--port <port>] [--cwd <dir>] [--restart]"));
+    console.error(
+      renderError(
+        "Missing command",
+        "Usage: fennec start|run <command> --name <name> [--port <port>] [--cwd <dir>] [--restart]"
+      )
+    );
     process.exit(1);
   }
   const appName = name ?? cmdParts[0] ?? "app";
   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(
+        `
+  ${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;
@@ -4098,7 +4512,9 @@ async function runCommand(args2) {
   const existing = tracked.find((t) => t.name === appName);
   if (existing && isTrackedRunning(existing)) {
     console.error();
-    console.error(`  ${pc7.yellow("\u26A0")} ${pc7.bold(appName)} ${pc7.dim(`is already running (PID: ${existing.pid})`)}`);
+    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();
@@ -4107,20 +4523,30 @@ async function runCommand(args2) {
   const logDir = dirname4(logFilePathFor(appName));
   mkdirSync4(logDir, { recursive: true });
   const logFilePath = logFilePathFor(appName);
-  console.error(`
+  console.error(
+    `
   ${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", pc7.green("enabled"))}`);
+  if (group) console.error(`  ${renderKV("Group", group)}`);
   console.error(`  ${divider()}`);
   try {
     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 currentChild = spawnDaemon({
+      cmdParts,
+      name: appName,
+      cwd,
+      logFilePath,
+      env: buildSpawnEnv(startEnv),
+      logMode: jsonlFlag ? "jsonl" : "text"
+    });
     const pid = currentChild.pid ?? 0;
     addTracked({
       name: appName,
@@ -4132,31 +4558,42 @@ async function runCommand(args2) {
       env: startEnv,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       autoRestart: restartFlag,
-      logMode: jsonlFlag ? "jsonl" : "text"
+      logMode: jsonlFlag ? "jsonl" : "text",
+      group
     });
     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 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(
+        `  ${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}`)}`);
+        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`)}`);
+        console.error(
+          `  ${pc7.yellow("\u26A0")} ${pc7.bold(appName)} ${pc7.dim(`is running but port ${port} is not accepting connections yet`)}`
+        );
       }
     }
     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(
+        `  ${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([]);
@@ -4181,7 +4618,14 @@ async function resurrectTracked() {
     try {
       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 });
+      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,
@@ -4213,25 +4657,49 @@ async function resurrectTracked() {
 // src/commands/kill.ts
 import pc8 from "picocolors";
 async function killCommand(args2) {
-  const rawTarget = args2[0];
   const signalIndex = args2.indexOf("--signal");
   const signalRaw = signalIndex !== -1 ? args2[signalIndex + 1] : "SIGTERM";
   const signal = signalRaw ?? "SIGTERM";
   const force = args2.includes("-y") || args2.includes("--yes");
-  if (rawTarget === "all" || args2.includes("--all") || args2.includes("-a")) {
-    await killAll(signal, force);
+  const target = resolveTargets(args2);
+  if (target.kind === "single") {
+    await killOne(target.value, signal, force, false);
     return;
   }
-  if (!rawTarget) {
-    console.error(renderError("Missing target", "Usage: fennec kill <pid|name|all> [--signal SIGTERM|SIGKILL|SIGINT]"));
-    process.exit(1);
+  if (target.kind === "names") {
+    for (const name of target.values) {
+      await killOne(name, signal, force, true);
+    }
+    return;
   }
+  if (target.kind === "group") {
+    await killGroup(target.group, signal, force);
+    return;
+  }
+  if (target.kind === "all") {
+    await killAll(signal, force);
+    return;
+  }
+  console.error(
+    renderError(
+      "Missing target",
+      "Usage: fennec kill <pid|name|all> [--signal SIGTERM|SIGKILL|SIGINT] [--group <group>] [-y]"
+    )
+  );
+  process.exit(1);
+}
+async function killOne(rawTarget, signal, force, multi) {
   let targetPid;
   let displayName;
   const pid = parseInt(rawTarget, 10);
   if (!isNaN(pid) && String(pid) === rawTarget) {
     if (!isProcessRunning(pid)) {
-      console.error(renderError("Process not found", `No process with PID ${pid} is running`));
+      const msg = `No process with PID ${pid} is running`;
+      if (multi) {
+        console.error(renderError("Process not found", msg));
+        return;
+      }
+      console.error(renderError("Process not found", msg));
       process.exit(1);
     }
     targetPid = pid;
@@ -4242,16 +4710,23 @@ async function killCommand(args2) {
     if (trackedMatch) {
       if (!isTrackedRunning(trackedMatch)) {
         removeTrackedByPid(trackedMatch.pid);
-        console.error(`
-  ${pc8.green("\u2713")} ${pc8.bold(rawTarget)} ${pc8.dim("removed from tracked apps (was already stopped)")}`);
+        console.error(
+          `
+  ${pc8.green("\u2713")} ${pc8.bold(rawTarget)} ${pc8.dim("removed from tracked apps (was already stopped)")}`
+        );
         console.error();
         return;
       }
       targetPid = trackedMatch.pid;
       displayName = `${trackedMatch.name} (PID ${targetPid})`;
     } else {
-      console.error(renderError("Not tracked", `No tracked process named "${rawTarget}".
-Use ${pc8.cyan(`fennec kill <pid>`)} to kill a system process by its PID.`));
+      const msg = `No tracked process named "${rawTarget}".
+Use ${pc8.cyan("fennec kill <pid>")} to kill a system process by its PID.`;
+      if (multi) {
+        console.error(renderError("Not tracked", msg));
+        return;
+      }
+      console.error(renderError("Not tracked", msg));
       process.exit(1);
     }
   }
@@ -4261,7 +4736,7 @@ Use ${pc8.cyan(`fennec kill <pid>`)} to kill a system process by its PID.`));
     return;
   }
   const spinner = createSpinner(`Sending ${signal} to ${displayName}...`);
-  const success = killProcess(targetPid, signal);
+  const success = killTree(targetPid, signal);
   if (success) {
     await new Promise((r) => setTimeout(r, 200));
     const stillRunning = isProcessRunning(targetPid);
@@ -4270,12 +4745,12 @@ Use ${pc8.cyan(`fennec kill <pid>`)} to kill a system process by its PID.`));
       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");
+        killTree(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(`  ${pc8.dim("Retrying with SIGTERM...")}`);
-        killProcess(targetPid, "SIGTERM");
+        killTree(targetPid, "SIGTERM");
         console.error(`  ${pc8.yellow("\u26A0")} ${displayName} ${pc8.dim("may still be running")}`);
       }
     } else {
@@ -4284,30 +4759,45 @@ Use ${pc8.cyan(`fennec kill <pid>`)} to kill a system process by its PID.`));
     }
   } else {
     spinner.fail(`Failed to kill ${displayName}`);
-    console.error(renderError("Permission denied", "Try running with sudo or use a different signal."));
+    console.error(
+      renderError("Permission denied", "Try running with sudo or use a different signal.")
+    );
   }
 }
-async function killAll(signal, force) {
+async function killGroup(group, signal, force) {
   const tracked = readTracked();
-  if (tracked.length === 0) {
-    console.error(`  ${pc8.dim("No tracked apps to kill.")}`);
-    return;
+  const inGroup = tracked.filter((t) => t.group === group);
+  if (inGroup.length === 0) {
+    console.error(
+      renderError(
+        "Empty group",
+        `No tracked entries in group "${group}".
+Known groups: ${pc8.cyan(getGroups().join(", ") || "(none)")}`
+      )
+    );
+    process.exit(1);
   }
-  const running = tracked.filter((t) => isTrackedRunning(t));
-  const stopped = tracked.filter((t) => !isTrackedRunning(t));
-  console.error(`
-  ${pc8.bold(`Kill ${running.length} running + remove ${stopped.length} stopped tracked app(s)?`)}`);
-  console.error(`  ${pc8.dim("Permanently removes every Fennec-tracked app \u2014 other processes are untouched.")}
-`);
+  const running = inGroup.filter((t) => isTrackedRunning(t));
+  const stopped = inGroup.filter((t) => !isTrackedRunning(t));
+  console.error(
+    `
+  ${pc8.bold(`Kill group ${pc8.cyan(group)}: ${running.length} running + remove ${stopped.length} stopped?`)}`
+  );
+  console.error(
+    `  ${pc8.dim("Permanently removes only apps in this group \u2014 other groups are untouched.")}
+`
+  );
   const confirmed = force || await confirmPrompt(`${pc8.red("Are you sure?")} ${pc8.dim("This cannot be undone")}`, false);
   if (!confirmed) {
     console.error(`  ${pc8.dim("Cancelled.")}`);
     return;
   }
-  const spinner = createSpinner(`Killing ${running.length} + removing ${stopped.length} tracked app(s)...`);
+  const spinner = createSpinner(
+    `Killing ${running.length} + removing ${stopped.length} tracked app(s) in ${group}...`
+  );
   let killed = 0, failed = 0;
   for (const t of running) {
-    if (killProcess(t.pid, signal)) {
+    if (killTree(t.pid, signal)) {
       killed++;
     } else {
       failed++;
@@ -4319,38 +4809,105 @@ async function killAll(signal, force) {
   }
   await new Promise((r) => setTimeout(r, 300));
   const total = running.length + stopped.length;
-  total > 0 ? spinner.succeed(`${killed} killed, ${stopped.length} stopped entr${stopped.length === 1 ? "y" : "ies"} removed`) : spinner.fail("Failed to kill apps");
+  total > 0 ? spinner.succeed(
+    `${killed} killed, ${stopped.length} stopped entries removed from group ${group}`
+  ) : spinner.fail("Failed to kill apps");
   if (failed > 0) console.error(`  ${pc8.yellow(`${failed} running app(s) could not be killed`)}`);
 }
-
-// src/commands/stop.ts
-import pc9 from "picocolors";
-async function stopCommand(args2) {
-  const stopAll = args2.includes("--all") || args2.includes("-a");
-  if (stopAll) {
-    await stopAllTracked(args2);
+async function killAll(signal, force) {
+  const tracked = readTracked();
+  if (tracked.length === 0) {
+    console.error(`  ${pc8.dim("No tracked apps to kill.")}`);
     return;
   }
-  const rawTarget = args2[0];
-  if (!rawTarget) {
-    console.error(renderError("Missing name", "Usage: fennec stop <name|--all>"));
-    process.exit(1);
-  }
-  const tracked = readTracked();
-  const trackedMatch = tracked.find((t) => t.name === rawTarget);
+  const running = tracked.filter((t) => isTrackedRunning(t));
+  const stopped = tracked.filter((t) => !isTrackedRunning(t));
+  console.error(
+    `
+  ${pc8.bold(`Kill ${running.length} running + remove ${stopped.length} stopped tracked app(s)?`)}`
+  );
+  console.error(
+    `  ${pc8.dim("Permanently removes every Fennec-tracked app \u2014 other processes are untouched.")}
+`
+  );
+  const confirmed = force || await confirmPrompt(`${pc8.red("Are you sure?")} ${pc8.dim("This cannot be undone")}`, false);
+  if (!confirmed) {
+    console.error(`  ${pc8.dim("Cancelled.")}`);
+    return;
+  }
+  const spinner = createSpinner(
+    `Killing ${running.length} + removing ${stopped.length} tracked app(s)...`
+  );
+  let killed = 0, failed = 0;
+  for (const t of running) {
+    if (killTree(t.pid, signal)) {
+      killed++;
+    } else {
+      failed++;
+    }
+    removeTrackedByPid(t.pid);
+  }
+  for (const t of stopped) {
+    removeTrackedByPid(t.pid);
+  }
+  await new Promise((r) => setTimeout(r, 300));
+  const total = running.length + stopped.length;
+  total > 0 ? spinner.succeed(`${killed} killed, ${stopped.length} stopped entries removed`) : spinner.fail("Failed to kill apps");
+  if (failed > 0) console.error(`  ${pc8.yellow(`${failed} running app(s) could not be killed`)}`);
+}
+
+// src/commands/stop.ts
+import pc9 from "picocolors";
+async function stopCommand(args2) {
+  const target = resolveTargets(args2);
+  if (target.kind === "group") {
+    await stopAllTracked(args2, target.group);
+    return;
+  }
+  if (target.kind === "all") {
+    await stopAllTracked(args2);
+    return;
+  }
+  if (target.kind === "single") {
+    await stopOne(target.value, args2);
+    return;
+  }
+  if (target.kind === "names") {
+    for (const name of target.values) {
+      await stopOne(name, args2, true);
+    }
+    return;
+  }
+  console.error(
+    renderError("Missing name", "Usage: fennec stop <name|--all> [--group <group>] [-y]")
+  );
+  process.exit(1);
+}
+async function stopOne(rawTarget, args2, multi = false) {
+  const tracked = readTracked();
+  const trackedMatch = tracked.find((t) => t.name === rawTarget);
   if (!trackedMatch) {
-    console.error(renderError("Not found", `No tracked process named "${rawTarget}". Use ${pc9.cyan("fennec kill <pid>")} to kill a system process.`));
+    const msg = `No tracked process named "${rawTarget}". Use ${pc9.cyan("fennec kill <pid>")} to kill a system process.`;
+    if (multi) {
+      console.error(renderError("Not found", msg));
+      return;
+    }
+    console.error(renderError("Not found", msg));
     process.exit(1);
   }
   if (!isTrackedRunning(trackedMatch)) {
     console.error(`
   ${pc9.yellow("\u26A0")} ${pc9.bold(rawTarget)} ${pc9.dim("is already stopped")}`);
     console.error();
-    process.exit(0);
+    if (!multi) process.exit(0);
+    return;
   }
   const displayName = `${trackedMatch.name} (PID ${trackedMatch.pid})`;
   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);
+  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(`  ${pc9.dim("Cancelled")}`);
     return;
@@ -4358,18 +4915,23 @@ async function stopCommand(args2) {
   setAutoRestart(trackedMatch.name, false);
   await stopSingleProcess(trackedMatch.pid, trackedMatch.name);
 }
-async function stopAllTracked(args2) {
+async function stopAllTracked(args2, group) {
   const tracked = readTracked();
-  const running = tracked.filter((t) => isTrackedRunning(t));
+  const running = tracked.filter((t) => isTrackedRunning(t) && (!group || t.group === group));
   if (running.length === 0) {
-    console.error(`
-  ${pc9.dim("No running tracked processes to stop.")}
-`);
+    console.error(
+      `
+  ${pc9.dim(group ? `No running tracked processes in group "${group}".` : "No running tracked processes to stop.")}
+`
+    );
     return;
   }
-  console.error(`
-  ${pc9.yellow("\u26A0")} ${pc9.bold(`Stop all ${running.length} running process(es)?`)} ${pc9.dim("(They can be re-spawned later)")}
-`);
+  const scope = group ? ` group ${pc9.cyan(group)}` : "";
+  console.error(
+    `
+  ${pc9.yellow("\u26A0")} ${pc9.bold(`Stop all ${running.length} running process(es)${scope}?`)} ${pc9.dim("(They can be re-spawned later)")}
+`
+  );
   for (const t of running) {
     console.error(`  ${pc9.green("\u25CF")} ${pc9.bold(t.name)} ${pc9.dim(`(PID ${t.pid})`)}`);
   }
@@ -4386,7 +4948,7 @@ async function stopAllTracked(args2) {
   let failed = 0;
   for (const t of running) {
     setAutoRestart(t.name, false);
-    if (killProcess(t.pid, "SIGTERM")) {
+    if (killTree(t.pid, "SIGTERM")) {
       stopped++;
     } else {
       failed++;
@@ -4396,7 +4958,9 @@ async function stopAllTracked(args2) {
   spinner.stop();
   process.stdout.write("\r\x1B[K");
   if (stopped > 0) {
-    console.error(`  ${pc9.green("\u2713")} ${pc9.bold(`Stopped ${stopped} process(es)`)} ${pc9.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(`  ${pc9.red("\u2717")} ${pc9.bold(`${failed} process(es) failed to stop`)}`);
@@ -4407,7 +4971,7 @@ async function stopAllTracked(args2) {
 async function stopSingleProcess(pid, name) {
   const displayName = `${name} (PID ${pid})`;
   const spinner = createSpinner(`Stopping ${displayName}...`);
-  const success = killProcess(pid, "SIGTERM");
+  const success = killTree(pid, "SIGTERM");
   if (success) {
     await new Promise((r) => setTimeout(r, 200));
     const stillRunning = isProcessRunning(pid);
@@ -4416,7 +4980,7 @@ async function stopSingleProcess(pid, name) {
       const forceKill = await confirmPrompt(`Send ${pc9.red("SIGKILL")} to force stop?`, true);
       if (forceKill) {
         const forceSpinner = createSpinner(`Sending SIGKILL to ${displayName}...`);
-        killProcess(pid, "SIGKILL");
+        killTree(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 {
@@ -4439,38 +5003,77 @@ import { mkdirSync as mkdirSync5 } from "fs";
 import { resolve as resolve5 } from "path";
 import { homedir as homedir3 } from "os";
 async function spawnCommand(args2) {
-  const spawnAll = args2.includes("--all") || args2.includes("-a");
-  const name = args2[0];
-  if (spawnAll) {
-    await spawnAllStopped();
+  const target = resolveTargets(args2);
+  if (target.kind === "single") {
+    await spawnOne(target.value, false);
     return;
   }
-  if (!name) {
-    await spawnList();
+  if (target.kind === "names") {
+    for (const name of target.values) {
+      await spawnOne(name, true);
+    }
+    return;
+  }
+  if (target.kind === "group") {
+    const group = target.group;
+    const tracked = readTracked();
+    const inGroup = tracked.filter((t) => t.group === group && !isTrackedRunning(t) && t.command);
+    if (inGroup.length === 0) {
+      console.error(
+        renderError(
+          "Empty group",
+          `No stopped entries with a saved command in group "${group}".
+Known groups: ${pc10.cyan(getGroups().join(", ") || "(none)")}`
+        )
+      );
+      process.exit(1);
+    }
+    await spawnAllStopped(inGroup);
+    return;
+  }
+  if (target.kind === "all") {
+    await spawnAllStopped(readTracked().filter((t) => !isTrackedRunning(t) && t.command));
     return;
   }
+  await spawnList();
+}
+async function spawnOne(name, multi) {
   const tracked = readTracked();
   const match = tracked.find((t) => t.name === name);
   if (!match) {
-    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.`));
+    const msg = `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.`;
+    if (multi) {
+      console.error(renderError("Not found", msg));
+      return;
+    }
+    console.error(renderError("Not found", msg));
     process.exit(1);
   }
   if (isTrackedRunning(match)) {
-    console.error(`
-  ${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(
+      `
+  ${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);
+    if (!multi) process.exit(0);
+    return;
   }
   if (!match.command) {
-    console.error(renderError("No command saved", `"${name}" has no saved command and cannot be re-spawned.`));
+    const msg = `"${name}" has no saved command and cannot be re-spawned.`;
+    if (multi) {
+      console.error(renderError("No command saved", msg));
+      return;
+    }
+    console.error(renderError("No command saved", msg));
     process.exit(1);
   }
   await respawnProcess(match);
 }
-async function spawnAllStopped() {
-  const tracked = readTracked();
-  const toSpawn = tracked.filter((t) => !isTrackedRunning(t) && t.command);
+async function spawnAllStopped(procs) {
+  const toSpawn = procs;
   if (toSpawn.length === 0) {
     console.error(`
   ${pc10.dim("No stopped processes with saved commands to spawn.")}
@@ -4493,7 +5096,14 @@ async function spawnAllStopped() {
       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 child = spawnDaemon({
+        cmdParts,
+        name: proc.name,
+        cwd: proc.cwd,
+        logFilePath,
+        env: buildSpawnEnv(proc.env),
+        logMode: proc.logMode
+      });
       const pid = child.pid ?? 0;
       addTracked({
         name: proc.name,
@@ -4505,7 +5115,10 @@ async function spawnAllStopped() {
         env: proc.env,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         autoRestart: proc.autoRestart,
-        logMode: proc.logMode
+        logMode: proc.logMode,
+        // Preserve the logical group across stop -> spawn (addTracked REPLACES
+        // the entry by name, so group must be carried over explicitly).
+        group: proc.group
       });
       if (proc.autoRestart) {
         ensureSupervisorRunning();
@@ -4532,7 +5145,9 @@ async function spawnList() {
   if (tracked.length === 0) {
     console.error(`
   ${pc10.dim("No tracked processes found.")}`);
-    console.error(`  ${pc10.dim("Start an app first:")} ${pc10.cyan("fennec start <command> --name <name>")}`);
+    console.error(
+      `  ${pc10.dim("Start an app first:")} ${pc10.cyan("fennec start <command> --name <name>")}`
+    );
     console.error();
     return;
   }
@@ -4544,8 +5159,10 @@ async function spawnList() {
     console.error();
     return;
   }
-  console.error(`
-  ${symbols.fox} ${pc10.bold("Available to spawn")} ${pc10.dim(`(${stopped.length}/${tracked.length} stopped)`)}`);
+  console.error(
+    `
+  ${symbols.fox} ${pc10.bold("Available to spawn")} ${pc10.dim(`(${stopped.length}/${tracked.length} stopped)`)}`
+  );
   if (running.length > 0) {
     console.error(`  ${pc10.dim("Running (use stop first):")}`);
     for (const r of running) {
@@ -4553,11 +5170,14 @@ async function spawnList() {
     }
     console.error();
   }
-  const selected = await selectPrompt("Select a process to spawn:", stopped.map((t) => ({
-    value: t.name,
-    label: t.name,
-    description: t.command.length > 80 ? t.command.slice(0, 80) + "..." : t.command
-  })));
+  const selected = await selectPrompt(
+    "Select a process to spawn:",
+    stopped.map((t) => ({
+      value: t.name,
+      label: t.name,
+      description: t.command.length > 80 ? t.command.slice(0, 80) + "..." : t.command
+    }))
+  );
   if (selected === null) {
     console.error(`  ${pc10.dim("Cancelled")}`);
     return;
@@ -4572,14 +5192,23 @@ async function respawnProcess(proc) {
   const logDir = resolve5(homedir3(), ".fennec", "logs");
   mkdirSync5(logDir, { recursive: true });
   const logFilePath = resolve5(logDir, `${proc.name}.log`);
-  console.error(`
+  console.error(
+    `
   ${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 = spawnDaemon({ cmdParts, name: proc.name, cwd: proc.cwd, logFilePath, env: buildSpawnEnv(proc.env), logMode: proc.logMode });
+    const child = spawnDaemon({
+      cmdParts,
+      name: proc.name,
+      cwd: proc.cwd,
+      logFilePath,
+      env: buildSpawnEnv(proc.env),
+      logMode: proc.logMode
+    });
     const pid = child.pid ?? 0;
     addTracked({
       name: proc.name,
@@ -4591,7 +5220,8 @@ async function respawnProcess(proc) {
       env: proc.env,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       autoRestart: proc.autoRestart,
-      logMode: proc.logMode
+      logMode: proc.logMode,
+      group: proc.group
     });
     if (proc.autoRestart) {
       ensureSupervisorRunning();
@@ -4607,32 +5237,51 @@ async function respawnProcess(proc) {
 
 // src/commands/restart.ts
 import pc11 from "picocolors";
-import { mkdirSync as mkdirSync6 } from "fs";
-import { resolve as resolve6 } from "path";
-import { homedir as homedir4 } from "os";
 async function restartCommand(args2) {
-  const raw = args2[0];
-  if (!raw) {
-    console.error(renderError("Missing process name/pid", "Usage: fennec restart <name|pid> [-y]"));
-    process.exit(1);
+  const force = args2.includes("-y") || args2.includes("--yes");
+  const target = resolveTargets(args2);
+  if (target.kind === "group") {
+    await restartGroup(target.group, force);
+    return;
+  }
+  if (target.kind === "names") {
+    for (const n of target.values) await restartOne(n, force, true);
+    return;
   }
+  if (target.kind === "single") {
+    await restartOne(target.value, force, false);
+    return;
+  }
+  console.error(
+    renderError(
+      "Missing process name/pid",
+      "Usage: fennec restart <name|pid> [-y] [--group <group>]"
+    )
+  );
+  process.exit(1);
+}
+async function restartOne(raw, force, multi) {
   const tracked = readTracked();
   const pidNum = parseInt(raw, 10);
   const trackedEntry = tracked.find((t) => t.name === raw) ?? (!isNaN(pidNum) && String(pidNum) === raw ? tracked.find((t) => t.pid === pidNum) : void 0);
   if (!trackedEntry) {
-    console.error(renderError("Not tracked", `No tracked process named or with PID "${raw}".
-fennec restart only re-spawns Fennec-tracked apps (from their saved config).`));
+    const msg = `No tracked process named or with PID "${raw}".
+fennec restart only re-spawns Fennec-tracked apps (from their saved config).`;
+    if (multi) {
+      console.error(renderError("Not tracked", msg));
+      return;
+    }
+    console.error(renderError("Not tracked", msg));
     process.exit(1);
   }
   const targetPid = trackedEntry.pid;
-  const force = args2.includes("-y") || args2.includes("--yes");
   const confirmed = force || await confirmPrompt(`Restart ${pc11.bold(`${trackedEntry.name} (PID ${targetPid})`)}?`, false);
   if (!confirmed) {
     console.error(`  ${pc11.dim("Cancelled")}`);
     return;
   }
   const spinner = createSpinner(`Stopping ${trackedEntry.name} (PID ${targetPid})...`);
-  const killed = killProcess(targetPid, "SIGTERM");
+  const killed = killTree(targetPid, "SIGTERM");
   if (!killed) {
     spinner.fail(`Failed to stop PID ${targetPid}`);
     return;
@@ -4640,17 +5289,22 @@ fennec restart only re-spawns Fennec-tracked apps (from their saved config).`));
   await new Promise((r) => setTimeout(r, 1e3));
   if (isProcessRunning(targetPid)) {
     spinner.warn("Process didn't stop, sending SIGKILL...");
-    killProcess(targetPid, "SIGKILL");
+    killTree(targetPid, "SIGKILL");
     await new Promise((r) => setTimeout(r, 500));
   }
   spinner.succeed(`${trackedEntry.name} stopped`);
   const respawnSpinner = createSpinner(`Re-spawning ${trackedEntry.name}...`);
   try {
     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 });
+    const logFilePath = logFilePathFor(trackedEntry.name);
+    const child = spawnDaemon({
+      cmdParts,
+      name: trackedEntry.name,
+      cwd: trackedEntry.cwd,
+      logFilePath,
+      env: buildSpawnEnv(trackedEntry.env),
+      logMode: trackedEntry.logMode
+    });
     removeTrackedByPid(targetPid);
     addTracked({
       name: trackedEntry.name,
@@ -4662,12 +5316,72 @@ fennec restart only re-spawns Fennec-tracked apps (from their saved config).`));
       env: trackedEntry.env,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
       autoRestart: trackedEntry.autoRestart,
-      logMode: trackedEntry.logMode
+      logMode: trackedEntry.logMode,
+      group: trackedEntry.group
     });
     respawnSpinner.succeed(`${trackedEntry.name} restarted (PID: ${child.pid})`);
   } catch (error) {
     respawnSpinner.fail(`Failed to re-spawn ${trackedEntry.name}: ${String(error)}`);
-    console.error(`  ${pc11.dim("Config preserved. Re-run manually:")} ${renderCommand(trackedEntry.command)}`);
+    console.error(
+      `  ${pc11.dim("Config preserved. Re-run manually:")} ${renderCommand(trackedEntry.command)}`
+    );
+  }
+}
+async function restartGroup(group, force) {
+  const tracked = readTracked();
+  const inGroup = tracked.filter((t) => t.group === group);
+  if (inGroup.length === 0) {
+    console.error(
+      renderError(
+        "Empty group",
+        `No tracked entries in group "${group}".
+Known groups: ${pc11.cyan(getGroups().join(", ") || "(none)")}`
+      )
+    );
+    process.exit(1);
+  }
+  const confirmed = force || await confirmPrompt(
+    `Restart ${pc11.bold(`${inGroup.length}`)} process(es) in group ${pc11.cyan(group)}?`,
+    false
+  );
+  if (!confirmed) {
+    console.error(`  ${pc11.dim("Cancelled")}`);
+    return;
+  }
+  for (const trackedEntry of inGroup) {
+    const spinner = createSpinner(`Restarting ${trackedEntry.name}...`);
+    try {
+      const cmdParts = resolveArgs(trackedEntry);
+      const logFilePath = logFilePathFor(trackedEntry.name);
+      const child = spawnDaemon({
+        cmdParts,
+        name: trackedEntry.name,
+        cwd: trackedEntry.cwd,
+        logFilePath,
+        env: buildSpawnEnv(trackedEntry.env),
+        logMode: trackedEntry.logMode
+      });
+      removeTrackedByPid(trackedEntry.pid);
+      addTracked({
+        name: trackedEntry.name,
+        pid: child.pid ?? 0,
+        command: trackedEntry.command,
+        args: cmdParts,
+        port: trackedEntry.port,
+        group: trackedEntry.group,
+        cwd: trackedEntry.cwd,
+        env: trackedEntry.env,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        autoRestart: trackedEntry.autoRestart,
+        logMode: trackedEntry.logMode
+      });
+      spinner.succeed(`${trackedEntry.name} restarted (PID: ${child.pid})`);
+    } catch (error) {
+      spinner.fail(`Failed to re-spawn ${trackedEntry.name}: ${String(error)}`);
+      console.error(
+        `  ${pc11.dim("Config preserved. Re-run manually:")} ${renderCommand(trackedEntry.command)}`
+      );
+    }
   }
 }
 
@@ -4676,7 +5390,9 @@ 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>]`));
+    console.error(
+      renderError("Missing PID", `Usage: fennec adopt <pid> [--name <name>] [--port <port>]`)
+    );
     process.exit(1);
   }
   const pid = parseInt(pidArg, 10);
@@ -4689,8 +5405,10 @@ function adoptCommand(args2) {
     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})`)}`);
+  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`);
@@ -4710,7 +5428,10 @@ var SECRET_PATTERNS = [
   // 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 },
+  {
+    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
@@ -4726,9 +5447,15 @@ var SECRET_PATTERNS = [
   // 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 },
+  {
+    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 }
+  {
+    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;
@@ -4846,17 +5573,27 @@ async function inspectCommand(args2) {
     process.exit(1);
   }
   const tracked = readTracked();
-  const proc = tracked.find((t) => t.name === target || parseInt(target, 10) === t.pid && !isNaN(parseInt(target, 10)));
+  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 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 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) {
@@ -4871,13 +5608,18 @@ async function inspectCommand(args2) {
   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))}`);
+    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))}`);
+      for (const l of errorLines.slice(-8))
+        console.error(`  ${pc13.red(stripAnsi(l).slice(0, 300))}`);
     }
     console.error();
     return;
@@ -4904,7 +5646,7 @@ async function inspectCommand(args2) {
 // 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 { resolve as resolve6, dirname as dirname5 } from "path";
 import "os";
 import yaml from "js-yaml";
 function loadConfig(path) {
@@ -4923,7 +5665,7 @@ function loadConfig(path) {
 }
 function resolveCwd(baseDir, cwd) {
   if (!cwd) return baseDir;
-  return resolve7(baseDir, cwd);
+  return resolve6(baseDir, cwd);
 }
 async function waitForPort(port, timeoutMs = 3e4) {
   const deadline = Date.now() + timeoutMs;
@@ -4972,7 +5714,7 @@ async function startApp(app, baseDir) {
   const wasRunning = !!(existing && isTrackedRunning(existing));
   if (wasRunning) {
     try {
-      process.kill(existing.pid, "SIGTERM");
+      killTree(existing.pid, "SIGTERM");
     } catch {
     }
   }
@@ -5014,7 +5756,7 @@ async function startApp(app, baseDir) {
 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");
+  const configPath = configIndex !== -1 ? resolve6(args2[configIndex + 1]) : resolve6(process.cwd(), "fennec.config.yaml");
   if (sub === "down") {
     return devDown();
   }
@@ -5025,7 +5767,9 @@ async function devCommand(args2) {
     return devRestart(args2.slice(1));
   }
   if (sub !== "up") {
-    console.error(renderError("Unknown sub-command", `"${sub}" \u2014 use: up | down | status | restart`));
+    console.error(
+      renderError("Unknown sub-command", `"${sub}" \u2014 use: up | down | status | restart`)
+    );
     process.exit(1);
   }
   const config = loadConfig(configPath);
@@ -5043,14 +5787,18 @@ async function devCommand(args2) {
     if (p) {
       const prev = portOwner.get(p);
       if (prev) {
-        console.error(renderError("Port conflict", `apps "${prev}" and "${a.name}" both declare port :${p}`));
+        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}`)}`);
+  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) {
@@ -5061,7 +5809,10 @@ async function devCommand(args2) {
         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)`)}`);
+        if (!ok)
+          console.error(
+            `  ${pc14.yellow("\u26A0")} ${pc14.dim(`${dep} :${port} not ready in time (continuing)`)}`
+          );
       }
     }
     const res = await startApp(app, baseDir);
@@ -5069,8 +5820,10 @@ async function devCommand(args2) {
     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.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).")}
 `);
 }
@@ -5082,20 +5835,24 @@ function devDown() {
 `);
     return;
   }
-  console.error(`
-  ${symbols.fox} ${pc14.bold("fennec dev down")} ${pc14.dim(`\u2014 stopping ${tracked.length} app(s)`)}`);
+  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");
+      if (isTrackedRunning(t)) killTree(t.pid, "SIGTERM");
     } catch {
     }
     t.autoRestart = false;
     addTracked({ ...t, autoRestart: false });
     console.error(`  ${pc14.red("\u25A0")} ${pc14.bold(t.name)}`);
   }
-  console.error(`
+  console.error(
+    `
   ${pc14.green("\u2713")} Stack stopped (auto-restart disabled). Use ${pc14.cyan("fennec dev up")} to bring it back.
-`);
+`
+  );
 }
 function devRestart(names) {
   ensureSupervisorRunning();
@@ -5104,7 +5861,12 @@ function devRestart(names) {
   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.`));
+    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(`
@@ -5112,14 +5874,18 @@ function devRestart(names) {
 `);
     return;
   }
-  console.error(`
-  ${symbols.fox} ${pc14.bold("fennec dev restart")} ${pc14.dim(`\u2014 ${targets.length} app(s)`)}`);
+  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(
+        `  ${pc14.red("\u2717")} ${pc14.bold(t.name)} ${pc14.dim(`restart failed: ${String(err)}`)}`
+      );
     }
   }
   console.error();
@@ -5165,7 +5931,15 @@ function topoOrder(apps) {
 }
 
 // src/commands/log.ts
-import { existsSync as existsSync9, unlinkSync as unlinkSync3, statSync as statSync2, openSync as openSync3, fstatSync, readSync, closeSync as closeSync3 } from "fs";
+import {
+  existsSync as existsSync9,
+  unlinkSync as unlinkSync3,
+  statSync as statSync3,
+  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;
@@ -5189,14 +5963,21 @@ async function logCommand(args2) {
     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`));
+    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)));
+  const trackedMatch = tracked.find(
+    (t) => t.name === target || parseInt(target, 10) === t.pid && !isNaN(parseInt(target, 10))
+  );
   if (trackedMatch) {
     displayName = trackedMatch.name;
     logFilePath = logFilePathFor(trackedMatch.name);
@@ -5209,16 +5990,20 @@ async function logCommand(args2) {
   }
   if (clearFlag) {
     if (!logFilePath || !existsSync9(logFilePath)) {
-      console.error(`
+      console.error(
+        `
   ${pc15.yellow("\u26A0")} ${pc15.dim("No log file found for")} ${pc15.bold(displayName)}
-`);
+`
+      );
       process.exit(0);
     }
     try {
       unlinkSync3(logFilePath);
-      console.error(`
+      console.error(
+        `
   ${pc15.green("\u2713")} ${pc15.bold("Log cleared")} ${pc15.dim(`\u2014 ${logFilePath}`)}
-`);
+`
+      );
     } catch (err) {
       console.error(renderError("Failed to clear log", String(err)));
       process.exit(1);
@@ -5238,7 +6023,10 @@ async function logCommand(args2) {
       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 });
+          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)"];
@@ -5253,7 +6041,10 @@ async function logCommand(args2) {
     }
     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 redactedHits = sliced.reduce(
+      (acc, l) => acc + (redactionCount(stripAnsi(l)) > 0 ? 1 : 0),
+      0
+    );
     const payload = {
       app: displayName,
       running,
@@ -5275,7 +6066,9 @@ async function logCommand(args2) {
     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.")}`);
+      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}...`);
@@ -5292,7 +6085,10 @@ async function logCommand(args2) {
       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 });
+          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)"];
@@ -5307,8 +6103,10 @@ async function logCommand(args2) {
     }
     spinner.stop();
     process.stdout.write("\r\x1B[K");
-    console.error(`
-  ${symbols.fox} ${pc15.bold("Logs")} ${renderAppName(displayName)} ${pc15.dim(`(last ${logLines.length} line${logLines.length !== 1 ? "s" : ""})${redact ? pc15.dim(" \xB7 secrets redacted") : ""})`)}`);
+    console.error(
+      `
+  ${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;
@@ -5334,7 +6132,7 @@ async function logCommand(args2) {
 async function followLog(logFilePath, opts) {
   let lastSize = 0;
   try {
-    lastSize = statSync2(logFilePath).size;
+    lastSize = statSync3(logFilePath).size;
   } catch {
   }
   console.error(`
@@ -5384,10 +6182,10 @@ async function followLog(logFilePath, opts) {
       closeSync3(fd);
     }
   }, 400);
-  await new Promise((resolve13) => {
+  await new Promise((resolve12) => {
     const stop = () => {
       clearInterval(timer);
-      resolve13();
+      resolve12();
     };
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
@@ -5398,8 +6196,10 @@ function listAvailableApps() {
   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>")}
-`);
+    console.error(
+      `  ${pc15.dim("Start one with:")} ${pc15.cyan("fennec start <command> --name <name>")}
+`
+    );
     return;
   }
   console.error(`
@@ -5411,12 +6211,18 @@ function listAvailableApps() {
     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.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.")}
-`);
+  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
@@ -5451,37 +6257,253 @@ async function attachCommand(args2) {
   }
 }
 
-// src/commands/sessions.ts
-import { SessionStore } from "@plumpslabs/fennec-core";
+// src/commands/store.ts
+import { StoreManager, redactSession } from "@plumpslabs/fennec-core";
+import "@plumpslabs/fennec-core";
 import pc17 from "picocolors";
-async function sessionsCommand() {
-  const store = new SessionStore("./.fennec/sessions");
-  const sessions = store.list();
-  if (sessions.length === 0) {
+var KINDS = ["session", "process", "workflow", "plugin", "config", "export"];
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+function formatAge(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h`;
+  return `${Math.floor(h / 24)}d`;
+}
+async function storeCommand(args2) {
+  const local = args2.includes("--local");
+  const showSecrets = args2.includes("--show-secrets");
+  const yes = args2.includes("-y") || args2.includes("--yes");
+  const positional = [];
+  for (const a of args2) {
+    if (a.startsWith("--") || a === "-y") continue;
+    positional.push(a);
+  }
+  const kind = positional[0];
+  const action = positional[1];
+  const name = positional[2];
+  const mgr = new StoreManager(local);
+  mgr.ensure();
+  if (!kind) {
+    const scan = mgr.scan();
+    console.error(
+      `
+  ${symbols.fox} ${pc17.bold("Fennec Store")} ${pc17.dim(local ? "(local ./.fennec)" : "(global)")}
+`
+    );
+    const columns = [
+      { key: "kind", label: "Kind", format: (v) => pc17.bold(String(v)) },
+      { key: "count", label: "Items", format: (v) => pc17.cyan(String(v)) },
+      { key: "size", label: "Size", format: (v) => pc17.dim(formatBytes(Number(v))) },
+      { key: "oldest", label: "Oldest", format: (v) => pc17.dim(formatAge(Number(v))) }
+    ];
+    const rows = scan.map((e) => ({
+      kind: e.kind,
+      count: e.count,
+      size: e.sizeBytes,
+      oldest: e.oldestMs
+    }));
+    console.error(renderTable(columns, rows));
+    console.error(`  ${pc17.dim(mgr.base)}
+`);
+    return;
+  }
+  if (!KINDS.includes(kind)) {
+    console.error(renderError("Unknown kind", `Kind must be one of: ${KINDS.join(", ")}`));
+    process.exit(1);
+  }
+  if (kind !== "session") {
+    const entry = mgr.scan().find((e) => e.kind === kind);
     console.error(`
-  ${pc17.dim("No saved sessions found.")}
+  ${pc17.bold(kind)} ${pc17.dim(`(${entry?.count ?? 0} item(s))`)}
+`);
+    console.error(`  ${pc17.dim(mgr.dirFor(kind))}
+`);
+    const tip = kind === "process" ? "Managed via `fennec ps` / `fennec kill` / `fennec restart`." : kind === "export" ? "Created by `fennec export` / `fennec import`." : "Read-only in this view (Phase 2).";
+    console.error(`  ${pc17.dim(tip)}
 `);
     return;
   }
-  const columns = [
-    { key: "name", label: "Name", format: (v) => pc17.bold(String(v)) },
-    { key: "origin", label: "Origin" },
-    { 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(`
+  const store = mgr.sessionStore();
+  if (!action || action === "ls" || action === "list") {
+    const sessions = store.list();
+    if (sessions.length === 0) {
+      console.error(
+        `
+  ${pc17.dim(`No saved sessions found${local ? " in ./.fennec/sessions" : " in the global store"}.`)}
+`
+      );
+      return;
+    }
+    const columns = [
+      { key: "name", label: "Name", format: (v) => pc17.bold(String(v)) },
+      { key: "origin", label: "Origin" },
+      { 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} ${pc17.bold("Saved Sessions")}
 `);
-  console.error(renderTable(columns, rows));
-  console.error(`  ${pc17.dim(`${sessions.length} session(s)`)}
+    console.error(renderTable(columns, rows));
+    console.error(`  ${pc17.dim(`${sessions.length} session(s)`)}
+`);
+    return;
+  }
+  if (action === "info") {
+    if (!name) {
+      console.error(
+        renderError("Missing name", "Usage: fennec store session info <name> [--show-secrets]")
+      );
+      process.exit(1);
+    }
+    const session = store.load(name);
+    if (!session) {
+      console.error(
+        renderError(
+          "Session not found",
+          `No session named "${name}". Use 'fennec store session' to list.`
+        )
+      );
+      process.exit(1);
+    }
+    const shown = showSecrets ? session : redactSession(session);
+    const cookieDomains = shown.cookies.map((c) => String(c.domain ?? c.name ?? "?")).filter((v, i, a) => a.indexOf(v) === i);
+    let body = "";
+    body += renderKV("Name", shown.name);
+    body += renderKV("Origin", shown.origin);
+    body += renderKV("Saved", new Date(shown.savedAt).toLocaleString());
+    if (shown.metadata) {
+      for (const [k, v] of Object.entries(shown.metadata)) body += renderKV(k, String(v));
+    }
+    body += renderKV(
+      "Cookies",
+      `${shown.cookies.length} (domains: ${cookieDomains.join(", ") || "-"})`
+    );
+    body += renderKV("localStorage keys", String(Object.keys(shown.localStorage).length));
+    body += renderKV("Values", showSecrets ? "shown" : pc17.dim("masked \u2014 use --show-secrets"));
+    console.error(`
+  ${pc17.bold(`Session: ${shown.name}`)}
 `);
+    console.error(renderSection("Details", body));
+    return;
+  }
+  if (action === "rm" || action === "remove" || action === "delete") {
+    if (!name) {
+      console.error(renderError("Missing name", "Usage: fennec store session rm <name>"));
+      process.exit(1);
+    }
+    if (!store.load(name)) {
+      console.error(renderError("Session not found", `No session named "${name}".`));
+      process.exit(1);
+    }
+    const confirmed = yes || await confirmPrompt(`Delete session ${pc17.bold(name)}?`, false);
+    if (!confirmed) {
+      console.error(`  ${pc17.dim("Cancelled")}`);
+      return;
+    }
+    const ok = store.delete(name);
+    console.error(
+      ok ? `  ${pc17.green("\u2713")} ${pc17.bold(name)} deleted
+` : `  ${pc17.red("\u2717")} failed to delete ${pc17.bold(name)}
+`
+    );
+    return;
+  }
+  console.error(renderError("Unknown action", "Actions: ls | info <name> | rm <name>"));
+  process.exit(1);
 }
 
-// src/commands/setup.ts
+// src/commands/doctor.ts
+import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { join } from "path";
+import { execSync as execSync3 } from "child_process";
+import { StoreManager as StoreManager2 } from "@plumpslabs/fennec-core";
 import pc18 from "picocolors";
+async function doctorCommand() {
+  const mgr = new StoreManager2(false);
+  const base = mgr.base;
+  const problems = [];
+  const notes = [];
+  if (!mgr.permsSafe()) {
+    problems.push(`Store dir is group/other readable: ${base}
+      Fix: chmod 700 ${base}`);
+  }
+  if (StoreManager2.isSynced(base)) {
+    problems.push(
+      `Store lives under a synced directory: ${base}
+      Auth cookies/tokens in sessions + process launch commands could leak across machines.
+      Prefer a non-synced location (FENNEC_HOME=/non-synced/fennec) or use --local with care.`
+    );
+  }
+  const scan = mgr.scan();
+  const sess = scan.find((s) => s.kind === "session");
+  if (sess && sess.count > 0) {
+    notes.push(
+      `${sess.count} auth session(s) with cookies/localStorage stored on disk.
+      Values are masked by default in 'fennec store session info'; use --show-secrets to reveal.`
+    );
+  }
+  const proc = scan.find((s) => s.kind === "process");
+  if (proc && proc.count > 0) {
+    const tracked = mgr.fileFor("process", "");
+    const cmds = existsSync10(tracked) ? JSON.parse(readFileSync9(tracked, "utf-8")) : [];
+    const secretCmds = cmds.filter(
+      (c) => c.command && /(?:^|[\s;|&])([A-Za-z_][A-Za-z0-9_]*)=/.test(c.command)
+    ).length;
+    if (secretCmds > 0) {
+      notes.push(
+        `${secretCmds} tracked process launch command(s) may embed secrets (KEY=value).
+      Stored in ${tracked} \u2014 keep the store out of synced/committed locations.`
+      );
+    }
+  }
+  const localFen = join(process.cwd(), ".fennec");
+  if (existsSync10(localFen)) {
+    let ignored = false;
+    try {
+      execSync3("git check-ignore -q .fennec", { cwd: process.cwd(), stdio: "ignore" });
+      ignored = true;
+    } catch (err) {
+      ignored = err?.code === "ENOENT";
+    }
+    if (!ignored) {
+      problems.push(
+        `Local ./.fennec exists here and is NOT gitignored.
+      It can hold sessions + tracked processes \u2014 add '.fennec/' to .gitignore or remove it.`
+      );
+    }
+  }
+  console.error(`
+  ${pc18.bold("Fennec Doctor")}
+`);
+  console.error(`  ${pc18.dim("Store:")} ${base}
+`);
+  if (problems.length === 0 && notes.length === 0) {
+    console.error(`  ${pc18.green("\u2713")} No issues found.
+`);
+    return;
+  }
+  for (const p of problems) console.error(`  ${pc18.red("\u2717")} ${p}
+`);
+  for (const n of notes) console.error(`  ${pc18.yellow("!")} ${n}
+`);
+}
+
+// src/commands/setup.ts
+import pc19 from "picocolors";
 async function setupCommand() {
   console.error(`
-  ${symbols.fox} ${pc18.bold("Fennec Setup")}
+  ${symbols.fox} ${pc19.bold("Fennec Setup")}
 `);
   const mcpClient = await selectPrompt("Which MCP client are you using?", [
     { value: "claude", label: "Claude Desktop", description: "Anthropic's AI desktop app" },
@@ -5490,12 +6512,12 @@ async function setupCommand() {
     { value: "other", label: "Other MCP client", description: "Any MCP-compatible client" }
   ]);
   if (!mcpClient) {
-    console.error(`  ${pc18.dim("Setup cancelled.")}
+    console.error(`  ${pc19.dim("Setup cancelled.")}
 `);
     return;
   }
   console.error(`
-  ${pc18.green("\u2713")} Selected: ${pc18.bold(mcpClient)}
+  ${pc19.green("\u2713")} Selected: ${pc19.bold(mcpClient)}
 `);
   const configSnippet = `{
   "mcpServers": {
@@ -5505,46 +6527,55 @@ async function setupCommand() {
     }
   }
 }`;
-  console.error(`  ${pc18.bold("Add this to your MCP client config:")}
-`);
-  console.error(`  ${pc18.dim("```")}`);
-  console.error(configSnippet.split("\n").map((l) => `  ${l}`).join("\n"));
-  console.error(`  ${pc18.dim("```")}
+  console.error(`  ${pc19.bold("Add this to your MCP client config:")}
 `);
-  console.error(`  ${renderSuccess("Setup complete!")} ${pc18.dim("Run")} ${renderCommand("fennec start")} ${pc18.dim("to begin.")}
+  console.error(`  ${pc19.dim("```")}`);
+  console.error(
+    configSnippet.split("\n").map((l) => `  ${l}`).join("\n")
+  );
+  console.error(`  ${pc19.dim("```")}
 `);
+  console.error(
+    `  ${renderSuccess("Setup complete!")} ${pc19.dim("Run")} ${renderCommand("fennec start")} ${pc19.dim("to begin.")}
+`
+  );
 }
 
 // src/commands/management.ts
-import { existsSync as existsSync10, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve8 } from "path";
-import { execSync as execSync3 } from "child_process";
-import pc19 from "picocolors";
+import { existsSync as existsSync11, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve7 } from "path";
+import { execSync as execSync4 } from "child_process";
+import pc20 from "picocolors";
 async function installBrowsersCommand() {
   console.error(`
-  ${pc19.bold("Installing Browser Engines")}
+  ${pc20.bold("Installing Browser Engines")}
 `);
   const spinner = createSpinner("Installing Chromium...");
   try {
-    execSync3("npx playwright install chromium", { stdio: "pipe", timeout: 12e4 });
+    execSync4("npx playwright install chromium", { stdio: "pipe", timeout: 12e4 });
     spinner.succeed("Chromium installed successfully");
   } catch {
     spinner.fail("Failed to install Chromium");
-    console.error(`  ${pc19.yellow("\u2192")} Try running: ${renderCommand("npx playwright install chromium")}`);
+    console.error(
+      `  ${pc20.yellow("\u2192")} Try running: ${renderCommand("npx playwright install chromium")}`
+    );
   }
   console.error(`
-  ${pc19.green("\u2713")} Browser installation complete.
+  ${pc20.green("\u2713")} Browser installation complete.
 `);
 }
 async function initCommand() {
   console.error(`
-  ${pc19.bold("Initialize Fennec Configuration")}
+  ${pc20.bold("Initialize Fennec Configuration")}
 `);
-  const configFile = resolve8("./fennec.config.yaml");
-  if (existsSync10(configFile)) {
-    const overwrite = await confirmPrompt(`${pc19.yellow("fennec.config.yaml")} already exists. Overwrite?`, false);
+  const configFile = resolve7("./fennec.config.yaml");
+  if (existsSync11(configFile)) {
+    const overwrite = await confirmPrompt(
+      `${pc20.yellow("fennec.config.yaml")} already exists. Overwrite?`,
+      false
+    );
     if (!overwrite) {
-      console.error(`  ${pc19.dim("Cancelled.")}
+      console.error(`  ${pc20.dim("Cancelled.")}
 `);
       return;
     }
@@ -5624,44 +6655,44 @@ logging:
   file: null
 `;
   writeFileSync4(configFile, config, "utf-8");
-  spinner.succeed(`Configuration written to ${pc19.bold(configFile)}`);
+  spinner.succeed(`Configuration written to ${pc20.bold(configFile)}`);
   console.error(`
-  ${pc19.dim("Edit the file to customize Fennec behavior.")}
+  ${pc20.dim("Edit the file to customize Fennec behavior.")}
 `);
 }
 
 // src/commands/health.ts
-import { existsSync as existsSync11, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { execSync as execSync4 } from "child_process";
-import { resolve as resolve9 } from "path";
-import { homedir as homedir6 } from "os";
-import pc20 from "picocolors";
+import { existsSync as existsSync12, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+import { execSync as execSync5 } from "child_process";
+import { resolve as resolve8 } from "path";
+import { homedir as homedir5 } from "os";
+import pc21 from "picocolors";
 async function healthCommand() {
   printBanner();
-  console.error(`  ${pc20.bold("Fennec Health Check")}
+  console.error(`  ${pc21.bold("Fennec Health Check")}
 `);
   let adbStatus = "unknown";
   try {
-    const result = execSync4("adb --version", {
+    const result = execSync5("adb --version", {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "pipe"]
     });
     const version = result.split("\n")[0]?.trim() ?? "installed";
-    adbStatus = pc20.green(version);
+    adbStatus = pc21.green(version);
   } catch {
-    adbStatus = pc20.dim("not found") + " (optional)";
+    adbStatus = pc21.dim("not found") + " (optional)";
   }
   const tracked = readTracked();
   const runningCount = tracked.filter((t) => isProcessRunning(t.pid)).length;
-  const logDir = resolve9(homedir6(), ".fennec", "logs");
+  const logDir = resolve8(homedir5(), ".fennec", "logs");
   let logSize = "0 B";
   try {
-    if (existsSync11(logDir)) {
+    if (existsSync12(logDir)) {
       const files = readdirSync2(logDir);
       let totalBytes = 0;
       for (const f of files) {
-        const fStat = statSync3(resolve9(logDir, f));
+        const fStat = statSync4(resolve8(logDir, f));
         totalBytes += fStat.size;
       }
       logSize = totalBytes > 1024 * 1024 ? `${(totalBytes / (1024 * 1024)).toFixed(1)} MB` : `${(totalBytes / 1024).toFixed(1)} KB`;
@@ -5674,7 +6705,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} ${pc20.bold("System")}
+  console.error(`  ${symbols.fox} ${pc21.bold("System")}
 `);
   console.error(`  ${renderKV("Node.js", process.version)}`);
   console.error(`  ${renderKV("Platform", `${process.platform} ${process.arch}`)}`);
@@ -5682,7 +6713,7 @@ async function healthCommand() {
   console.error(`  ${renderKV("ADB", adbStatus)}`);
   console.error(`  ${renderKV("PID", String(process.pid))}`);
   console.error();
-  console.error(`  ${symbols.fox} ${pc20.bold("Processes")}
+  console.error(`  ${symbols.fox} ${pc21.bold("Processes")}
 `);
   console.error(`  ${renderKV("Tracked", String(tracked.length))}`);
   console.error(`  ${renderKV("Running", String(runningCount))}`);
@@ -5690,56 +6721,67 @@ async function healthCommand() {
   console.error();
   const allHealthy = runningCount === tracked.length || tracked.length === 0;
   if (allHealthy) {
-    console.error(`  ${pc20.green("\u2713")} ${pc20.bold("All systems healthy")}
+    console.error(`  ${pc21.green("\u2713")} ${pc21.bold("All systems healthy")}
 `);
   } else {
     const stopped = tracked.length - runningCount;
-    console.error(`  ${pc20.yellow("\u26A0")} ${pc20.bold(`${stopped} process(es) stopped`)}  ${pc20.dim("fennec ps")}
-`);
+    console.error(
+      `  ${pc21.yellow("\u26A0")} ${pc21.bold(`${stopped} process(es) stopped`)}  ${pc21.dim("fennec ps")}
+`
+    );
   }
 }
 
 // src/commands/cleanup.ts
-import pc21 from "picocolors";
+import pc22 from "picocolors";
 async function cleanupCommand() {
   const tracked = readTracked();
   if (tracked.length === 0) {
     console.error(`
-  ${pc21.dim("No tracked processes to clean up.")}
+  ${pc22.dim("No tracked processes to clean up.")}
 `);
     return;
   }
   const toRemove = tracked.filter((t) => !isProcessRunning(t.pid) && !t.command);
   if (toRemove.length === 0) {
-    console.error(`
-  ${pc21.green("\u2713")} ${pc21.bold("All clean")} ${pc21.dim("\u2014 no dead entries without saved commands.")}
-`);
+    console.error(
+      `
+  ${pc22.green("\u2713")} ${pc22.bold("All clean")} ${pc22.dim("\u2014 no dead entries without saved commands.")}
+`
+    );
     return;
   }
-  console.error(`
-  ${pc21.yellow("\u26A0")} ${pc21.bold(`Found ${toRemove.length} dead entr${toRemove.length > 1 ? "ies" : "y"} without saved commands`)}
-`);
+  console.error(
+    `
+  ${pc22.yellow("\u26A0")} ${pc22.bold(`Found ${toRemove.length} dead entr${toRemove.length > 1 ? "ies" : "y"} without saved commands`)}
+`
+  );
   for (const entry of toRemove) {
-    console.error(`  ${pc21.dim("\xB7")} ${pc21.bold(entry.name)} ${pc21.dim(`(PID ${entry.pid})`)}`);
+    console.error(`  ${pc22.dim("\xB7")} ${pc22.bold(entry.name)} ${pc22.dim(`(PID ${entry.pid})`)}`);
   }
   console.error();
-  const confirmed = await confirmPrompt(`Remove ${toRemove.length} entr${toRemove.length > 1 ? "ies" : "y"}?`, false);
+  const confirmed = await confirmPrompt(
+    `Remove ${toRemove.length} entr${toRemove.length > 1 ? "ies" : "y"}?`,
+    false
+  );
   if (!confirmed) {
-    console.error(`  ${pc21.dim("Cancelled")}
+    console.error(`  ${pc22.dim("Cancelled")}
 `);
     return;
   }
   const remaining = tracked.filter((t) => !toRemove.includes(t));
   saveTracked(remaining);
-  console.error(`
-  ${pc21.green("\u2713")} ${pc21.bold(`Removed ${toRemove.length} entr${toRemove.length > 1 ? "ies" : "y"}`)} ${pc21.dim(`(${remaining.length} remaining)`)}
-`);
+  console.error(
+    `
+  ${pc22.green("\u2713")} ${pc22.bold(`Removed ${toRemove.length} entr${toRemove.length > 1 ? "ies" : "y"}`)} ${pc22.dim(`(${remaining.length} remaining)`)}
+`
+  );
 }
 
 // src/commands/info.ts
-import pc22 from "picocolors";
-import { resolve as resolve10 } from "path";
-import { homedir as homedir7 } from "os";
+import pc23 from "picocolors";
+import { resolve as resolve9 } from "path";
+import { homedir as homedir6 } from "os";
 async function infoCommand(args2) {
   const name = args2[0];
   if (!name) {
@@ -5753,34 +6795,34 @@ async function infoCommand(args2) {
     process.exit(1);
   }
   const running = isProcessRunning(match.pid);
-  const statusIcon = running ? pc22.green("\u25CF") : pc22.red("\u25CB");
-  const statusText = running ? pc22.green("running") : pc22.red("stopped");
+  const statusIcon = running ? pc23.green("\u25CF") : pc23.red("\u25CB");
+  const statusText = running ? pc23.green("running") : pc23.red("stopped");
   const uptime = running ? formatUptime(Math.floor((Date.now() - new Date(match.startedAt).getTime()) / 1e3)) : "-";
-  const logPath = resolve10(homedir7(), ".fennec", "logs", `${match.name}.log`);
+  const logPath = resolve9(homedir6(), ".fennec", "logs", `${match.name}.log`);
   console.error(`
-  ${symbols.fox} ${pc22.bold(match.name)} ${pc22.dim("\u2014 Process Info")}
+  ${symbols.fox} ${pc23.bold(match.name)} ${pc23.dim("\u2014 Process Info")}
 `);
-  console.error(`  ${renderKVColor("Name", match.name, pc22.bold)}`);
+  console.error(`  ${renderKVColor("Name", match.name, pc23.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 || pc22.dim("(none)"))}`);
+  console.error(`  ${renderKVColor("Command", match.command || pc23.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(`
-  ${pc22.dim("Re-spawn with:")} ${pc22.cyan(`fennec spawn ${match.name}`)}`);
+  ${pc23.dim("Re-spawn with:")} ${pc23.cyan(`fennec spawn ${match.name}`)}`);
   }
   console.error();
 }
 
 // src/commands/rename.ts
-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";
+import pc24 from "picocolors";
+import { existsSync as existsSync13, renameSync as renameSync2 } from "fs";
+import { resolve as resolve10 } from "path";
+import { homedir as homedir7 } from "os";
 async function renameCommand(args2) {
   const [oldName, newName] = args2;
   if (!oldName || !newName) {
@@ -5789,7 +6831,7 @@ async function renameCommand(args2) {
   }
   if (oldName === newName) {
     console.error(`
-  ${pc23.yellow("\u26A0")} ${pc23.dim("Old and new names are the same.")}
+  ${pc24.yellow("\u26A0")} ${pc24.dim("Old and new names are the same.")}
 `);
     process.exit(0);
   }
@@ -5804,25 +6846,30 @@ async function renameCommand(args2) {
     process.exit(1);
   }
   console.error(`
-  ${symbols.fox} ${pc23.bold("Rename Process")}
+  ${symbols.fox} ${pc24.bold("Rename Process")}
 `);
   console.error(`  ${renderKVColor("From", oldName)}`);
   console.error(`  ${renderKVColor("To", newName)}`);
   if (isProcessRunning(match.pid)) {
-    console.error(`  ${pc23.yellow("\u26A0")} ${pc23.dim("Process is still running \u2014 log entries will go to the old file until stopped.")}`);
+    console.error(
+      `  ${pc24.yellow("\u26A0")} ${pc24.dim("Process is still running \u2014 log entries will go to the old file until stopped.")}`
+    );
   }
   console.error();
-  const confirmed = await confirmPrompt(`Rename ${pc23.bold(oldName)} ${pc23.dim("\u2192")} ${pc23.bold(newName)}?`, true);
+  const confirmed = await confirmPrompt(
+    `Rename ${pc24.bold(oldName)} ${pc24.dim("\u2192")} ${pc24.bold(newName)}?`,
+    true
+  );
   if (!confirmed) {
-    console.error(`  ${pc23.dim("Cancelled")}
+    console.error(`  ${pc24.dim("Cancelled")}
 `);
     return;
   }
   const spinner = createSpinner(`Renaming ${oldName} \u2192 ${newName}...`);
-  const logDir = resolve11(homedir8(), ".fennec", "logs");
-  const oldLog = resolve11(logDir, `${oldName}.log`);
-  const newLog = resolve11(logDir, `${newName}.log`);
-  if (existsSync12(oldLog) && !existsSync12(newLog)) {
+  const logDir = resolve10(homedir7(), ".fennec", "logs");
+  const oldLog = resolve10(logDir, `${oldName}.log`);
+  const newLog = resolve10(logDir, `${newName}.log`);
+  if (existsSync13(oldLog) && !existsSync13(newLog)) {
     try {
       renameSync2(oldLog, newLog);
     } catch {
@@ -5830,14 +6877,14 @@ async function renameCommand(args2) {
   }
   match.name = newName;
   saveTracked(tracked);
-  spinner.succeed(`${pc23.bold(oldName)} ${pc23.dim("\u2192")} ${pc23.bold(newName)}`);
+  spinner.succeed(`${pc24.bold(oldName)} ${pc24.dim("\u2192")} ${pc24.bold(newName)}`);
   console.error();
 }
 
 // src/commands/export-import.ts
-import pc24 from "picocolors";
-import { existsSync as existsSync13, writeFileSync as writeFileSync5, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve12 } from "path";
+import pc25 from "picocolors";
+import { existsSync as existsSync14, writeFileSync as writeFileSync5, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve11 } from "path";
 async function exportCommand(args2) {
   const tracked = readTracked();
   const fileIndex = args2.indexOf("--file");
@@ -5848,17 +6895,19 @@ async function exportCommand(args2) {
   }
   if (tracked.length === 0) {
     console.error(`
-  ${pc24.dim("No tracked processes to export.")}
+  ${pc25.dim("No tracked processes to export.")}
 `);
     return;
   }
   const json = JSON.stringify(tracked, null, 2);
   if (filePath) {
     try {
-      writeFileSync5(resolve12(filePath), json, "utf-8");
-      console.error(`
-  ${pc24.green("\u2713")} ${pc24.bold(`Exported ${tracked.length} process(es)`)} ${pc24.dim(`\u2192 ${filePath}`)}
-`);
+      writeFileSync5(resolve11(filePath), json, "utf-8");
+      console.error(
+        `
+  ${pc25.green("\u2713")} ${pc25.bold(`Exported ${tracked.length} process(es)`)} ${pc25.dim(`\u2192 ${filePath}`)}
+`
+      );
     } catch (err) {
       console.error(renderError("Export failed", String(err)));
       process.exit(1);
@@ -5873,16 +6922,18 @@ async function importCommand(args2) {
     console.error(renderError("Missing file", "Usage: fennec import <file>"));
     process.exit(1);
   }
-  const resolvedPath = resolve12(filePath);
-  if (!existsSync13(resolvedPath)) {
+  const resolvedPath = resolve11(filePath);
+  if (!existsSync14(resolvedPath)) {
     console.error(renderError("File not found", `"${filePath}" does not exist.`));
     process.exit(1);
   }
   let imported;
   try {
-    imported = JSON.parse(readFileSync9(resolvedPath, "utf-8"));
+    imported = JSON.parse(readFileSync10(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."));
+      console.error(
+        renderError("Invalid file", "File must contain a non-empty JSON array of process objects.")
+      );
       process.exit(1);
     }
   } catch (err) {
@@ -5891,20 +6942,23 @@ async function importCommand(args2) {
   }
   const existing = readTracked();
   console.error(`
-  ${symbols.fox} ${pc24.bold("Import Processes")}
+  ${symbols.fox} ${pc25.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(`
-  ${pc24.bold("Processes to import:")}`);
+  ${pc25.bold("Processes to import:")}`);
   for (const p of imported) {
-    console.error(`  ${pc24.green("+")} ${pc24.bold(p.name)} ${pc24.dim(`(${p.command})`)}`);
+    console.error(`  ${pc25.green("+")} ${pc25.bold(p.name)} ${pc25.dim(`(${p.command})`)}`);
   }
   console.error();
-  const confirmed = await confirmPrompt("Merge into tracked.json? Existing processes with the same name will be overwritten.", true);
+  const confirmed = await confirmPrompt(
+    "Merge into tracked.json? Existing processes with the same name will be overwritten.",
+    true
+  );
   if (!confirmed) {
-    console.error(`  ${pc24.dim("Cancelled")}
+    console.error(`  ${pc25.dim("Cancelled")}
 `);
     return;
   }
@@ -5918,8 +6972,108 @@ async function importCommand(args2) {
     }
   }
   saveTracked(merged);
-  console.error(`  ${pc24.green("\u2713")} ${pc24.bold(`Imported ${imported.length} process(es)`)} ${pc24.dim(`(${merged.length} total)`)}
+  console.error(
+    `  ${pc25.green("\u2713")} ${pc25.bold(`Imported ${imported.length} process(es)`)} ${pc25.dim(`(${merged.length} total)`)}
+`
+  );
+}
+
+// src/commands/group.ts
+import pc26 from "picocolors";
+async function groupCommand(args2) {
+  const positional = args2.filter((a) => !a.startsWith("-") && !a.includes("="));
+  const unset = args2.includes("--unset");
+  if (positional.length === 0) {
+    const tracked = readTracked();
+    if (tracked.length === 0) {
+      console.error(`
+  ${pc26.dim("No tracked processes.")}
 `);
+      return;
+    }
+    const columns = [
+      { key: "name", label: "App", format: (v) => pc26.bold(String(v)) },
+      {
+        key: "group",
+        label: "Group",
+        format: (v) => {
+          const g = String(v);
+          return g === "-" ? pc26.dim("-") : pc26.cyan(g);
+        }
+      },
+      {
+        key: "command",
+        label: "Command",
+        format: (v) => {
+          const c = String(v);
+          return c.length > 50 ? c.slice(0, 50) + "\u2026" : c;
+        }
+      }
+    ];
+    const rows = tracked.map((t) => ({
+      name: t.name,
+      group: t.group ?? "-",
+      command: t.command
+    }));
+    console.error(
+      `
+  ${pc26.bold("Fennec Apps by Group")} ${pc26.dim(`(${getGroups().length} group(s))`)}
+`
+    );
+    console.error(renderTable(columns, rows));
+    console.error(`  ${pc26.dim("Assign one:")} ${pc26.cyan("fennec group <name> <group>")}`);
+    console.error(
+      `  ${pc26.dim("Assign bulk:")} ${pc26.cyan("fennec group <group> <name...>")}  ${pc26.dim("Clear:")} ${pc26.cyan("fennec group <name> --unset")}`
+    );
+    console.error();
+    return;
+  }
+  if (unset) {
+    const name = positional[0];
+    const ok = setGroup(name, void 0);
+    if (!ok) {
+      console.error(renderError("Not found", `No tracked process named "${name}".`));
+      process.exit(1);
+    }
+    console.error(`
+  ${pc26.green("\u2713")} ${pc26.bold(name)} ${pc26.dim("removed from its group")}
+`);
+    return;
+  }
+  let group;
+  let names;
+  if (positional.length >= 3) {
+    group = positional[0];
+    names = positional.slice(1);
+  } else {
+    const [a, b] = positional;
+    const tracked = readTracked();
+    const aIsApp = tracked.some((t) => t.name === a);
+    if (aIsApp) {
+      names = [a];
+      group = b;
+    } else {
+      group = a;
+      names = [b];
+    }
+  }
+  const okNames = [];
+  const failed = [];
+  for (const n of names) {
+    if (setGroup(n, group)) okNames.push(n);
+    else failed.push(n);
+  }
+  if (okNames.length > 0) {
+    console.error(
+      `
+  ${pc26.green("\u2713")} ${pc26.bold(okNames.join(", "))} ${pc26.dim(`assigned to group`)} ${pc26.cyan(group)}`
+    );
+  }
+  if (failed.length > 0) {
+    console.error(`  ${pc26.red("\u2717")} ${pc26.dim(`not found: ${failed.join(", ")}`)}`);
+  }
+  if (okNames.length === 0 && failed.length > 0) process.exit(1);
+  console.error();
 }
 
 // src/index.ts
@@ -5977,6 +7131,8 @@ async function main() {
     await cleanupCommand();
   } else if (command === "rename") {
     await renameCommand(args);
+  } else if (command === "group") {
+    await groupCommand(args);
   } else if (command === "export") {
     await exportCommand(args);
   } else if (command === "import") {
@@ -5991,8 +7147,14 @@ async function main() {
     await attachPortCommand(args);
   } else if (command === "watch") {
     await watchCommand(args);
+  } else if (command === "store") {
+    printBanner();
+    await storeCommand(args);
+  } else if (command === "doctor") {
+    printBanner();
+    await doctorCommand();
   } else if (command === "sessions") {
-    await sessionsCommand();
+    await storeCommand(["session"]);
   } else if (command === "setup") {
     await setupCommand();
   } else if (command === "install-browsers") {
@@ -6013,7 +7175,9 @@ async function main() {
       showHelp();
     }
   } else {
-    console.error(renderError(`Unknown command: ${command}`, "Run 'fennec help' for usage information"));
+    console.error(
+      renderError(`Unknown command: ${command}`, "Run 'fennec help' for usage information")
+    );
     process.exit(1);
   }
 }