@plumpslabs/fennec-cli 1.14.1 → 1.14.3

package/dist/index.js

@@ -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.1";
+var VERSION = "1.14.3";
 var cachedBanner = null;
 var cachedCompact = null;
 function generateBanner() {
@@ -2158,11 +2166,12 @@ 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 +2184,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 +2230,45 @@ 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 +2336,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 +2462,7 @@ 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"] },
@@ -2872,12 +2903,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 +2939,48 @@ 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));
@@ -3089,6 +3173,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");
@@ -3253,7 +3375,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 {
     }
   }
@@ -3442,7 +3564,7 @@ function supervisorStop() {
     return;
   }
   try {
-    process.kill(pid, "SIGTERM");
+    killTree(pid, "SIGTERM");
     console.error(`
   ${pc4.green("\u2713")} ${pc4.bold("Supervisor stopped")} ${pc4.dim(`(PID ${pid})`)}
 `);
@@ -3822,6 +3944,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();
@@ -3874,10 +3997,11 @@ 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.")}`);
+  ${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;
@@ -3889,10 +4013,18 @@ async function psCommand(args2) {
       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;
@@ -3902,11 +4034,13 @@ async function psCommand(args2) {
   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;
+  const scope = groupFilter ? ` in group ${pc6.cyan(groupFilter)}` : "";
   console.error(`
-  ${symbols.fox} ${pc6.bold("Fennec Apps")} ${pc6.dim(`(${runningCount}/${tracked.length} running)`)}
+  ${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.")}`);
@@ -3914,6 +4048,7 @@ async function psCommand(args2) {
   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 +4062,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
     };
@@ -3994,11 +4134,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();
     });
   });
 }
@@ -4075,6 +4215,7 @@ 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);
@@ -4114,6 +4255,7 @@ async function runCommand(args2) {
   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 = {};
@@ -4132,7 +4274,8 @@ 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...`);
@@ -4213,25 +4356,44 @@ 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;
@@ -4250,8 +4412,13 @@ async function killCommand(args2) {
       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 +4428,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 +4437,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 {
@@ -4287,6 +4454,43 @@ Use ${pc8.cyan(`fennec kill <pid>`)} to kill a system process by its PID.`));
     console.error(renderError("Permission denied", "Try running with sudo or use a different signal."));
   }
 }
+async function killGroup(group, signal, 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: ${pc8.cyan(getGroups().join(", ") || "(none)")}`));
+    process.exit(1);
+  }
+  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) in ${group}...`);
+  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 from group ${group}`) : spinner.fail("Failed to kill apps");
+  if (failed > 0) console.error(`  ${pc8.yellow(`${failed} running app(s) could not be killed`)}`);
+}
 async function killAll(signal, force) {
   const tracked = readTracked();
   if (tracked.length === 0) {
@@ -4307,7 +4511,7 @@ async function killAll(signal, force) {
   const spinner = createSpinner(`Killing ${running.length} + removing ${stopped.length} tracked app(s)...`);
   let killed = 0, failed = 0;
   for (const t of running) {
-    if (killProcess(t.pid, signal)) {
+    if (killTree(t.pid, signal)) {
       killed++;
     } else {
       failed++;
@@ -4319,34 +4523,53 @@ 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`) : 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) {
+  const target = resolveTargets(args2);
+  if (target.kind === "group") {
+    await stopAllTracked(args2, target.group);
+    return;
+  }
+  if (target.kind === "all") {
     await stopAllTracked(args2);
     return;
   }
-  const rawTarget = args2[0];
-  if (!rawTarget) {
-    console.error(renderError("Missing name", "Usage: fennec stop <name|--all>"));
-    process.exit(1);
+  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");
@@ -4358,17 +4581,18 @@ 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.")}
+  ${pc9.dim(group ? `No running tracked processes in group "${group}".` : "No running tracked processes to stop.")}
 `);
     return;
   }
+  const scope = group ? ` group ${pc9.cyan(group)}` : "";
   console.error(`
-  ${pc9.yellow("\u26A0")} ${pc9.bold(`Stop all ${running.length} running process(es)?`)} ${pc9.dim("(They can be re-spawned later)")}
+  ${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 +4610,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++;
@@ -4407,7 +4631,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 +4640,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,20 +4663,45 @@ 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)) {
@@ -4460,17 +4709,22 @@ async function spawnCommand(args2) {
   ${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.")}
@@ -4607,32 +4861,46 @@ 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,16 +4908,14 @@ 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 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({
@@ -4670,6 +4936,45 @@ fennec restart only re-spawns Fennec-tracked apps (from their saved config).`));
     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,
+        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)}`);
+    }
+  }
+}
 
 // src/commands/adopt.ts
 import pc12 from "picocolors";
@@ -4904,7 +5209,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 +5228,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 +5277,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 +5319,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();
   }
@@ -5086,7 +5391,7 @@ function devDown() {
   ${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;
@@ -5384,10 +5689,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);
@@ -5451,37 +5756,237 @@ 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(`
-  ${pc17.dim("No saved sessions found.")}
+  ${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;
   }
-  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(`
+  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.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 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 +5995,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 +6010,46 @@ async function setupCommand() {
     }
   }
 }`;
-  console.error(`  ${pc18.bold("Add this to your MCP client config:")}
+  console.error(`  ${pc19.bold("Add this to your MCP client config:")}
 `);
-  console.error(`  ${pc18.dim("```")}`);
+  console.error(`  ${pc19.dim("```")}`);
   console.error(configSnippet.split("\n").map((l) => `  ${l}`).join("\n"));
-  console.error(`  ${pc18.dim("```")}
+  console.error(`  ${pc19.dim("```")}
 `);
-  console.error(`  ${renderSuccess("Setup complete!")} ${pc18.dim("Run")} ${renderCommand("fennec start")} ${pc18.dim("to begin.")}
+  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 +6129,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 statSync3 } 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 = statSync3(resolve8(logDir, f));
         totalBytes += fStat.size;
       }
       logSize = totalBytes > 1024 * 1024 ? `${(totalBytes / (1024 * 1024)).toFixed(1)} MB` : `${(totalBytes / 1024).toFixed(1)} KB`;
@@ -5674,7 +6179,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 +6187,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 +6195,56 @@ 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.")}
+  ${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`)}
+  ${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);
   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)`)}
+  ${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 +6258,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 +6294,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 +6309,25 @@ 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 +6335,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,16 +6353,16 @@ 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");
+      writeFileSync5(resolve11(filePath), json, "utf-8");
       console.error(`
-  ${pc24.green("\u2713")} ${pc24.bold(`Exported ${tracked.length} process(es)`)} ${pc24.dim(`\u2192 ${filePath}`)}
+  ${pc25.green("\u2713")} ${pc25.bold(`Exported ${tracked.length} process(es)`)} ${pc25.dim(`\u2192 ${filePath}`)}
 `);
     } catch (err) {
       console.error(renderError("Export failed", String(err)));
@@ -5873,14 +6378,14 @@ 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."));
       process.exit(1);
@@ -5891,20 +6396,20 @@ 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);
   if (!confirmed) {
-    console.error(`  ${pc24.dim("Cancelled")}
+    console.error(`  ${pc25.dim("Cancelled")}
 `);
     return;
   }
@@ -5918,8 +6423,63 @@ 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:")} ${pc26.cyan("fennec group <name> <group>")}  ${pc26.dim("Clear:")} ${pc26.cyan("fennec group <name> --unset")}`);
+    console.error();
+    return;
+  }
+  const name = positional[0];
+  const newGroup = positional[1];
+  if (!newGroup && !unset) {
+    console.error(renderError("Missing group", "Usage: fennec group <name> <group>   (or: fennec group <name> --unset)"));
+    process.exit(1);
+  }
+  const ok = setGroup(name, unset ? void 0 : newGroup);
+  if (!ok) {
+    console.error(renderError("Not found", `No tracked process named "${name}".`));
+    process.exit(1);
+  }
+  if (unset) {
+    console.error(`
+  ${pc26.green("\u2713")} ${pc26.bold(name)} ${pc26.dim("removed from its group")}
+`);
+  } else {
+    console.error(`
+  ${pc26.green("\u2713")} ${pc26.bold(name)} ${pc26.dim("assigned to group")} ${pc26.cyan(newGroup)}
+`);
+  }
 }
 
 // src/index.ts
@@ -5977,6 +6537,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 +6553,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") {