panopticon-cli 0.3.2 → 0.3.4

package/dist/cli/index.js

@@ -16,7 +16,7 @@ import {
   restoreBackup,
   saveConfig,
   syncHooks
-} from "../chunk-B2JBBOJN.js";
+} from "../chunk-C6A7S65K.js";
 import {
   PROJECTS_CONFIG_FILE,
   getProject,
@@ -26,7 +26,7 @@ import {
   registerProject,
   resolveProjectFromIssue,
   unregisterProject
-} from "../chunk-PSJRCUOA.js";
+} from "../chunk-BH6BR26M.js";
 import {
   AGENTS_DIR,
   CERTS_DIR,
@@ -41,1149 +41,999 @@ import {
   SOURCE_TRAEFIK_TEMPLATES,
   SYNC_TARGETS,
   TRAEFIK_CERTS_DIR,
-  TRAEFIK_DIR,
-  __commonJS,
-  __esm,
-  __export,
-  __require,
-  __toCommonJS,
-  init_esm_shims,
-  init_paths
-} from "../chunk-SG7O6I7R.js";
+  TRAEFIK_DIR
+} from "../chunk-P5TQ5C3J.js";
 
-// src/lib/tmux.ts
-import { execSync } from "child_process";
-function listSessions() {
-  try {
-    const output = execSync('tmux list-sessions -F "#{session_name}|#{session_created}|#{session_attached}|#{session_windows}"', {
-      encoding: "utf8"
-    });
-    return output.trim().split("\n").filter(Boolean).map((line) => {
-      const [name, created, attached, windows] = line.split("|");
-      return {
-        name,
-        created: new Date(parseInt(created) * 1e3),
-        attached: attached === "1",
-        windows: parseInt(windows)
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-function sessionExists(name) {
-  try {
-    execSync(`tmux has-session -t ${name} 2>/dev/null`);
-    return true;
-  } catch {
-    return false;
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk33 from "chalk";
+
+// src/cli/commands/init.ts
+import { existsSync, mkdirSync, readdirSync, cpSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import ora from "ora";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var PACKAGE_ROOT = join(__dirname, "..", "..");
+var BUNDLED_SKILLS_DIR = join(PACKAGE_ROOT, "skills");
+var BUNDLED_AGENTS_DIR = join(PACKAGE_ROOT, "agents");
+function copyBundledSkills() {
+  if (!existsSync(BUNDLED_SKILLS_DIR)) {
+    return 0;
   }
-}
-function createSession(name, cwd, initialCommand, options) {
-  const escapedCwd = cwd.replace(/"/g, '\\"');
-  let envFlags = "";
-  if (options?.env) {
-    for (const [key, value] of Object.entries(options.env)) {
-      envFlags += ` -e ${key}="${value.replace(/"/g, '\\"')}"`;
-    }
+  if (!existsSync(SKILLS_DIR)) {
+    mkdirSync(SKILLS_DIR, { recursive: true });
   }
-  if (initialCommand && (initialCommand.includes("`") || initialCommand.includes("\n") || initialCommand.length > 500)) {
-    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags}`);
-    execSync("sleep 0.5");
-    const tmpFile = `/tmp/pan-cmd-${name}.sh`;
-    const fs = __require("fs");
-    fs.writeFileSync(tmpFile, initialCommand);
-    fs.chmodSync(tmpFile, "755");
-    execSync(`tmux send-keys -t ${name} "bash ${tmpFile}" Enter`);
-  } else if (initialCommand) {
-    const cmd = `tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags} "${initialCommand.replace(/"/g, '\\"')}"`;
-    execSync(cmd);
-  } else {
-    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags}`);
+  const skills = readdirSync(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  let copied = 0;
+  for (const skill of skills) {
+    const sourcePath = join(BUNDLED_SKILLS_DIR, skill.name);
+    const targetPath = join(SKILLS_DIR, skill.name);
+    cpSync(sourcePath, targetPath, { recursive: true });
+    copied++;
   }
+  return copied;
 }
-function killSession(name) {
-  execSync(`tmux kill-session -t ${name}`);
-}
-function sendKeys(sessionName, keys) {
-  const escapedKeys = keys.replace(/"/g, '\\"');
-  execSync(`tmux send-keys -t ${sessionName} "${escapedKeys}"`);
-  execSync(`tmux send-keys -t ${sessionName} Enter`);
-}
-function getAgentSessions() {
-  return listSessions().filter((s) => s.name.startsWith("agent-"));
-}
-var init_tmux = __esm({
-  "src/lib/tmux.ts"() {
-    "use strict";
-    init_esm_shims();
+function copyBundledAgents() {
+  if (!existsSync(BUNDLED_AGENTS_DIR)) {
+    return 0;
   }
-});
-
-// src/lib/hooks.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync, readdirSync as readdirSync3, unlinkSync } from "fs";
-import { join as join3 } from "path";
-function getHookDir(agentId) {
-  return join3(AGENTS_DIR, agentId);
-}
-function getHookFile(agentId) {
-  return join3(getHookDir(agentId), "hook.json");
-}
-function getMailDir(agentId) {
-  return join3(getHookDir(agentId), "mail");
-}
-function initHook(agentId) {
-  const hookDir = getHookDir(agentId);
-  const mailDir = getMailDir(agentId);
-  mkdirSync2(hookDir, { recursive: true });
-  mkdirSync2(mailDir, { recursive: true });
-  const hookFile = getHookFile(agentId);
-  if (!existsSync3(hookFile)) {
-    const hook = {
-      agentId,
-      items: []
-    };
-    writeFileSync(hookFile, JSON.stringify(hook, null, 2));
+  if (!existsSync(AGENTS_DIR)) {
+    mkdirSync(AGENTS_DIR, { recursive: true });
+  }
+  const agents = readdirSync(BUNDLED_AGENTS_DIR, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md"));
+  let copied = 0;
+  for (const agent of agents) {
+    const sourcePath = join(BUNDLED_AGENTS_DIR, agent.name);
+    const targetPath = join(AGENTS_DIR, agent.name);
+    cpSync(sourcePath, targetPath);
+    copied++;
   }
+  return copied;
 }
-function getHook(agentId) {
-  const hookFile = getHookFile(agentId);
-  if (!existsSync3(hookFile)) {
-    return null;
+async function initCommand() {
+  const spinner = ora("Initializing Panopticon...").start();
+  if (existsSync(CONFIG_FILE)) {
+    spinner.info("Panopticon already initialized");
+    console.log(chalk.dim(`  Config: ${CONFIG_FILE}`));
+    console.log(chalk.dim(`  Home: ${PANOPTICON_HOME}`));
+    console.log(chalk.dim("  Run `pan sync` to update skills"));
+    return;
   }
   try {
-    const content = readFileSync2(hookFile, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function pushToHook(agentId, item) {
-  initHook(agentId);
-  const hook = getHook(agentId) || { agentId, items: [] };
-  const newItem = {
-    ...item,
-    id: `hook-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  hook.items.push(newItem);
-  writeFileSync(getHookFile(agentId), JSON.stringify(hook, null, 2));
-  return newItem;
-}
-function checkHook(agentId) {
-  const hook = getHook(agentId);
-  if (!hook || hook.items.length === 0) {
-    const mailDir = getMailDir(agentId);
-    if (existsSync3(mailDir)) {
-      const mails = readdirSync3(mailDir).filter((f) => f.endsWith(".json"));
-      if (mails.length > 0) {
-        const mailItems = mails.map((file) => {
-          try {
-            const content = readFileSync2(join3(mailDir, file), "utf-8");
-            return JSON.parse(content);
-          } catch {
-            return null;
-          }
-        }).filter(Boolean);
-        return {
-          hasWork: mailItems.length > 0,
-          urgentCount: mailItems.filter((i) => i.priority === "urgent").length,
-          items: mailItems
-        };
+    for (const dir of INIT_DIRS) {
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
       }
     }
-    return { hasWork: false, urgentCount: 0, items: [] };
-  }
-  const now = /* @__PURE__ */ new Date();
-  const activeItems = hook.items.filter((item) => {
-    if (item.expiresAt) {
-      return new Date(item.expiresAt) > now;
+    spinner.text = "Created directories...";
+    const config = getDefaultConfig();
+    saveConfig(config);
+    spinner.text = "Created config...";
+    spinner.text = "Installing bundled skills...";
+    const skillsCopied = copyBundledSkills();
+    spinner.text = "Installing bundled agents...";
+    const agentsCopied = copyBundledAgents();
+    const shell = detectShell();
+    const rcFile = getShellRcFile(shell);
+    if (rcFile && existsSync(rcFile)) {
+      addAlias(rcFile);
+      spinner.succeed("Panopticon initialized!");
+      console.log("");
+      console.log(chalk.green("\u2713") + " Created " + chalk.cyan(PANOPTICON_HOME));
+      console.log(chalk.green("\u2713") + " Created " + chalk.cyan(CONFIG_FILE));
+      if (skillsCopied > 0) {
+        console.log(chalk.green("\u2713") + ` Installed ${skillsCopied} bundled skills`);
+      }
+      if (agentsCopied > 0) {
+        console.log(chalk.green("\u2713") + ` Installed ${agentsCopied} bundled agents`);
+      }
+      console.log(chalk.green("\u2713") + " " + getAliasInstructions(shell));
+    } else {
+      spinner.succeed("Panopticon initialized!");
+      console.log("");
+      console.log(chalk.green("\u2713") + " Created " + chalk.cyan(PANOPTICON_HOME));
+      console.log(chalk.green("\u2713") + " Created " + chalk.cyan(CONFIG_FILE));
+      if (skillsCopied > 0) {
+        console.log(chalk.green("\u2713") + ` Installed ${skillsCopied} bundled skills`);
+      }
+      if (agentsCopied > 0) {
+        console.log(chalk.green("\u2713") + ` Installed ${agentsCopied} bundled agents`);
+      }
+      console.log(chalk.yellow("!") + " Could not detect shell. Add alias manually:");
+      console.log(chalk.dim('    alias pan="panopticon"'));
     }
-    return true;
-  });
-  const priorityOrder = { urgent: 0, high: 1, normal: 2, low: 3 };
-  activeItems.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
-  return {
-    hasWork: activeItems.length > 0,
-    urgentCount: activeItems.filter((i) => i.priority === "urgent").length,
-    items: activeItems
-  };
-}
-function popFromHook(agentId, itemId) {
-  const hook = getHook(agentId);
-  if (!hook) return false;
-  const index = hook.items.findIndex((i) => i.id === itemId);
-  if (index === -1) return false;
-  hook.items.splice(index, 1);
-  hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync(getHookFile(agentId), JSON.stringify(hook, null, 2));
-  return true;
-}
-function clearHook(agentId) {
-  const hook = getHook(agentId);
-  if (!hook) return;
-  hook.items = [];
-  hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
-  writeFileSync(getHookFile(agentId), JSON.stringify(hook, null, 2));
+    console.log("");
+    console.log("Next steps:");
+    console.log(chalk.dim("  1. Run: pan sync"));
+    console.log(chalk.dim("  2. Start dashboard: pan up"));
+  } catch (error) {
+    spinner.fail("Failed to initialize");
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
 }
-function sendMail(toAgentId, from, message, priority = "normal") {
-  initHook(toAgentId);
-  const mailDir = getMailDir(toAgentId);
-  const mailItem = {
-    id: `mail-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-    type: "message",
-    priority,
-    source: from,
-    payload: { message },
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeFileSync(
-    join3(mailDir, `${mailItem.id}.json`),
-    JSON.stringify(mailItem, null, 2)
-  );
-}
-function generateGUPPPrompt(agentId) {
-  const { hasWork, urgentCount, items } = checkHook(agentId);
-  if (!hasWork) return null;
-  const lines = [
-    "# GUPP: Work Found on Your Hook",
-    "",
-    '> "If there is work on your Hook, YOU MUST RUN IT."',
-    ""
-  ];
-  if (urgentCount > 0) {
-    lines.push(`\u26A0\uFE0F **${urgentCount} URGENT item(s) require immediate attention**`);
-    lines.push("");
+
+// src/cli/commands/sync.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+async function syncCommand(options) {
+  const config = loadConfig();
+  const targets = config.sync?.targets;
+  if (!targets || !Array.isArray(targets) || targets.length === 0) {
+    console.log(chalk2.yellow("No sync targets configured."));
+    console.log(chalk2.dim("Edit ~/.panopticon/config.toml to add targets to the [sync] section."));
+    console.log(chalk2.dim('Example: targets = ["claude-code", "cursor"]'));
+    return;
   }
-  lines.push(`## Pending Work Items (${items.length})`);
-  lines.push("");
-  for (const item of items) {
-    const priorityEmoji = {
-      urgent: "\u{1F534}",
-      high: "\u{1F7E0}",
-      normal: "\u{1F7E2}",
-      low: "\u26AA"
-    }[item.priority];
-    lines.push(`### ${priorityEmoji} ${item.type.toUpperCase()}: ${item.id}`);
-    lines.push(`- Source: ${item.source}`);
-    lines.push(`- Created: ${item.createdAt}`);
-    if (item.payload.issueId) {
-      lines.push(`- Issue: ${item.payload.issueId}`);
-    }
-    if (item.payload.message) {
-      lines.push(`- Message: ${item.payload.message}`);
+  const validTargets = targets;
+  if (options.dryRun) {
+    console.log(chalk2.bold("Sync Plan (dry run):\n"));
+    const hooksPlan = planHooksSync();
+    if (hooksPlan.length > 0) {
+      console.log(chalk2.cyan("hooks (bin scripts):"));
+      for (const hook of hooksPlan) {
+        const icon = hook.status === "new" ? chalk2.green("+") : chalk2.blue("\u21BB");
+        const status = hook.status === "new" ? "" : chalk2.dim("[update]");
+        console.log(`  ${icon} ${hook.name} ${status}`);
+      }
+      console.log("");
     }
-    if (item.payload.action) {
-      lines.push(`- Action: ${item.payload.action}`);
+    for (const runtime of validTargets) {
+      const plan = planSync(runtime);
+      console.log(chalk2.cyan(`${runtime}:`));
+      if (plan.skills.length === 0 && plan.commands.length === 0 && plan.agents.length === 0) {
+        console.log(chalk2.dim("  (nothing to sync)"));
+        continue;
+      }
+      for (const item of plan.skills) {
+        const icon = item.status === "conflict" ? chalk2.yellow("!") : chalk2.green("+");
+        const status = item.status === "conflict" ? chalk2.yellow("[conflict]") : "";
+        console.log(`  ${icon} skill/${item.name} ${status}`);
+      }
+      for (const item of plan.commands) {
+        const icon = item.status === "conflict" ? chalk2.yellow("!") : chalk2.green("+");
+        const status = item.status === "conflict" ? chalk2.yellow("[conflict]") : "";
+        console.log(`  ${icon} command/${item.name} ${status}`);
+      }
+      for (const item of plan.agents) {
+        const icon = item.status === "conflict" ? chalk2.yellow("!") : chalk2.green("+");
+        const status = item.status === "conflict" ? chalk2.yellow("[conflict]") : "";
+        console.log(`  ${icon} agent/${item.name} ${status}`);
+      }
+      console.log("");
     }
-    lines.push("");
-  }
-  lines.push("---");
-  lines.push("");
-  lines.push("Execute these items in priority order. Use `bd hook pop <id>` after completing each item.");
-  return lines.join("\n");
-}
-var init_hooks = __esm({
-  "src/lib/hooks.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_paths();
+    console.log(chalk2.dim("Run without --dry-run to apply changes."));
+    return;
   }
-});
-
-// src/lib/cv.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, readdirSync as readdirSync4 } from "fs";
-import { join as join4 } from "path";
-function getCVFile(agentId) {
-  return join4(AGENTS_DIR, agentId, "cv.json");
-}
-function getAgentCV(agentId) {
-  const cvFile = getCVFile(agentId);
-  if (existsSync4(cvFile)) {
-    try {
-      return JSON.parse(readFileSync3(cvFile, "utf-8"));
-    } catch {
+  if (config.sync.backup_before_sync) {
+    const spinner2 = ora2("Creating backup...").start();
+    const backupDirs = validTargets.flatMap((r) => [
+      SYNC_TARGETS[r].skills,
+      SYNC_TARGETS[r].commands,
+      SYNC_TARGETS[r].agents
+    ]);
+    const backup2 = createBackup(backupDirs);
+    if (backup2.targets.length > 0) {
+      spinner2.succeed(`Backup created: ${backup2.timestamp}`);
+    } else {
+      spinner2.info("No existing content to backup");
+    }
+    if (options.backupOnly) {
+      return;
     }
   }
-  const cv = {
-    agentId,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    lastActive: (/* @__PURE__ */ new Date()).toISOString(),
-    runtime: "claude",
-    model: "sonnet",
-    stats: {
-      totalIssues: 0,
-      successCount: 0,
-      failureCount: 0,
-      abandonedCount: 0,
-      avgDuration: 0,
-      successRate: 0
-    },
-    skillsUsed: [],
-    recentWork: []
-  };
-  saveAgentCV(cv);
-  return cv;
-}
-function saveAgentCV(cv) {
-  const dir = join4(AGENTS_DIR, cv.agentId);
-  mkdirSync3(dir, { recursive: true });
-  writeFileSync2(getCVFile(cv.agentId), JSON.stringify(cv, null, 2));
-}
-function startWork(agentId, issueId, skills) {
-  const cv = getAgentCV(agentId);
-  const entry = {
-    issueId,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    outcome: "in_progress",
-    skills
-  };
-  cv.recentWork.unshift(entry);
-  cv.stats.totalIssues++;
-  cv.lastActive = (/* @__PURE__ */ new Date()).toISOString();
-  if (skills) {
-    for (const skill of skills) {
-      if (!cv.skillsUsed.includes(skill)) {
-        cv.skillsUsed.push(skill);
+  const spinner = ora2("Syncing...").start();
+  let totalCreated = 0;
+  let totalConflicts = 0;
+  for (const runtime of validTargets) {
+    spinner.text = `Syncing to ${runtime}...`;
+    const result = executeSync(runtime, { force: options.force });
+    totalCreated += result.created.length;
+    totalConflicts += result.conflicts.length;
+    if (result.conflicts.length > 0 && !options.force) {
+      console.log("");
+      console.log(chalk2.yellow(`Conflicts in ${runtime}:`));
+      for (const name of result.conflicts) {
+        console.log(chalk2.dim(`  - ${name} (use --force to overwrite)`));
       }
     }
   }
-  if (cv.recentWork.length > 50) {
-    cv.recentWork = cv.recentWork.slice(0, 50);
+  if (totalConflicts > 0 && !options.force) {
+    spinner.warn(`Synced ${totalCreated} items, ${totalConflicts} conflicts`);
+    console.log("");
+    console.log(chalk2.dim("Use --force to overwrite conflicting items."));
+  } else {
+    spinner.succeed(`Synced ${totalCreated} items to ${validTargets.join(", ")}`);
   }
-  saveAgentCV(cv);
-}
-function getAgentRankings() {
-  const rankings = [];
-  if (!existsSync4(AGENTS_DIR)) return rankings;
-  const dirs = readdirSync4(AGENTS_DIR, { withFileTypes: true }).filter(
-    (d) => d.isDirectory()
-  );
-  for (const dir of dirs) {
-    const cv = getAgentCV(dir.name);
-    if (cv.stats.totalIssues > 0) {
-      rankings.push({
-        agentId: dir.name,
-        successRate: cv.stats.successRate,
-        totalIssues: cv.stats.totalIssues,
-        avgDuration: cv.stats.avgDuration
-      });
+  const hooksSpinner = ora2("Syncing hooks...").start();
+  const hooksResult = syncHooks();
+  if (hooksResult.errors.length > 0) {
+    hooksSpinner.warn(`Synced ${hooksResult.synced.length} hooks, ${hooksResult.errors.length} errors`);
+    for (const error of hooksResult.errors) {
+      console.log(chalk2.red(`  \u2717 ${error}`));
     }
+  } else if (hooksResult.synced.length > 0) {
+    hooksSpinner.succeed(`Synced ${hooksResult.synced.length} hooks to ~/.panopticon/bin/`);
+  } else {
+    hooksSpinner.info("No hooks to sync");
   }
-  rankings.sort((a, b) => {
-    if (b.successRate !== a.successRate) {
-      return b.successRate - a.successRate;
-    }
-    return b.totalIssues - a.totalIssues;
-  });
-  return rankings;
 }
-function formatCV(cv) {
-  const lines = [
-    `# Agent CV: ${cv.agentId}`,
-    "",
-    `Runtime: ${cv.runtime} (${cv.model})`,
-    `Created: ${cv.createdAt}`,
-    `Last Active: ${cv.lastActive}`,
-    "",
-    "## Statistics",
-    "",
-    `- Total Issues: ${cv.stats.totalIssues}`,
-    `- Success Rate: ${(cv.stats.successRate * 100).toFixed(1)}%`,
-    `- Successes: ${cv.stats.successCount}`,
-    `- Failures: ${cv.stats.failureCount}`,
-    `- Abandoned: ${cv.stats.abandonedCount}`,
-    `- Avg Duration: ${cv.stats.avgDuration} minutes`,
-    ""
-  ];
-  if (cv.skillsUsed.length > 0) {
-    lines.push("## Skills Used");
-    lines.push("");
-    lines.push(cv.skillsUsed.join(", "));
-    lines.push("");
+
+// src/cli/commands/restore.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+import inquirer from "inquirer";
+async function restoreCommand(timestamp) {
+  const backups = listBackups();
+  if (backups.length === 0) {
+    console.log(chalk3.yellow("No backups found."));
+    return;
   }
-  if (cv.recentWork.length > 0) {
-    lines.push("## Recent Work");
-    lines.push("");
-    for (const work of cv.recentWork.slice(0, 10)) {
-      const statusIcon = {
-        success: "\u2713",
-        failed: "\u2717",
-        abandoned: "\u2298",
-        in_progress: "\u25CF"
-      }[work.outcome];
-      const duration = work.duration ? ` (${work.duration}m)` : "";
-      lines.push(`${statusIcon} ${work.issueId}${duration}`);
-      if (work.failureReason) {
-        lines.push(`  Reason: ${work.failureReason}`);
-      }
-    }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-var init_cv = __esm({
-  "src/lib/cv.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_paths();
-  }
-});
-
-// src/lib/agents.ts
-var agents_exports = {};
-__export(agents_exports, {
-  autoRecoverAgents: () => autoRecoverAgents,
-  detectCrashedAgents: () => detectCrashedAgents,
-  getAgentDir: () => getAgentDir,
-  getAgentState: () => getAgentState,
-  listRunningAgents: () => listRunningAgents,
-  messageAgent: () => messageAgent,
-  recoverAgent: () => recoverAgent,
-  saveAgentState: () => saveAgentState,
-  spawnAgent: () => spawnAgent,
-  stopAgent: () => stopAgent
-});
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, readFileSync as readFileSync4, readdirSync as readdirSync5 } from "fs";
-import { join as join5 } from "path";
-import { execSync as execSync2 } from "child_process";
-function getAgentDir(agentId) {
-  return join5(AGENTS_DIR, agentId);
-}
-function getAgentState(agentId) {
-  const stateFile = join5(getAgentDir(agentId), "state.json");
-  if (!existsSync5(stateFile)) return null;
-  const content = readFileSync4(stateFile, "utf8");
-  return JSON.parse(content);
-}
-function saveAgentState(state) {
-  const dir = getAgentDir(state.id);
-  mkdirSync4(dir, { recursive: true });
-  writeFileSync3(
-    join5(dir, "state.json"),
-    JSON.stringify(state, null, 2)
-  );
-}
-function spawnAgent(options) {
-  const agentId = `agent-${options.issueId.toLowerCase()}`;
-  if (sessionExists(agentId)) {
-    throw new Error(`Agent ${agentId} already running. Use 'pan work tell' to message it.`);
-  }
-  initHook(agentId);
-  const state = {
-    id: agentId,
-    issueId: options.issueId,
-    workspace: options.workspace,
-    runtime: options.runtime || "claude",
-    model: options.model || "sonnet",
-    status: "starting",
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    // Initialize Phase 4 fields
-    handoffCount: 0,
-    costSoFar: 0
-  };
-  saveAgentState(state);
-  let prompt = options.prompt || "";
-  const { hasWork, items } = checkHook(agentId);
-  if (hasWork) {
-    const guppPrompt = generateGUPPPrompt(agentId);
-    if (guppPrompt) {
-      prompt = guppPrompt + "\n\n---\n\n" + prompt;
+  if (!timestamp) {
+    console.log(chalk3.bold("Available backups:\n"));
+    for (const backup2 of backups.slice(0, 10)) {
+      console.log(`  ${chalk3.cyan(backup2.timestamp)} - ${backup2.targets.join(", ")}`);
     }
-  }
-  const promptFile = join5(getAgentDir(agentId), "initial-prompt.md");
-  if (prompt) {
-    writeFileSync3(promptFile, prompt);
-  }
-  checkAndSetupHooks();
-  writeTaskCache(agentId, options.issueId);
-  const claudeCmd = `claude --dangerously-skip-permissions --model ${state.model}`;
-  createSession(agentId, options.workspace, claudeCmd, {
-    env: {
-      PANOPTICON_AGENT_ID: agentId
+    if (backups.length > 10) {
+      console.log(chalk3.dim(`  ... and ${backups.length - 10} more`));
     }
-  });
-  if (prompt) {
-    let ready = false;
-    for (let i = 0; i < 15; i++) {
-      execSync2("sleep 1");
-      try {
-        const pane = execSync2(`tmux capture-pane -t ${agentId} -p`, { encoding: "utf-8" });
-        if (pane.includes("\u276F") || pane.includes(">")) {
-          ready = true;
-          break;
-        }
-      } catch {
+    console.log("");
+    const { selected } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "selected",
+        message: "Select backup to restore:",
+        choices: backups.slice(0, 10).map((b) => ({
+          name: `${b.timestamp} (${b.targets.join(", ")})`,
+          value: b.timestamp
+        }))
       }
+    ]);
+    timestamp = selected;
+  }
+  const { confirm: confirm2 } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `Restore backup ${timestamp}? This will overwrite current files.`,
+      default: false
     }
-    if (ready) {
-      execSync2(`tmux load-buffer "${promptFile}"`);
-      execSync2(`tmux paste-buffer -t ${agentId}`);
-      execSync2("sleep 0.5");
-      execSync2(`tmux send-keys -t ${agentId} Enter`);
-    } else {
-      console.error("Claude did not become ready in time, prompt not sent");
-    }
+  ]);
+  if (!confirm2) {
+    console.log(chalk3.dim("Restore cancelled."));
+    return;
   }
-  state.status = "running";
-  saveAgentState(state);
-  startWork(agentId, options.issueId);
-  return state;
-}
-function listRunningAgents() {
-  const tmuxSessions = getAgentSessions();
-  const tmuxNames = new Set(tmuxSessions.map((s) => s.name));
-  const agents = [];
-  if (!existsSync5(AGENTS_DIR)) return agents;
-  const dirs = readdirSync5(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
-  for (const dir of dirs) {
-    const state = getAgentState(dir.name);
-    if (state) {
-      agents.push({
-        ...state,
-        tmuxActive: tmuxNames.has(state.id)
-      });
+  const spinner = ora3("Restoring backup...").start();
+  try {
+    const config = loadConfig();
+    const targets = config.sync.targets;
+    const targetDirs = {};
+    for (const runtime of targets) {
+      targetDirs[`${runtime}-skills`] = SYNC_TARGETS[runtime].skills;
+      targetDirs[`${runtime}-commands`] = SYNC_TARGETS[runtime].commands;
+      targetDirs["skills"] = SYNC_TARGETS[runtime].skills;
+      targetDirs["commands"] = SYNC_TARGETS[runtime].commands;
     }
+    restoreBackup(timestamp, targetDirs);
+    spinner.succeed(`Restored backup: ${timestamp}`);
+  } catch (error) {
+    spinner.fail("Failed to restore");
+    console.error(chalk3.red(error.message));
+    process.exit(1);
   }
-  return agents;
 }
-function stopAgent(agentId) {
-  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
-  if (sessionExists(normalizedId)) {
-    killSession(normalizedId);
+
+// src/cli/commands/backup.ts
+import chalk4 from "chalk";
+async function backupListCommand(options) {
+  const backups = listBackups();
+  if (options.json) {
+    console.log(JSON.stringify(backups, null, 2));
+    return;
   }
-  const state = getAgentState(normalizedId);
-  if (state) {
-    state.status = "stopped";
-    saveAgentState(state);
+  if (backups.length === 0) {
+    console.log(chalk4.dim("No backups found."));
+    console.log(chalk4.dim("Backups are created automatically during sync."));
+    return;
+  }
+  console.log(chalk4.bold("Backups:\n"));
+  for (const backup2 of backups) {
+    console.log(`  ${chalk4.cyan(backup2.timestamp)}`);
+    console.log(`    ${chalk4.dim("Contains:")} ${backup2.targets.join(", ")}`);
   }
+  console.log();
+  console.log(chalk4.dim(`Total: ${backups.length} backups`));
+  console.log(chalk4.dim("Use `pan restore <timestamp>` to restore a backup."));
 }
-function messageAgent(agentId, message) {
-  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
-  if (!sessionExists(normalizedId)) {
-    throw new Error(`Agent ${normalizedId} not running`);
+async function backupCleanCommand(options) {
+  const keepCount = parseInt(options.keep || "10", 10);
+  const removed = cleanOldBackups(keepCount);
+  if (removed === 0) {
+    console.log(chalk4.dim(`No backups removed (keeping ${keepCount}).`));
+  } else {
+    console.log(chalk4.green(`Removed ${removed} old backup(s), keeping ${keepCount}.`));
   }
-  sendKeys(normalizedId, message);
-  const mailDir = join5(getAgentDir(normalizedId), "mail");
-  mkdirSync4(mailDir, { recursive: true });
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  writeFileSync3(
-    join5(mailDir, `${timestamp}.md`),
-    `# Message
+}
 
-${message}
-`
-  );
+// src/cli/commands/skills.ts
+import { readdirSync as readdirSync2, readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import chalk5 from "chalk";
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const frontmatter = match[1];
+  const name = frontmatter.match(/name:\s*(.+)/)?.[1]?.trim();
+  const description = frontmatter.match(/description:\s*(.+)/)?.[1]?.trim();
+  return { name, description };
 }
-function detectCrashedAgents() {
-  const agents = listRunningAgents();
-  return agents.filter(
-    (agent) => agent.status === "running" && !agent.tmuxActive
-  );
+function listSkills() {
+  if (!existsSync2(SKILLS_DIR)) return [];
+  const skills = [];
+  const dirs = readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const dir of dirs) {
+    const skillFile = join2(SKILLS_DIR, dir.name, "SKILL.md");
+    if (!existsSync2(skillFile)) continue;
+    const content = readFileSync(skillFile, "utf8");
+    const { name, description } = parseSkillFrontmatter(content);
+    skills.push({
+      name: name || dir.name,
+      description: description || "(no description)",
+      path: skillFile
+    });
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
 }
-function recoverAgent(agentId) {
-  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
-  const state = getAgentState(normalizedId);
-  if (!state) {
-    return null;
+async function skillsCommand(options) {
+  const skills = listSkills();
+  if (options.json) {
+    console.log(JSON.stringify(skills, null, 2));
+    return;
   }
-  if (sessionExists(normalizedId)) {
-    return state;
+  console.log(chalk5.bold(`
+Panopticon Skills (${skills.length})
+`));
+  if (skills.length === 0) {
+    console.log(chalk5.yellow("No skills found."));
+    console.log(chalk5.dim("Skills should be in ~/.panopticon/skills/<name>/SKILL.md"));
+    return;
   }
-  const healthFile = join5(getAgentDir(normalizedId), "health.json");
-  let health = { consecutiveFailures: 0, killCount: 0, recoveryCount: 0 };
-  if (existsSync5(healthFile)) {
-    try {
-      health = { ...health, ...JSON.parse(readFileSync4(healthFile, "utf-8")) };
-    } catch {
-    }
+  for (const skill of skills) {
+    console.log(chalk5.cyan(skill.name));
+    console.log(chalk5.dim(`  ${skill.description}`));
   }
-  health.recoveryCount = (health.recoveryCount || 0) + 1;
-  writeFileSync3(healthFile, JSON.stringify(health, null, 2));
-  const recoveryPrompt = generateRecoveryPrompt(state);
-  const claudeCmd = `claude --dangerously-skip-permissions --model ${state.model} "${recoveryPrompt.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
-  createSession(normalizedId, state.workspace, claudeCmd);
-  state.status = "running";
-  state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
-  saveAgentState(state);
-  return state;
+  console.log(`
+${chalk5.dim('Run "pan sync" to sync skills to Claude Code')}`);
 }
-function generateRecoveryPrompt(state) {
-  const lines = [
-    "# Agent Recovery",
-    "",
-    "\u26A0\uFE0F This agent session was recovered after a crash.",
-    "",
-    "## Previous Context",
-    `- Issue: ${state.issueId}`,
-    `- Workspace: ${state.workspace}`,
-    `- Started: ${state.startedAt}`,
-    "",
-    "## Recovery Steps",
-    "1. Check beads for context: `bd show " + state.issueId + "`",
-    "2. Review recent git commits: `git log --oneline -10`",
-    "3. Check hook for pending work: `pan work hook check`",
-    "4. Resume from last known state",
-    "",
-    "## GUPP Reminder",
-    '> "If there is work on your Hook, YOU MUST RUN IT."',
-    ""
-  ];
-  const { hasWork } = checkHook(state.id);
-  if (hasWork) {
-    const guppPrompt = generateGUPPPrompt(state.id);
-    if (guppPrompt) {
-      lines.push("---");
-      lines.push("");
-      lines.push(guppPrompt);
-    }
+
+// src/cli/commands/work/issue.ts
+import chalk6 from "chalk";
+import ora4 from "ora";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join6, dirname as dirname2 } from "path";
+
+// src/lib/agents.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync4, readdirSync as readdirSync5 } from "fs";
+import { join as join5 } from "path";
+import { execSync as execSync2 } from "child_process";
+import { homedir } from "os";
+
+// src/lib/tmux.ts
+import { execSync } from "child_process";
+import { writeFileSync, chmodSync } from "fs";
+function listSessions() {
+  try {
+    const output = execSync('tmux list-sessions -F "#{session_name}|#{session_created}|#{session_attached}|#{session_windows}"', {
+      encoding: "utf8"
+    });
+    return output.trim().split("\n").filter(Boolean).map((line) => {
+      const [name, created, attached, windows] = line.split("|");
+      return {
+        name,
+        created: new Date(parseInt(created) * 1e3),
+        attached: attached === "1",
+        windows: parseInt(windows)
+      };
+    });
+  } catch {
+    return [];
   }
-  return lines.join("\n");
 }
-function autoRecoverAgents() {
-  const crashed = detectCrashedAgents();
-  const recovered = [];
-  const failed = [];
-  for (const agent of crashed) {
-    try {
-      const result = recoverAgent(agent.id);
-      if (result) {
-        recovered.push(agent.id);
-      } else {
-        failed.push(agent.id);
-      }
-    } catch (error) {
-      failed.push(agent.id);
-    }
+function sessionExists(name) {
+  try {
+    execSync(`tmux has-session -t ${name} 2>/dev/null`);
+    return true;
+  } catch {
+    return false;
   }
-  return { recovered, failed };
 }
-function checkAndSetupHooks() {
-  const { homedir: homedir9 } = __require("os");
-  const settingsPath = join5(homedir9(), ".claude", "settings.json");
-  const hookPath = join5(homedir9(), ".panopticon", "bin", "heartbeat-hook");
-  if (existsSync5(settingsPath)) {
-    try {
-      const settingsContent = readFileSync4(settingsPath, "utf-8");
-      const settings = JSON.parse(settingsContent);
-      const postToolUse = settings?.hooks?.PostToolUse || [];
-      const hookConfigured = postToolUse.some(
-        (hookConfig) => hookConfig.hooks?.some(
-          (hook) => hook.command === hookPath || hook.command?.includes("panopticon") || hook.command?.includes("heartbeat-hook")
-        )
-      );
-      if (hookConfigured) {
-        return;
-      }
-    } catch {
+function createSession(name, cwd, initialCommand, options) {
+  const escapedCwd = cwd.replace(/"/g, '\\"');
+  let envFlags = "";
+  if (options?.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      envFlags += ` -e ${key}="${value.replace(/"/g, '\\"')}"`;
     }
   }
-  try {
-    console.log("Configuring Panopticon heartbeat hooks...");
-    execSync2("pan setup hooks", { stdio: "pipe" });
-    console.log("\u2713 Heartbeat hooks configured");
-  } catch (error) {
-    console.warn("\u26A0 Failed to auto-configure hooks. Run `pan setup hooks` manually.");
+  if (initialCommand && (initialCommand.includes("`") || initialCommand.includes("\n") || initialCommand.length > 500)) {
+    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags}`);
+    execSync("sleep 0.5");
+    const tmpFile = `/tmp/pan-cmd-${name}.sh`;
+    writeFileSync(tmpFile, initialCommand);
+    chmodSync(tmpFile, "755");
+    execSync(`tmux send-keys -t ${name} "bash ${tmpFile}" Enter`);
+  } else if (initialCommand) {
+    const cmd = `tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags} "${initialCommand.replace(/"/g, '\\"')}"`;
+    execSync(cmd);
+  } else {
+    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags}`);
   }
 }
-function writeTaskCache(agentId, issueId) {
-  const cacheDir = join5(getAgentDir(agentId));
-  mkdirSync4(cacheDir, { recursive: true });
-  const cacheFile = join5(cacheDir, "current-task.json");
-  writeFileSync3(
-    cacheFile,
-    JSON.stringify({
-      id: issueId,
-      title: `Working on ${issueId}`,
-      updated_at: (/* @__PURE__ */ new Date()).toISOString()
-    }, null, 2)
-  );
+function killSession(name) {
+  execSync(`tmux kill-session -t ${name}`);
+}
+function sendKeys(sessionName, keys) {
+  const escapedKeys = keys.replace(/"/g, '\\"');
+  execSync(`tmux send-keys -t ${sessionName} "${escapedKeys}"`);
+  execSync(`tmux send-keys -t ${sessionName} Enter`);
+}
+function getAgentSessions() {
+  return listSessions().filter((s) => s.name.startsWith("agent-"));
 }
-var init_agents = __esm({
-  "src/lib/agents.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_paths();
-    init_tmux();
-    init_hooks();
-    init_cv();
-  }
-});
 
-// package.json
-var require_package = __commonJS({
-  "package.json"(exports, module) {
-    module.exports = {
-      name: "panopticon-cli",
-      version: "0.3.2",
-      description: "Multi-agent orchestration for AI coding assistants (Claude Code, Codex, Cursor, Gemini CLI)",
-      keywords: [
-        "ai-agents",
-        "orchestration",
-        "claude-code",
-        "codex",
-        "cursor",
-        "gemini",
-        "multi-agent",
-        "devtools",
-        "linear"
-      ],
-      author: "Edward Becker <edward.becker@mindyournow.com>",
-      license: "MIT",
-      repository: {
-        type: "git",
-        url: "https://github.com/eltmon/panopticon-cli.git"
-      },
-      homepage: "https://github.com/eltmon/panopticon-cli#readme",
-      bugs: {
-        url: "https://github.com/eltmon/panopticon-cli/issues"
-      },
-      type: "module",
-      bin: {
-        pan: "./dist/cli/index.js",
-        panopticon: "./dist/cli/index.js"
-      },
-      main: "./dist/index.js",
-      types: "./dist/index.d.ts",
-      files: [
-        "dist",
-        "templates",
-        "README.md",
-        "LICENSE"
-      ],
-      engines: {
-        node: ">=18.0.0"
-      },
-      scripts: {
-        dev: "tsx watch src/cli/index.ts",
-        build: "tsup",
-        typecheck: "tsc --noEmit",
-        lint: "eslint src/",
-        test: "vitest --no-file-parallelism",
-        "test:unit": "vitest run tests/unit",
-        "test:integration": "vitest run tests/integration",
-        "test:e2e": "vitest run tests/e2e",
-        "test:coverage": "vitest run --coverage",
-        docs: "typedoc",
-        "docs:watch": "typedoc --watch",
-        prepublishOnly: "npm run build",
-        postinstall: "node scripts/postinstall.mjs || true"
-      },
-      dependencies: {
-        "@iarna/toml": "^2.2.5",
-        "@linear/sdk": "^70.0.0",
-        "@octokit/rest": "^22.0.1",
-        "better-sqlite3": "^12.6.2",
-        chalk: "^5.6.2",
-        commander: "^12.1.0",
-        conf: "^12.0.0",
-        execa: "^8.0.1",
-        inquirer: "^9.3.8",
-        ora: "^8.2.0",
-        rally: "^2.1.3",
-        yaml: "^2.8.2"
-      },
-      devDependencies: {
-        "@types/better-sqlite3": "^7.6.13",
-        "@types/inquirer": "^9.0.9",
-        "@types/node": "^20.10.0",
-        "@vitest/coverage-v8": "^1.0.4",
-        eslint: "^8.55.0",
-        tsup: "^8.0.1",
-        tsx: "^4.6.2",
-        typedoc: "^0.25.0",
-        typescript: "^5.3.2",
-        vitest: "^1.0.4"
-      }
+// src/lib/hooks.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, readdirSync as readdirSync3, unlinkSync } from "fs";
+import { join as join3 } from "path";
+function getHookDir(agentId) {
+  return join3(AGENTS_DIR, agentId);
+}
+function getHookFile(agentId) {
+  return join3(getHookDir(agentId), "hook.json");
+}
+function getMailDir(agentId) {
+  return join3(getHookDir(agentId), "mail");
+}
+function initHook(agentId) {
+  const hookDir = getHookDir(agentId);
+  const mailDir = getMailDir(agentId);
+  mkdirSync2(hookDir, { recursive: true });
+  mkdirSync2(mailDir, { recursive: true });
+  const hookFile = getHookFile(agentId);
+  if (!existsSync3(hookFile)) {
+    const hook = {
+      agentId,
+      items: []
     };
+    writeFileSync2(hookFile, JSON.stringify(hook, null, 2));
   }
-});
-
-// src/cli/index.ts
-init_esm_shims();
-import { Command } from "commander";
-import chalk29 from "chalk";
-
-// src/cli/commands/init.ts
-init_esm_shims();
-init_paths();
-import { existsSync, mkdirSync, readdirSync, cpSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import chalk from "chalk";
-import ora from "ora";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var PACKAGE_ROOT = join(__dirname, "..", "..");
-var BUNDLED_SKILLS_DIR = join(PACKAGE_ROOT, "skills");
-var BUNDLED_AGENTS_DIR = join(PACKAGE_ROOT, "agents");
-function copyBundledSkills() {
-  if (!existsSync(BUNDLED_SKILLS_DIR)) {
-    return 0;
-  }
-  if (!existsSync(SKILLS_DIR)) {
-    mkdirSync(SKILLS_DIR, { recursive: true });
-  }
-  const skills = readdirSync(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
-  let copied = 0;
-  for (const skill of skills) {
-    const sourcePath = join(BUNDLED_SKILLS_DIR, skill.name);
-    const targetPath = join(SKILLS_DIR, skill.name);
-    cpSync(sourcePath, targetPath, { recursive: true });
-    copied++;
-  }
-  return copied;
 }
-function copyBundledAgents() {
-  if (!existsSync(BUNDLED_AGENTS_DIR)) {
-    return 0;
-  }
-  if (!existsSync(AGENTS_DIR)) {
-    mkdirSync(AGENTS_DIR, { recursive: true });
+function getHook(agentId) {
+  const hookFile = getHookFile(agentId);
+  if (!existsSync3(hookFile)) {
+    return null;
   }
-  const agents = readdirSync(BUNDLED_AGENTS_DIR, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md"));
-  let copied = 0;
-  for (const agent of agents) {
-    const sourcePath = join(BUNDLED_AGENTS_DIR, agent.name);
-    const targetPath = join(AGENTS_DIR, agent.name);
-    cpSync(sourcePath, targetPath);
-    copied++;
+  try {
+    const content = readFileSync2(hookFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
   }
-  return copied;
 }
-async function initCommand() {
-  const spinner = ora("Initializing Panopticon...").start();
-  if (existsSync(CONFIG_FILE)) {
-    spinner.info("Panopticon already initialized");
-    console.log(chalk.dim(`  Config: ${CONFIG_FILE}`));
-    console.log(chalk.dim(`  Home: ${PANOPTICON_HOME}`));
-    console.log(chalk.dim("  Run `pan sync` to update skills"));
-    return;
-  }
-  try {
-    for (const dir of INIT_DIRS) {
-      if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
+function pushToHook(agentId, item) {
+  initHook(agentId);
+  const hook = getHook(agentId) || { agentId, items: [] };
+  const newItem = {
+    ...item,
+    id: `hook-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  hook.items.push(newItem);
+  writeFileSync2(getHookFile(agentId), JSON.stringify(hook, null, 2));
+  return newItem;
+}
+function checkHook(agentId) {
+  const hook = getHook(agentId);
+  if (!hook || hook.items.length === 0) {
+    const mailDir = getMailDir(agentId);
+    if (existsSync3(mailDir)) {
+      const mails = readdirSync3(mailDir).filter((f) => f.endsWith(".json"));
+      if (mails.length > 0) {
+        const mailItems = mails.map((file) => {
+          try {
+            const content = readFileSync2(join3(mailDir, file), "utf-8");
+            return JSON.parse(content);
+          } catch {
+            return null;
+          }
+        }).filter(Boolean);
+        return {
+          hasWork: mailItems.length > 0,
+          urgentCount: mailItems.filter((i) => i.priority === "urgent").length,
+          items: mailItems
+        };
       }
     }
-    spinner.text = "Created directories...";
-    const config = getDefaultConfig();
-    saveConfig(config);
-    spinner.text = "Created config...";
-    spinner.text = "Installing bundled skills...";
-    const skillsCopied = copyBundledSkills();
-    spinner.text = "Installing bundled agents...";
-    const agentsCopied = copyBundledAgents();
-    const shell = detectShell();
-    const rcFile = getShellRcFile(shell);
-    if (rcFile && existsSync(rcFile)) {
-      addAlias(rcFile);
-      spinner.succeed("Panopticon initialized!");
-      console.log("");
-      console.log(chalk.green("\u2713") + " Created " + chalk.cyan(PANOPTICON_HOME));
-      console.log(chalk.green("\u2713") + " Created " + chalk.cyan(CONFIG_FILE));
-      if (skillsCopied > 0) {
-        console.log(chalk.green("\u2713") + ` Installed ${skillsCopied} bundled skills`);
-      }
-      if (agentsCopied > 0) {
-        console.log(chalk.green("\u2713") + ` Installed ${agentsCopied} bundled agents`);
-      }
-      console.log(chalk.green("\u2713") + " " + getAliasInstructions(shell));
-    } else {
-      spinner.succeed("Panopticon initialized!");
-      console.log("");
-      console.log(chalk.green("\u2713") + " Created " + chalk.cyan(PANOPTICON_HOME));
-      console.log(chalk.green("\u2713") + " Created " + chalk.cyan(CONFIG_FILE));
-      if (skillsCopied > 0) {
-        console.log(chalk.green("\u2713") + ` Installed ${skillsCopied} bundled skills`);
-      }
-      if (agentsCopied > 0) {
-        console.log(chalk.green("\u2713") + ` Installed ${agentsCopied} bundled agents`);
-      }
-      console.log(chalk.yellow("!") + " Could not detect shell. Add alias manually:");
-      console.log(chalk.dim('    alias pan="panopticon"'));
+    return { hasWork: false, urgentCount: 0, items: [] };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const activeItems = hook.items.filter((item) => {
+    if (item.expiresAt) {
+      return new Date(item.expiresAt) > now;
+    }
+    return true;
+  });
+  const priorityOrder = { urgent: 0, high: 1, normal: 2, low: 3 };
+  activeItems.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  return {
+    hasWork: activeItems.length > 0,
+    urgentCount: activeItems.filter((i) => i.priority === "urgent").length,
+    items: activeItems
+  };
+}
+function popFromHook(agentId, itemId) {
+  const hook = getHook(agentId);
+  if (!hook) return false;
+  const index = hook.items.findIndex((i) => i.id === itemId);
+  if (index === -1) return false;
+  hook.items.splice(index, 1);
+  hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync2(getHookFile(agentId), JSON.stringify(hook, null, 2));
+  return true;
+}
+function clearHook(agentId) {
+  const hook = getHook(agentId);
+  if (!hook) return;
+  hook.items = [];
+  hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync2(getHookFile(agentId), JSON.stringify(hook, null, 2));
+}
+function sendMail(toAgentId, from, message, priority = "normal") {
+  initHook(toAgentId);
+  const mailDir = getMailDir(toAgentId);
+  const mailItem = {
+    id: `mail-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    type: "message",
+    priority,
+    source: from,
+    payload: { message },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync2(
+    join3(mailDir, `${mailItem.id}.json`),
+    JSON.stringify(mailItem, null, 2)
+  );
+}
+function generateGUPPPrompt(agentId) {
+  const { hasWork, urgentCount, items } = checkHook(agentId);
+  if (!hasWork) return null;
+  const lines = [
+    "# GUPP: Work Found on Your Hook",
+    "",
+    '> "If there is work on your Hook, YOU MUST RUN IT."',
+    ""
+  ];
+  if (urgentCount > 0) {
+    lines.push(`\u26A0\uFE0F **${urgentCount} URGENT item(s) require immediate attention**`);
+    lines.push("");
+  }
+  lines.push(`## Pending Work Items (${items.length})`);
+  lines.push("");
+  for (const item of items) {
+    const priorityEmoji = {
+      urgent: "\u{1F534}",
+      high: "\u{1F7E0}",
+      normal: "\u{1F7E2}",
+      low: "\u26AA"
+    }[item.priority];
+    lines.push(`### ${priorityEmoji} ${item.type.toUpperCase()}: ${item.id}`);
+    lines.push(`- Source: ${item.source}`);
+    lines.push(`- Created: ${item.createdAt}`);
+    if (item.payload.issueId) {
+      lines.push(`- Issue: ${item.payload.issueId}`);
     }
-    console.log("");
-    console.log("Next steps:");
-    console.log(chalk.dim("  1. Run: pan sync"));
-    console.log(chalk.dim("  2. Start dashboard: pan up"));
-  } catch (error) {
-    spinner.fail("Failed to initialize");
-    console.error(chalk.red(error.message));
-    process.exit(1);
+    if (item.payload.message) {
+      lines.push(`- Message: ${item.payload.message}`);
+    }
+    if (item.payload.action) {
+      lines.push(`- Action: ${item.payload.action}`);
+    }
+    lines.push("");
   }
+  lines.push("---");
+  lines.push("");
+  lines.push("Execute these items in priority order. Use `bd hook pop <id>` after completing each item.");
+  return lines.join("\n");
 }
 
-// src/cli/commands/sync.ts
-init_esm_shims();
-import chalk2 from "chalk";
-import ora2 from "ora";
-init_paths();
-async function syncCommand(options) {
-  const config = loadConfig();
-  const targets = config.sync?.targets;
-  if (!targets || !Array.isArray(targets) || targets.length === 0) {
-    console.log(chalk2.yellow("No sync targets configured."));
-    console.log(chalk2.dim("Edit ~/.panopticon/config.toml to add targets to the [sync] section."));
-    console.log(chalk2.dim('Example: targets = ["claude-code", "cursor"]'));
-    return;
-  }
-  const validTargets = targets;
-  if (options.dryRun) {
-    console.log(chalk2.bold("Sync Plan (dry run):\n"));
-    const hooksPlan = planHooksSync();
-    if (hooksPlan.length > 0) {
-      console.log(chalk2.cyan("hooks (bin scripts):"));
-      for (const hook of hooksPlan) {
-        const icon = hook.status === "new" ? chalk2.green("+") : chalk2.blue("\u21BB");
-        const status = hook.status === "new" ? "" : chalk2.dim("[update]");
-        console.log(`  ${icon} ${hook.name} ${status}`);
-      }
-      console.log("");
+// src/lib/cv.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, readdirSync as readdirSync4 } from "fs";
+import { join as join4 } from "path";
+function getCVFile(agentId) {
+  return join4(AGENTS_DIR, agentId, "cv.json");
+}
+function getAgentCV(agentId) {
+  const cvFile = getCVFile(agentId);
+  if (existsSync4(cvFile)) {
+    try {
+      return JSON.parse(readFileSync3(cvFile, "utf-8"));
+    } catch {
     }
-    for (const runtime of validTargets) {
-      const plan = planSync(runtime);
-      console.log(chalk2.cyan(`${runtime}:`));
-      if (plan.skills.length === 0 && plan.commands.length === 0 && plan.agents.length === 0) {
-        console.log(chalk2.dim("  (nothing to sync)"));
-        continue;
-      }
-      for (const item of plan.skills) {
-        const icon = item.status === "conflict" ? chalk2.yellow("!") : chalk2.green("+");
-        const status = item.status === "conflict" ? chalk2.yellow("[conflict]") : "";
-        console.log(`  ${icon} skill/${item.name} ${status}`);
-      }
-      for (const item of plan.commands) {
-        const icon = item.status === "conflict" ? chalk2.yellow("!") : chalk2.green("+");
-        const status = item.status === "conflict" ? chalk2.yellow("[conflict]") : "";
-        console.log(`  ${icon} command/${item.name} ${status}`);
-      }
-      for (const item of plan.agents) {
-        const icon = item.status === "conflict" ? chalk2.yellow("!") : chalk2.green("+");
-        const status = item.status === "conflict" ? chalk2.yellow("[conflict]") : "";
-        console.log(`  ${icon} agent/${item.name} ${status}`);
+  }
+  const cv = {
+    agentId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActive: (/* @__PURE__ */ new Date()).toISOString(),
+    runtime: "claude",
+    model: "sonnet",
+    stats: {
+      totalIssues: 0,
+      successCount: 0,
+      failureCount: 0,
+      abandonedCount: 0,
+      avgDuration: 0,
+      successRate: 0
+    },
+    skillsUsed: [],
+    recentWork: []
+  };
+  saveAgentCV(cv);
+  return cv;
+}
+function saveAgentCV(cv) {
+  const dir = join4(AGENTS_DIR, cv.agentId);
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync3(getCVFile(cv.agentId), JSON.stringify(cv, null, 2));
+}
+function startWork(agentId, issueId, skills) {
+  const cv = getAgentCV(agentId);
+  const entry = {
+    issueId,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    outcome: "in_progress",
+    skills
+  };
+  cv.recentWork.unshift(entry);
+  cv.stats.totalIssues++;
+  cv.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+  if (skills) {
+    for (const skill of skills) {
+      if (!cv.skillsUsed.includes(skill)) {
+        cv.skillsUsed.push(skill);
       }
-      console.log("");
     }
-    console.log(chalk2.dim("Run without --dry-run to apply changes."));
-    return;
   }
-  if (config.sync.backup_before_sync) {
-    const spinner2 = ora2("Creating backup...").start();
-    const backupDirs = validTargets.flatMap((r) => [
-      SYNC_TARGETS[r].skills,
-      SYNC_TARGETS[r].commands,
-      SYNC_TARGETS[r].agents
-    ]);
-    const backup2 = createBackup(backupDirs);
-    if (backup2.targets.length > 0) {
-      spinner2.succeed(`Backup created: ${backup2.timestamp}`);
-    } else {
-      spinner2.info("No existing content to backup");
+  if (cv.recentWork.length > 50) {
+    cv.recentWork = cv.recentWork.slice(0, 50);
+  }
+  saveAgentCV(cv);
+}
+function getAgentRankings() {
+  const rankings = [];
+  if (!existsSync4(AGENTS_DIR)) return rankings;
+  const dirs = readdirSync4(AGENTS_DIR, { withFileTypes: true }).filter(
+    (d) => d.isDirectory()
+  );
+  for (const dir of dirs) {
+    const cv = getAgentCV(dir.name);
+    if (cv.stats.totalIssues > 0) {
+      rankings.push({
+        agentId: dir.name,
+        successRate: cv.stats.successRate,
+        totalIssues: cv.stats.totalIssues,
+        avgDuration: cv.stats.avgDuration
+      });
     }
-    if (options.backupOnly) {
-      return;
+  }
+  rankings.sort((a, b) => {
+    if (b.successRate !== a.successRate) {
+      return b.successRate - a.successRate;
     }
+    return b.totalIssues - a.totalIssues;
+  });
+  return rankings;
+}
+function formatCV(cv) {
+  const lines = [
+    `# Agent CV: ${cv.agentId}`,
+    "",
+    `Runtime: ${cv.runtime} (${cv.model})`,
+    `Created: ${cv.createdAt}`,
+    `Last Active: ${cv.lastActive}`,
+    "",
+    "## Statistics",
+    "",
+    `- Total Issues: ${cv.stats.totalIssues}`,
+    `- Success Rate: ${(cv.stats.successRate * 100).toFixed(1)}%`,
+    `- Successes: ${cv.stats.successCount}`,
+    `- Failures: ${cv.stats.failureCount}`,
+    `- Abandoned: ${cv.stats.abandonedCount}`,
+    `- Avg Duration: ${cv.stats.avgDuration} minutes`,
+    ""
+  ];
+  if (cv.skillsUsed.length > 0) {
+    lines.push("## Skills Used");
+    lines.push("");
+    lines.push(cv.skillsUsed.join(", "));
+    lines.push("");
   }
-  const spinner = ora2("Syncing...").start();
-  let totalCreated = 0;
-  let totalConflicts = 0;
-  for (const runtime of validTargets) {
-    spinner.text = `Syncing to ${runtime}...`;
-    const result = executeSync(runtime, { force: options.force });
-    totalCreated += result.created.length;
-    totalConflicts += result.conflicts.length;
-    if (result.conflicts.length > 0 && !options.force) {
-      console.log("");
-      console.log(chalk2.yellow(`Conflicts in ${runtime}:`));
-      for (const name of result.conflicts) {
-        console.log(chalk2.dim(`  - ${name} (use --force to overwrite)`));
+  if (cv.recentWork.length > 0) {
+    lines.push("## Recent Work");
+    lines.push("");
+    for (const work of cv.recentWork.slice(0, 10)) {
+      const statusIcon = {
+        success: "\u2713",
+        failed: "\u2717",
+        abandoned: "\u2298",
+        in_progress: "\u25CF"
+      }[work.outcome];
+      const duration = work.duration ? ` (${work.duration}m)` : "";
+      lines.push(`${statusIcon} ${work.issueId}${duration}`);
+      if (work.failureReason) {
+        lines.push(`  Reason: ${work.failureReason}`);
       }
     }
+    lines.push("");
   }
-  if (totalConflicts > 0 && !options.force) {
-    spinner.warn(`Synced ${totalCreated} items, ${totalConflicts} conflicts`);
-    console.log("");
-    console.log(chalk2.dim("Use --force to overwrite conflicting items."));
-  } else {
-    spinner.succeed(`Synced ${totalCreated} items to ${validTargets.join(", ")}`);
+  return lines.join("\n");
+}
+
+// src/lib/agents.ts
+function getAgentDir(agentId) {
+  return join5(AGENTS_DIR, agentId);
+}
+function getAgentState(agentId) {
+  const stateFile = join5(getAgentDir(agentId), "state.json");
+  if (!existsSync5(stateFile)) return null;
+  const content = readFileSync4(stateFile, "utf8");
+  return JSON.parse(content);
+}
+function saveAgentState(state) {
+  const dir = getAgentDir(state.id);
+  mkdirSync4(dir, { recursive: true });
+  writeFileSync4(
+    join5(dir, "state.json"),
+    JSON.stringify(state, null, 2)
+  );
+}
+function spawnAgent(options) {
+  const agentId = `agent-${options.issueId.toLowerCase()}`;
+  if (sessionExists(agentId)) {
+    throw new Error(`Agent ${agentId} already running. Use 'pan work tell' to message it.`);
   }
-  const hooksSpinner = ora2("Syncing hooks...").start();
-  const hooksResult = syncHooks();
-  if (hooksResult.errors.length > 0) {
-    hooksSpinner.warn(`Synced ${hooksResult.synced.length} hooks, ${hooksResult.errors.length} errors`);
-    for (const error of hooksResult.errors) {
-      console.log(chalk2.red(`  \u2717 ${error}`));
+  initHook(agentId);
+  const state = {
+    id: agentId,
+    issueId: options.issueId,
+    workspace: options.workspace,
+    runtime: options.runtime || "claude",
+    model: options.model || "sonnet",
+    status: "starting",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    // Initialize Phase 4 fields
+    handoffCount: 0,
+    costSoFar: 0
+  };
+  saveAgentState(state);
+  let prompt = options.prompt || "";
+  const { hasWork, items } = checkHook(agentId);
+  if (hasWork) {
+    const guppPrompt = generateGUPPPrompt(agentId);
+    if (guppPrompt) {
+      prompt = guppPrompt + "\n\n---\n\n" + prompt;
     }
-  } else if (hooksResult.synced.length > 0) {
-    hooksSpinner.succeed(`Synced ${hooksResult.synced.length} hooks to ~/.panopticon/bin/`);
-  } else {
-    hooksSpinner.info("No hooks to sync");
   }
-}
-
-// src/cli/commands/restore.ts
-init_esm_shims();
-import chalk3 from "chalk";
-import ora3 from "ora";
-import inquirer from "inquirer";
-init_paths();
-async function restoreCommand(timestamp) {
-  const backups = listBackups();
-  if (backups.length === 0) {
-    console.log(chalk3.yellow("No backups found."));
-    return;
+  const promptFile = join5(getAgentDir(agentId), "initial-prompt.md");
+  if (prompt) {
+    writeFileSync4(promptFile, prompt);
   }
-  if (!timestamp) {
-    console.log(chalk3.bold("Available backups:\n"));
-    for (const backup2 of backups.slice(0, 10)) {
-      console.log(`  ${chalk3.cyan(backup2.timestamp)} - ${backup2.targets.join(", ")}`);
-    }
-    if (backups.length > 10) {
-      console.log(chalk3.dim(`  ... and ${backups.length - 10} more`));
+  checkAndSetupHooks();
+  writeTaskCache(agentId, options.issueId);
+  const claudeCmd = `claude --dangerously-skip-permissions --model ${state.model}`;
+  createSession(agentId, options.workspace, claudeCmd, {
+    env: {
+      PANOPTICON_AGENT_ID: agentId
     }
-    console.log("");
-    const { selected } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "selected",
-        message: "Select backup to restore:",
-        choices: backups.slice(0, 10).map((b) => ({
-          name: `${b.timestamp} (${b.targets.join(", ")})`,
-          value: b.timestamp
-        }))
+  });
+  if (prompt) {
+    let ready = false;
+    for (let i = 0; i < 15; i++) {
+      execSync2("sleep 1");
+      try {
+        const pane = execSync2(`tmux capture-pane -t ${agentId} -p`, { encoding: "utf-8" });
+        if (pane.includes("\u276F") || pane.includes(">")) {
+          ready = true;
+          break;
+        }
+      } catch {
       }
-    ]);
-    timestamp = selected;
-  }
-  const { confirm } = await inquirer.prompt([
-    {
-      type: "confirm",
-      name: "confirm",
-      message: `Restore backup ${timestamp}? This will overwrite current files.`,
-      default: false
     }
-  ]);
-  if (!confirm) {
-    console.log(chalk3.dim("Restore cancelled."));
-    return;
+    if (ready) {
+      execSync2(`tmux load-buffer "${promptFile}"`);
+      execSync2(`tmux paste-buffer -t ${agentId}`);
+      execSync2("sleep 0.5");
+      execSync2(`tmux send-keys -t ${agentId} Enter`);
+    } else {
+      console.error("Claude did not become ready in time, prompt not sent");
+    }
   }
-  const spinner = ora3("Restoring backup...").start();
-  try {
-    const config = loadConfig();
-    const targets = config.sync.targets;
-    const targetDirs = {};
-    for (const runtime of targets) {
-      targetDirs[`${runtime}-skills`] = SYNC_TARGETS[runtime].skills;
-      targetDirs[`${runtime}-commands`] = SYNC_TARGETS[runtime].commands;
-      targetDirs["skills"] = SYNC_TARGETS[runtime].skills;
-      targetDirs["commands"] = SYNC_TARGETS[runtime].commands;
+  state.status = "running";
+  saveAgentState(state);
+  startWork(agentId, options.issueId);
+  return state;
+}
+function listRunningAgents() {
+  const tmuxSessions = getAgentSessions();
+  const tmuxNames = new Set(tmuxSessions.map((s) => s.name));
+  const agents = [];
+  if (!existsSync5(AGENTS_DIR)) return agents;
+  const dirs = readdirSync5(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const dir of dirs) {
+    const state = getAgentState(dir.name);
+    if (state) {
+      agents.push({
+        ...state,
+        tmuxActive: tmuxNames.has(state.id)
+      });
     }
-    restoreBackup(timestamp, targetDirs);
-    spinner.succeed(`Restored backup: ${timestamp}`);
-  } catch (error) {
-    spinner.fail("Failed to restore");
-    console.error(chalk3.red(error.message));
-    process.exit(1);
   }
+  return agents;
 }
-
-// src/cli/commands/backup.ts
-init_esm_shims();
-import chalk4 from "chalk";
-async function backupListCommand(options) {
-  const backups = listBackups();
-  if (options.json) {
-    console.log(JSON.stringify(backups, null, 2));
-    return;
+function stopAgent(agentId) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  if (sessionExists(normalizedId)) {
+    killSession(normalizedId);
   }
-  if (backups.length === 0) {
-    console.log(chalk4.dim("No backups found."));
-    console.log(chalk4.dim("Backups are created automatically during sync."));
-    return;
+  const state = getAgentState(normalizedId);
+  if (state) {
+    state.status = "stopped";
+    saveAgentState(state);
   }
-  console.log(chalk4.bold("Backups:\n"));
-  for (const backup2 of backups) {
-    console.log(`  ${chalk4.cyan(backup2.timestamp)}`);
-    console.log(`    ${chalk4.dim("Contains:")} ${backup2.targets.join(", ")}`);
+}
+function messageAgent(agentId, message) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  if (!sessionExists(normalizedId)) {
+    throw new Error(`Agent ${normalizedId} not running`);
   }
-  console.log();
-  console.log(chalk4.dim(`Total: ${backups.length} backups`));
-  console.log(chalk4.dim("Use `pan restore <timestamp>` to restore a backup."));
+  sendKeys(normalizedId, message);
+  const mailDir = join5(getAgentDir(normalizedId), "mail");
+  mkdirSync4(mailDir, { recursive: true });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  writeFileSync4(
+    join5(mailDir, `${timestamp}.md`),
+    `# Message
+
+${message}
+`
+  );
 }
-async function backupCleanCommand(options) {
-  const keepCount = parseInt(options.keep || "10", 10);
-  const removed = cleanOldBackups(keepCount);
-  if (removed === 0) {
-    console.log(chalk4.dim(`No backups removed (keeping ${keepCount}).`));
-  } else {
-    console.log(chalk4.green(`Removed ${removed} old backup(s), keeping ${keepCount}.`));
+function detectCrashedAgents() {
+  const agents = listRunningAgents();
+  return agents.filter(
+    (agent) => agent.status === "running" && !agent.tmuxActive
+  );
+}
+function recoverAgent(agentId) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  const state = getAgentState(normalizedId);
+  if (!state) {
+    return null;
+  }
+  if (sessionExists(normalizedId)) {
+    return state;
+  }
+  const healthFile = join5(getAgentDir(normalizedId), "health.json");
+  let health = { consecutiveFailures: 0, killCount: 0, recoveryCount: 0 };
+  if (existsSync5(healthFile)) {
+    try {
+      health = { ...health, ...JSON.parse(readFileSync4(healthFile, "utf-8")) };
+    } catch {
+    }
   }
+  health.recoveryCount = (health.recoveryCount || 0) + 1;
+  writeFileSync4(healthFile, JSON.stringify(health, null, 2));
+  const recoveryPrompt = generateRecoveryPrompt(state);
+  const claudeCmd = `claude --dangerously-skip-permissions --model ${state.model} "${recoveryPrompt.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+  createSession(normalizedId, state.workspace, claudeCmd);
+  state.status = "running";
+  state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  saveAgentState(state);
+  return state;
 }
-
-// src/cli/commands/skills.ts
-init_esm_shims();
-init_paths();
-import { readdirSync as readdirSync2, readFileSync, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-import chalk5 from "chalk";
-function parseSkillFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return {};
-  const frontmatter = match[1];
-  const name = frontmatter.match(/name:\s*(.+)/)?.[1]?.trim();
-  const description = frontmatter.match(/description:\s*(.+)/)?.[1]?.trim();
-  return { name, description };
+function generateRecoveryPrompt(state) {
+  const lines = [
+    "# Agent Recovery",
+    "",
+    "\u26A0\uFE0F This agent session was recovered after a crash.",
+    "",
+    "## Previous Context",
+    `- Issue: ${state.issueId}`,
+    `- Workspace: ${state.workspace}`,
+    `- Started: ${state.startedAt}`,
+    "",
+    "## Recovery Steps",
+    "1. Check beads for context: `bd show " + state.issueId + "`",
+    "2. Review recent git commits: `git log --oneline -10`",
+    "3. Check hook for pending work: `pan work hook check`",
+    "4. Resume from last known state",
+    "",
+    "## GUPP Reminder",
+    '> "If there is work on your Hook, YOU MUST RUN IT."',
+    ""
+  ];
+  const { hasWork } = checkHook(state.id);
+  if (hasWork) {
+    const guppPrompt = generateGUPPPrompt(state.id);
+    if (guppPrompt) {
+      lines.push("---");
+      lines.push("");
+      lines.push(guppPrompt);
+    }
+  }
+  return lines.join("\n");
 }
-function listSkills() {
-  if (!existsSync2(SKILLS_DIR)) return [];
-  const skills = [];
-  const dirs = readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
-  for (const dir of dirs) {
-    const skillFile = join2(SKILLS_DIR, dir.name, "SKILL.md");
-    if (!existsSync2(skillFile)) continue;
-    const content = readFileSync(skillFile, "utf8");
-    const { name, description } = parseSkillFrontmatter(content);
-    skills.push({
-      name: name || dir.name,
-      description: description || "(no description)",
-      path: skillFile
-    });
+function autoRecoverAgents() {
+  const crashed = detectCrashedAgents();
+  const recovered = [];
+  const failed = [];
+  for (const agent of crashed) {
+    try {
+      const result = recoverAgent(agent.id);
+      if (result) {
+        recovered.push(agent.id);
+      } else {
+        failed.push(agent.id);
+      }
+    } catch (error) {
+      failed.push(agent.id);
+    }
   }
-  return skills.sort((a, b) => a.name.localeCompare(b.name));
+  return { recovered, failed };
 }
-async function skillsCommand(options) {
-  const skills = listSkills();
-  if (options.json) {
-    console.log(JSON.stringify(skills, null, 2));
-    return;
-  }
-  console.log(chalk5.bold(`
-Panopticon Skills (${skills.length})
-`));
-  if (skills.length === 0) {
-    console.log(chalk5.yellow("No skills found."));
-    console.log(chalk5.dim("Skills should be in ~/.panopticon/skills/<name>/SKILL.md"));
-    return;
+function checkAndSetupHooks() {
+  const settingsPath = join5(homedir(), ".claude", "settings.json");
+  const hookPath = join5(homedir(), ".panopticon", "bin", "heartbeat-hook");
+  if (existsSync5(settingsPath)) {
+    try {
+      const settingsContent = readFileSync4(settingsPath, "utf-8");
+      const settings = JSON.parse(settingsContent);
+      const postToolUse = settings?.hooks?.PostToolUse || [];
+      const hookConfigured = postToolUse.some(
+        (hookConfig) => hookConfig.hooks?.some(
+          (hook) => hook.command === hookPath || hook.command?.includes("panopticon") || hook.command?.includes("heartbeat-hook")
+        )
+      );
+      if (hookConfigured) {
+        return;
+      }
+    } catch {
+    }
   }
-  for (const skill of skills) {
-    console.log(chalk5.cyan(skill.name));
-    console.log(chalk5.dim(`  ${skill.description}`));
+  try {
+    console.log("Configuring Panopticon heartbeat hooks...");
+    execSync2("pan setup hooks", { stdio: "pipe" });
+    console.log("\u2713 Heartbeat hooks configured");
+  } catch (error) {
+    console.warn("\u26A0 Failed to auto-configure hooks. Run `pan setup hooks` manually.");
   }
-  console.log(`
-${chalk5.dim('Run "pan sync" to sync skills to Claude Code')}`);
 }
-
-// src/cli/commands/work/index.ts
-init_esm_shims();
+function writeTaskCache(agentId, issueId) {
+  const cacheDir = join5(getAgentDir(agentId));
+  mkdirSync4(cacheDir, { recursive: true });
+  const cacheFile = join5(cacheDir, "current-task.json");
+  writeFileSync4(
+    cacheFile,
+    JSON.stringify({
+      id: issueId,
+      title: `Working on ${issueId}`,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2)
+  );
+}
 
 // src/cli/commands/work/issue.ts
-init_esm_shims();
-init_agents();
-import chalk6 from "chalk";
-import ora4 from "ora";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
 function findWorkspace(issueId, labels = []) {
   const normalizedId = issueId.toLowerCase();
   const resolved = resolveProjectFromIssue(issueId, labels);
@@ -1431,8 +1281,6 @@ async function issueCommand(id, options) {
 }
 
 // src/cli/commands/work/status.ts
-init_esm_shims();
-init_agents();
 import chalk7 from "chalk";
 async function statusCommand(options) {
   const agents = listRunningAgents();
@@ -1462,8 +1310,6 @@ async function statusCommand(options) {
 }
 
 // src/cli/commands/work/tell.ts
-init_esm_shims();
-init_agents();
 import chalk8 from "chalk";
 async function tellCommand(id, message) {
   const agentId = id.startsWith("agent-") ? id : `agent-${id.toLowerCase()}`;
@@ -1478,9 +1324,6 @@ async function tellCommand(id, message) {
 }
 
 // src/cli/commands/work/kill.ts
-init_esm_shims();
-init_agents();
-init_tmux();
 import chalk9 from "chalk";
 async function killCommand(id, options) {
   const agentId = id.startsWith("agent-") ? id : `agent-${id.toLowerCase()}`;
@@ -1502,9 +1345,6 @@ async function killCommand(id, options) {
 }
 
 // src/cli/commands/work/pending.ts
-init_esm_shims();
-init_agents();
-init_paths();
 import chalk10 from "chalk";
 import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import { join as join7 } from "path";
@@ -1534,17 +1374,14 @@ async function pendingCommand() {
 }
 
 // src/cli/commands/work/approve.ts
-init_esm_shims();
-init_agents();
-init_paths();
 import chalk11 from "chalk";
 import ora5 from "ora";
-import { existsSync as existsSync8, writeFileSync as writeFileSync4, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync7 } from "fs";
 import { join as join8 } from "path";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 import { execSync as execSync3 } from "child_process";
 function getLinearApiKey() {
-  const envFile = join8(homedir(), ".panopticon.env");
+  const envFile = join8(homedir2(), ".panopticon.env");
   if (existsSync8(envFile)) {
     const content = readFileSync7(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
@@ -1668,7 +1505,7 @@ async function approveCommand(id, options = {}) {
     state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
     saveAgentState(state);
     const approvedFile = join8(AGENTS_DIR, agentId, "approved");
-    writeFileSync4(approvedFile, JSON.stringify({
+    writeFileSync5(approvedFile, JSON.stringify({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       prMerged,
       linearUpdated
@@ -1689,16 +1526,15 @@ async function approveCommand(id, options = {}) {
 }
 
 // src/cli/commands/work/plan.ts
-init_esm_shims();
 import chalk12 from "chalk";
 import ora6 from "ora";
 import inquirer2 from "inquirer";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
 import { join as join9, dirname as dirname3 } from "path";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 import { execSync as execSync4 } from "child_process";
 function getLinearApiKey2() {
-  const envFile = join9(homedir2(), ".panopticon.env");
+  const envFile = join9(homedir3(), ".panopticon.env");
   if (existsSync9(envFile)) {
     const content = readFileSync8(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
@@ -2084,7 +1920,7 @@ function copyToPRDDirectory(issue, stateContent) {
     mkdirSync5(prdDir, { recursive: true });
     const filename = `${issue.identifier.toLowerCase()}-plan.md`;
     const prdPath = join9(prdDir, filename);
-    writeFileSync5(prdPath, stateContent);
+    writeFileSync6(prdPath, stateContent);
     return prdPath;
   } catch {
     return null;
@@ -2201,9 +2037,9 @@ async function planCommand(id, options = {}) {
     const planningDir = join9(outputDir, ".planning");
     mkdirSync5(planningDir, { recursive: true });
     const statePath = join9(planningDir, "STATE.md");
-    writeFileSync5(statePath, stateContent);
+    writeFileSync6(statePath, stateContent);
     const workspacePath = join9(planningDir, "WORKSPACE.md");
-    writeFileSync5(workspacePath, workspaceContent);
+    writeFileSync6(workspacePath, workspaceContent);
     spinnerCreate.succeed("Context files created");
     const spinnerBeads = ora6("Creating Beads tasks...").start();
     const beadsResult = createBeadsTasks(issueData, tasks);
@@ -2267,7 +2103,6 @@ async function planCommand(id, options = {}) {
 }
 
 // src/cli/commands/work/list.ts
-init_esm_shims();
 import chalk13 from "chalk";
 import ora7 from "ora";
 var PRIORITY_LABELS = {
@@ -2414,12 +2249,11 @@ ${tracker.toUpperCase()} (${issues.length} issues)
 }
 
 // src/cli/commands/work/triage.ts
-init_esm_shims();
 import chalk14 from "chalk";
 import ora8 from "ora";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
 import { join as join10 } from "path";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 function getTrackerConfig2(trackerType) {
   const config = loadConfig();
   const trackerConfig = config.trackers[trackerType];
@@ -2437,7 +2271,7 @@ function getTrackerConfig2(trackerType) {
   };
 }
 function getTriageStatePath() {
-  return join10(homedir3(), ".panopticon", "triage-state.json");
+  return join10(homedir4(), ".panopticon", "triage-state.json");
 }
 function loadTriageState() {
   const path = getTriageStatePath();
@@ -2451,12 +2285,12 @@ function loadTriageState() {
   return { dismissed: [], created: {} };
 }
 function saveTriageState(state) {
-  const dir = join10(homedir3(), ".panopticon");
+  const dir = join10(homedir4(), ".panopticon");
   if (!existsSync10(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
   const path = getTriageStatePath();
-  writeFileSync6(path, JSON.stringify(state, null, 2));
+  writeFileSync7(path, JSON.stringify(state, null, 2));
 }
 async function triageCommand(id, options = {}) {
   const spinner = ora8("Loading triage queue...").start();
@@ -2592,8 +2426,6 @@ ${secondaryType.toUpperCase()} Issues Pending Triage (${pending.length})
 }
 
 // src/cli/commands/work/hook.ts
-init_esm_shims();
-init_hooks();
 import chalk15 from "chalk";
 async function hookCommand(action, idOrMessage, options = {}) {
   const agentId = process.env.PANOPTICON_AGENT_ID || "default";
@@ -2709,8 +2541,6 @@ async function hookCommand(action, idOrMessage, options = {}) {
 }
 
 // src/cli/commands/work/recover.ts
-init_esm_shims();
-init_agents();
 import chalk16 from "chalk";
 import ora9 from "ora";
 async function recoverCommand(id, options = {}) {
@@ -2787,8 +2617,6 @@ async function recoverCommand(id, options = {}) {
 }
 
 // src/cli/commands/work/cv.ts
-init_esm_shims();
-init_cv();
 import chalk17 from "chalk";
 async function cvCommand(agentId, options = {}) {
   if (options.rankings || !agentId) {
@@ -2831,13 +2659,10 @@ async function cvCommand(agentId, options = {}) {
 }
 
 // src/cli/commands/work/context.ts
-init_esm_shims();
 import chalk18 from "chalk";
 
 // src/lib/context.ts
-init_esm_shims();
-init_paths();
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7, appendFileSync, readdirSync as readdirSync8 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync8, appendFileSync, readdirSync as readdirSync8 } from "fs";
 import { join as join11 } from "path";
 function getStateFile(agentId) {
   return join11(AGENTS_DIR, agentId, "STATE.md");
@@ -2856,7 +2681,7 @@ function writeAgentState(agentId, state) {
   const dir = join11(AGENTS_DIR, agentId);
   mkdirSync7(dir, { recursive: true });
   const content = generateStateMd(state);
-  writeFileSync7(getStateFile(agentId), content);
+  writeFileSync8(getStateFile(agentId), content);
 }
 function updateCheckpoint(agentId, checkpoint, resumePoint) {
   const state = readAgentState(agentId);
@@ -2940,7 +2765,7 @@ function appendSummary(agentId, summary) {
   if (existsSync11(summaryFile)) {
     appendFileSync(summaryFile, "\n---\n\n" + content);
   } else {
-    writeFileSync7(summaryFile, "# Work Summaries\n\n" + content);
+    writeFileSync8(summaryFile, "# Work Summaries\n\n" + content);
   }
 }
 function generateSummaryEntry(summary) {
@@ -3218,14 +3043,10 @@ History matches for "${pattern}":
 }
 
 // src/cli/commands/work/health.ts
-init_esm_shims();
 import chalk19 from "chalk";
 
 // src/lib/health.ts
-init_esm_shims();
-init_paths();
-init_agents();
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
 import { join as join12 } from "path";
 import { execSync as execSync5 } from "child_process";
 var DEFAULT_PING_TIMEOUT_MS = 30 * 1e3;
@@ -3257,7 +3078,7 @@ function getAgentHealth(agentId) {
 function saveAgentHealth(health) {
   const dir = join12(AGENTS_DIR, health.agentId);
   mkdirSync8(dir, { recursive: true });
-  writeFileSync8(getHealthFile(health.agentId), JSON.stringify(health, null, 2));
+  writeFileSync9(getHealthFile(health.agentId), JSON.stringify(health, null, 2));
 }
 function isAgentAlive(agentId) {
   try {
@@ -3469,7 +3290,6 @@ function formatHealthStatus(health) {
 }
 
 // src/cli/commands/work/health.ts
-init_agents();
 async function healthCommand(action, arg, options = {}) {
   const config = {
     pingTimeoutMs: DEFAULT_PING_TIMEOUT_MS,
@@ -3640,14 +3460,12 @@ function registerWorkCommands(program2) {
 }
 
 // src/cli/commands/workspace.ts
-init_esm_shims();
 import chalk20 from "chalk";
 import ora10 from "ora";
-import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
 import { join as join15, basename as basename2 } from "path";
 
 // src/lib/worktree.ts
-init_esm_shims();
 import { execSync as execSync6 } from "child_process";
 import { mkdirSync as mkdirSync9 } from "fs";
 import { dirname as dirname4 } from "path";
@@ -3698,8 +3516,6 @@ function removeWorktree(repoPath, worktreePath) {
 }
 
 // src/lib/template.ts
-init_esm_shims();
-init_paths();
 import { readFileSync as readFileSync13, existsSync as existsSync14, readdirSync as readdirSync9 } from "fs";
 import { join as join13 } from "path";
 function loadTemplate(templatePath) {
@@ -3757,8 +3573,6 @@ This workspace was created by Panopticon. Use \`bd\` commands to track your work
 }
 
 // src/lib/skills-merge.ts
-init_esm_shims();
-init_paths();
 import {
   existsSync as existsSync15,
   readdirSync as readdirSync10,
@@ -3914,7 +3728,7 @@ async function createCommand(issueId, options) {
       PROJECT_NAME: projectName
     };
     const claudeMd = generateClaudeMd(projectRoot, variables);
-    writeFileSync9(join15(workspacePath, "CLAUDE.md"), claudeMd);
+    writeFileSync10(join15(workspacePath, "CLAUDE.md"), claudeMd);
     let skillsResult = { added: [], skipped: [] };
     if (options.skills !== false) {
       spinner.text = "Merging skills...";
@@ -3945,7 +3759,7 @@ async function createCommand(issueId, options) {
   }
 }
 async function listCommand2(options) {
-  const { listProjects: listProjects3 } = await import("../projects-6JVKIYIH.js");
+  const { listProjects: listProjects3 } = await import("../projects-54CV437J.js");
   const projects = listProjects3();
   if (projects.length > 0 && options.all) {
     const allWorkspaces = [];
@@ -4062,14 +3876,12 @@ async function destroyCommand(issueId, options) {
 }
 
 // src/cli/commands/install.ts
-init_esm_shims();
-init_paths();
 import chalk21 from "chalk";
 import ora11 from "ora";
 import { execSync as execSync8 } from "child_process";
 import { existsSync as existsSync17, mkdirSync as mkdirSync12, readFileSync as readFileSync14, copyFileSync, readdirSync as readdirSync11, statSync } from "fs";
 import { join as join16 } from "path";
-import { homedir as homedir4, platform } from "os";
+import { homedir as homedir5, platform } from "os";
 function registerInstallCommand(program2) {
   program2.command("install").description("Install Panopticon prerequisites").option("--check", "Check prerequisites only").option("--minimal", "Skip Traefik and mkcert (use port-based routing)").option("--skip-mkcert", "Skip mkcert/HTTPS setup").option("--skip-docker", "Skip Docker network setup").action(installCommand);
 }
@@ -4165,7 +3977,7 @@ function checkPrerequisites() {
     message: hasBeads ? "installed" : "not found",
     fix: "cargo install beads-cli"
   });
-  const hasTtyd = checkCommand("ttyd") || existsSync17(join16(homedir4(), "bin", "ttyd"));
+  const hasTtyd = checkCommand("ttyd") || existsSync17(join16(homedir5(), "bin", "ttyd"));
   results.push({
     name: "ttyd",
     passed: hasTtyd,
@@ -4245,11 +4057,11 @@ async function installCommand(options) {
       spinner.info("Skipping mkcert (not installed)");
     }
   }
-  const hasTtyd = checkCommand("ttyd") || existsSync17(join16(homedir4(), "bin", "ttyd"));
+  const hasTtyd = checkCommand("ttyd") || existsSync17(join16(homedir5(), "bin", "ttyd"));
   if (!hasTtyd) {
     spinner.start("Installing ttyd (web terminal)...");
     try {
-      const binDir = join16(homedir4(), "bin");
+      const binDir = join16(homedir5(), "bin");
       mkdirSync12(binDir, { recursive: true });
       const ttydPath = join16(binDir, "ttyd");
       const plat2 = detectPlatform();
@@ -4328,20 +4140,11 @@ async function installCommand(options) {
   console.log("");
 }
 
-// src/cli/commands/cloister/index.ts
-init_esm_shims();
-
 // src/cli/commands/cloister/status.ts
-init_esm_shims();
 import chalk22 from "chalk";
 
-// src/lib/cloister/service.ts
-init_esm_shims();
-
 // src/lib/cloister/config.ts
-init_esm_shims();
-init_paths();
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, existsSync as existsSync18, mkdirSync as mkdirSync13 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync12, existsSync as existsSync18, mkdirSync as mkdirSync13 } from "fs";
 import { parse, stringify } from "@iarna/toml";
 import { join as join17 } from "path";
 var CLOISTER_CONFIG_FILE = join17(PANOPTICON_HOME, "cloister.toml");
@@ -4470,7 +4273,7 @@ function saveCloisterConfig(config) {
   }
   try {
     const content = stringify(config);
-    writeFileSync11(CLOISTER_CONFIG_FILE, content, "utf-8");
+    writeFileSync12(CLOISTER_CONFIG_FILE, content, "utf-8");
   } catch (error) {
     console.error("Failed to save Cloister config:", error);
     throw error;
@@ -4486,7 +4289,6 @@ function getHealthThresholdsMs() {
 }
 
 // src/lib/cloister/health.ts
-init_esm_shims();
 function evaluateHealthState(timeSinceActivityMs, thresholds) {
   if (timeSinceActivityMs < thresholds.stale) {
     return "active";
@@ -4580,8 +4382,6 @@ function getHealthLabel(state) {
 }
 
 // src/lib/cloister/database.ts
-init_esm_shims();
-init_paths();
 import Database from "better-sqlite3";
 import { join as join18 } from "path";
 import { existsSync as existsSync19, mkdirSync as mkdirSync14 } from "fs";
@@ -4655,21 +4455,16 @@ function cleanupOldEvents(database = getHealthDatabase(), retentionDays = RETENT
 }
 
 // src/lib/cloister/specialists.ts
-init_esm_shims();
-init_paths();
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync12, existsSync as existsSync21, mkdirSync as mkdirSync15, readdirSync as readdirSync13, unlinkSync as unlinkSync2 } from "fs";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync13, existsSync as existsSync21, mkdirSync as mkdirSync15, readdirSync as readdirSync13, unlinkSync as unlinkSync2 } from "fs";
 import { join as join21, basename as basename4 } from "path";
 import { execSync as execSync9 } from "child_process";
 
 // src/lib/cost-parsers/jsonl-parser.ts
-init_esm_shims();
 import { existsSync as existsSync20, readFileSync as readFileSync16, readdirSync as readdirSync12, statSync as statSync2 } from "fs";
 import { join as join20, basename as basename3 } from "path";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 
 // src/lib/cost.ts
-init_esm_shims();
-init_paths();
 import { join as join19 } from "path";
 var DEFAULT_PRICING = [
   // Anthropic
@@ -4710,7 +4505,7 @@ function getPricing(provider, model) {
 var BUDGETS_FILE = join19(COSTS_DIR, "budgets.json");
 
 // src/lib/cost-parsers/jsonl-parser.ts
-var CLAUDE_PROJECTS_DIR = join20(homedir5(), ".claude", "projects");
+var CLAUDE_PROJECTS_DIR = join20(homedir6(), ".claude", "projects");
 function getProjectDirs() {
   if (!existsSync20(CLAUDE_PROJECTS_DIR)) {
     return [];
@@ -4735,6 +4530,19 @@ function getSessionFiles(projectDir) {
     }
   });
 }
+function getAllSessionFiles() {
+  const files = [];
+  for (const projectDir of getProjectDirs()) {
+    files.push(...getSessionFiles(projectDir));
+  }
+  return files.sort((a, b) => {
+    try {
+      return statSync2(b).mtime.getTime() - statSync2(a).mtime.getTime();
+    } catch {
+      return 0;
+    }
+  });
+}
 function normalizeModelName(model) {
   if (model.includes("claude")) {
     let normalizedModel = model;
@@ -4887,7 +4695,7 @@ function saveRegistry(registry) {
   registry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   try {
     const content = JSON.stringify(registry, null, 2);
-    writeFileSync12(REGISTRY_FILE, content, "utf-8");
+    writeFileSync13(REGISTRY_FILE, content, "utf-8");
   } catch (error) {
     console.error("Failed to save specialist registry:", error);
     throw error;
@@ -4908,6 +4716,23 @@ function getSessionId(name) {
     return null;
   }
 }
+function clearSessionId(name) {
+  const sessionFile = getSessionFilePath(name);
+  if (!existsSync21(sessionFile)) {
+    return false;
+  }
+  try {
+    unlinkSync2(sessionFile);
+    return true;
+  } catch (error) {
+    console.error(`Failed to delete session file for ${name}:`, error);
+    throw error;
+  }
+}
+function getSpecialistMetadata(name) {
+  const registry = loadRegistry();
+  return registry.specialists.find((s) => s.name === name) || null;
+}
 function updateSpecialistMetadata(name, updates) {
   const registry = loadRegistry();
   const index = registry.specialists.findIndex((s) => s.name === name);
@@ -4941,6 +4766,34 @@ function recordWake(name, sessionId) {
 function getEnabledSpecialists() {
   return getAllSpecialists().filter((s) => s.enabled);
 }
+function findSessionFile(sessionId) {
+  try {
+    const allFiles = getAllSessionFiles();
+    for (const file of allFiles) {
+      const fileSessionId = basename4(file, ".jsonl");
+      if (fileSessionId === sessionId) {
+        return file;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function countContextTokens(name) {
+  const sessionId = getSessionId(name);
+  if (!sessionId) {
+    return null;
+  }
+  const sessionFile = findSessionFile(sessionId);
+  if (!sessionFile) {
+    return null;
+  }
+  const sessionUsage = parseClaudeSession(sessionFile);
+  if (!sessionUsage) {
+    return null;
+  }
+  return sessionUsage.usage.inputTokens + sessionUsage.usage.outputTokens + (sessionUsage.usage.cacheReadTokens || 0) + (sessionUsage.usage.cacheWriteTokens || 0);
+}
 function isRunning(name) {
   const tmuxSession = getTmuxSessionName(name);
   try {
@@ -4950,6 +4803,37 @@ function isRunning(name) {
     return false;
   }
 }
+function getSpecialistStatus(name) {
+  const metadata = getSpecialistMetadata(name) || {
+    name,
+    displayName: name,
+    description: "",
+    enabled: false,
+    autoWake: false
+  };
+  const sessionId = getSessionId(name);
+  const running = isRunning(name);
+  const contextTokens = countContextTokens(name);
+  let state;
+  if (running) {
+    state = "active";
+  } else if (sessionId) {
+    state = "sleeping";
+  } else {
+    state = "uninitialized";
+  }
+  return {
+    ...metadata,
+    sessionId: sessionId || void 0,
+    contextTokens: contextTokens || void 0,
+    state,
+    isRunning: running,
+    tmuxSession: getTmuxSessionName(name)
+  };
+}
+function getAllSpecialistStatus() {
+  return getAllSpecialists().map((metadata) => getSpecialistStatus(metadata.name));
+}
 async function initializeSpecialist(name) {
   if (isRunning(name)) {
     return {
@@ -5022,21 +4906,15 @@ async function initializeEnabledSpecialists() {
   }
   return results;
 }
-
-// src/lib/runtimes/index.ts
-init_esm_shims();
-
-// src/lib/runtimes/types.ts
-init_esm_shims();
+function checkSpecialistQueue(specialistName) {
+  return checkHook(specialistName);
+}
 
 // src/lib/runtimes/claude-code.ts
-init_esm_shims();
-init_agents();
-init_tmux();
-import { existsSync as existsSync22, readFileSync as readFileSync18, statSync as statSync3, mkdirSync as mkdirSync16 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync18, statSync as statSync3, mkdirSync as mkdirSync16, writeFileSync as writeFileSync14 } from "fs";
 import { join as join22 } from "path";
-import { homedir as homedir6 } from "os";
-var CLAUDE_PROJECTS_DIR2 = join22(homedir6(), ".claude", "projects");
+import { homedir as homedir7 } from "os";
+var CLAUDE_PROJECTS_DIR2 = join22(homedir7(), ".claude", "projects");
 var ClaudeCodeRuntime = class {
   name = "claude-code";
   /**
@@ -5136,7 +5014,7 @@ var ClaudeCodeRuntime = class {
    * Read active heartbeat file if it exists
    */
   getActiveHeartbeat(agentId) {
-    const heartbeatPath = join22(homedir6(), ".panopticon", "heartbeats", `${agentId}.json`);
+    const heartbeatPath = join22(homedir7(), ".panopticon", "heartbeats", `${agentId}.json`);
     if (!existsSync22(heartbeatPath)) {
       return null;
     }
@@ -5248,8 +5126,7 @@ var ClaudeCodeRuntime = class {
     const mailDir = join22(getAgentDir(agentId), "mail");
     mkdirSync16(mailDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const fs = __require("fs");
-    fs.writeFileSync(
+    writeFileSync14(
       join22(mailDir, `${timestamp}.md`),
       `# Message
 
@@ -5268,8 +5145,7 @@ ${message}
     const state = getAgentState(agentId);
     if (state) {
       state.status = "stopped";
-      const { saveAgentState: saveAgentState2 } = (init_agents(), __toCommonJS(agents_exports));
-      saveAgentState2(state);
+      saveAgentState(state);
     }
   }
   /**
@@ -5356,7 +5232,6 @@ function createClaudeCodeRuntime() {
 }
 
 // src/lib/runtimes/index.ts
-init_agents();
 var RuntimeRegistry = class {
   runtimes = /* @__PURE__ */ new Map();
   /**
@@ -5417,11 +5292,7 @@ function getRuntimeForAgent(agentId) {
   return getGlobalRegistry().getRuntimeForAgent(agentId);
 }
 
-// src/lib/cloister/service.ts
-init_agents();
-
 // src/lib/cloister/triggers.ts
-init_esm_shims();
 import { existsSync as existsSync23 } from "fs";
 import { join as join23 } from "path";
 import { execSync as execSync10 } from "child_process";
@@ -5656,13 +5527,10 @@ function checkAllTriggers(agentId, workspace, issueId, currentModel, health, con
 }
 
 // src/lib/cloister/handoff.ts
-init_esm_shims();
-init_agents();
-import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync17 } from "fs";
+import { writeFileSync as writeFileSync15, mkdirSync as mkdirSync17 } from "fs";
 import { join as join25 } from "path";
 
 // src/lib/cloister/handoff-context.ts
-init_esm_shims();
 import { existsSync as existsSync24, readFileSync as readFileSync19 } from "fs";
 import { join as join24 } from "path";
 import { execSync as execSync11 } from "child_process";
@@ -5846,7 +5714,6 @@ function buildHandoffPrompt(context, additionalInstructions) {
 }
 
 // src/lib/cloister/handoff.ts
-init_tmux();
 async function performHandoff(agentId, options) {
   const state = getAgentState(agentId);
   if (!state) {
@@ -5885,7 +5752,7 @@ async function performKillAndSpawn(state, options) {
     const handoffDir = join25(getAgentDir(state.id), "handoffs");
     mkdirSync17(handoffDir, { recursive: true });
     const handoffFile = join25(handoffDir, `handoff-${Date.now()}.md`);
-    writeFileSync13(handoffFile, prompt);
+    writeFileSync15(handoffFile, prompt);
     const newState = spawnAgent({
       issueId: state.issueId,
       workspace: state.workspace,
@@ -5957,8 +5824,6 @@ function sleep(ms) {
 }
 
 // src/lib/cloister/handoff-logger.ts
-init_esm_shims();
-init_paths();
 import { existsSync as existsSync26, mkdirSync as mkdirSync18, appendFileSync as appendFileSync3, readFileSync as readFileSync20 } from "fs";
 import { join as join26 } from "path";
 var HANDOFF_LOG_FILE = join26(PANOPTICON_HOME, "logs", "handoffs.jsonl");
@@ -6145,7 +6010,7 @@ var CloisterService = class {
           }
         }
       }
-      await this.checkHandoffTriggers(agentHealths);
+      void this.checkHandoffTriggers(agentHealths);
     } catch (error) {
       console.error("Cloister health check failed:", error);
       this.emit({ type: "error", error });
@@ -6436,7 +6301,6 @@ async function statusCommand2(options) {
 }
 
 // src/cli/commands/cloister/start.ts
-init_esm_shims();
 import chalk23 from "chalk";
 async function startCommand() {
   const service = getCloisterService();
@@ -6450,7 +6314,6 @@ async function startCommand() {
 }
 
 // src/cli/commands/cloister/stop.ts
-init_esm_shims();
 import chalk24 from "chalk";
 async function stopCommand(options) {
   const service = getCloisterService();
@@ -6483,16 +6346,12 @@ function registerCloisterCommands(program2) {
   cloister.command("emergency-stop").description("Emergency stop - kill ALL agents immediately").action(() => stopCommand({ emergency: true }));
 }
 
-// src/cli/commands/setup/index.ts
-init_esm_shims();
-
 // src/cli/commands/setup/hooks.ts
-init_esm_shims();
 import chalk25 from "chalk";
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync14, existsSync as existsSync27, mkdirSync as mkdirSync19, copyFileSync as copyFileSync2, chmodSync } from "fs";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync16, existsSync as existsSync27, mkdirSync as mkdirSync19, copyFileSync as copyFileSync2, chmodSync as chmodSync2 } from "fs";
 import { join as join27 } from "path";
 import { execSync as execSync12 } from "child_process";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir8 } from "os";
 function checkJqInstalled() {
   try {
     execSync12("which jq", { stdio: "pipe" });
@@ -6561,7 +6420,7 @@ async function setupHooksCommand() {
   } else {
     console.log(chalk25.green("\u2713 jq is installed"));
   }
-  const panopticonHome = join27(homedir7(), ".panopticon");
+  const panopticonHome = join27(homedir8(), ".panopticon");
   const binDir = join27(panopticonHome, "bin");
   const heartbeatsDir = join27(panopticonHome, "heartbeats");
   if (!existsSync27(binDir)) {
@@ -6576,9 +6435,9 @@ async function setupHooksCommand() {
   const scriptDest = join27(binDir, "heartbeat-hook");
   let sourcePath = scriptSource;
   if (!existsSync27(sourcePath)) {
-    const { fileURLToPath: fileURLToPath2 } = await import("url");
-    const { dirname: dirname5 } = await import("path");
-    const __dirname3 = dirname5(fileURLToPath2(import.meta.url));
+    const { fileURLToPath: fileURLToPath3 } = await import("url");
+    const { dirname: dirname6 } = await import("path");
+    const __dirname3 = dirname6(fileURLToPath3(import.meta.url));
     const installedSource = join27(__dirname3, "..", "..", "..", "scripts", "heartbeat-hook");
     if (existsSync27(installedSource)) {
       sourcePath = installedSource;
@@ -6590,9 +6449,9 @@ async function setupHooksCommand() {
     }
   }
   copyFileSync2(sourcePath, scriptDest);
-  chmodSync(scriptDest, 493);
+  chmodSync2(scriptDest, 493);
   console.log(chalk25.green("\u2713 Installed heartbeat-hook script"));
-  const claudeDir = join27(homedir7(), ".claude");
+  const claudeDir = join27(homedir8(), ".claude");
   const settingsPath = join27(claudeDir, "settings.json");
   let settings = {};
   if (existsSync27(settingsPath)) {
@@ -6630,7 +6489,7 @@ async function setupHooksCommand() {
       }
     ]
   });
-  writeFileSync14(settingsPath, JSON.stringify(settings, null, 2));
+  writeFileSync16(settingsPath, JSON.stringify(settings, null, 2));
   console.log(chalk25.green("\u2713 Updated Claude Code settings.json"));
   console.log(chalk25.green.bold("\n\u2713 Setup complete!\n"));
   console.log(chalk25.dim("Heartbeat hooks are now active. When you run agents via"));
@@ -6644,24 +6503,341 @@ function registerSetupCommands(program2) {
   setup.command("hooks").description("Configure Claude Code hooks for heartbeat tracking").action(setupHooksCommand);
 }
 
-// src/cli/commands/project.ts
-init_esm_shims();
+// src/cli/commands/specialists/list.ts
 import chalk26 from "chalk";
+function listCommand3(options) {
+  const specialists = getAllSpecialistStatus();
+  if (options.json) {
+    console.log(JSON.stringify(specialists, null, 2));
+    return;
+  }
+  console.log(chalk26.bold("\nSpecialist Agents:\n"));
+  if (specialists.length === 0) {
+    console.log(chalk26.dim("No specialists configured."));
+    console.log("");
+    return;
+  }
+  for (const specialist of specialists) {
+    displaySpecialist(specialist);
+  }
+  console.log("");
+}
+function displaySpecialist(specialist) {
+  const statusIcon = getStatusIcon(specialist);
+  const statusColor = getStatusColor(specialist);
+  const enabledBadge = specialist.enabled ? chalk26.green("enabled") : chalk26.dim("disabled");
+  console.log(`${statusIcon} ${chalk26.bold(specialist.displayName)} (${enabledBadge})`);
+  console.log(`  ${chalk26.dim(specialist.description)}`);
+  console.log(`  Status: ${statusColor(specialist.state)}`);
+  if (specialist.isRunning) {
+    console.log(`  Running: ${chalk26.cyan(specialist.tmuxSession)}`);
+  }
+  if (specialist.sessionId) {
+    const shortId = specialist.sessionId.substring(0, 8);
+    console.log(`  Session: ${chalk26.dim(shortId + "...")}`);
+  }
+  if (specialist.contextTokens) {
+    const tokensFormatted = specialist.contextTokens.toLocaleString();
+    console.log(`  Context: ${chalk26.dim(tokensFormatted + " tokens")}`);
+  }
+  if (specialist.lastWake) {
+    const lastWake = new Date(specialist.lastWake);
+    const relative = getRelativeTime(lastWake);
+    console.log(`  Last wake: ${chalk26.dim(relative)}`);
+  }
+  console.log("");
+}
+function getStatusIcon(specialist) {
+  if (!specialist.enabled) return chalk26.dim("\u25CB");
+  if (specialist.isRunning) return chalk26.green("\u25CF");
+  if (specialist.state === "sleeping") return chalk26.yellow("\u25CF");
+  return chalk26.dim("\u25CB");
+}
+function getStatusColor(specialist) {
+  if (specialist.isRunning) return chalk26.green;
+  if (specialist.state === "sleeping") return chalk26.yellow;
+  return chalk26.dim;
+}
+function getRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - date.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return "just now";
+}
+
+// src/cli/commands/specialists/wake.ts
+import chalk27 from "chalk";
+import { execSync as execSync13 } from "child_process";
+function wakeCommand(name, options) {
+  const validNames = ["merge-agent", "review-agent", "test-agent"];
+  if (!validNames.includes(name)) {
+    console.log(chalk27.red(`
+Error: Unknown specialist '${name}'`));
+    console.log(`Valid specialists: ${validNames.join(", ")}
+`);
+    process.exit(1);
+  }
+  const specialistName = name;
+  const status = getSpecialistStatus(specialistName);
+  console.log(chalk27.bold(`
+Waking ${status.displayName}...
+`));
+  if (status.isRunning) {
+    console.log(chalk27.yellow(`Specialist is already running in tmux session: ${status.tmuxSession}`));
+    if (options.task) {
+      console.log(chalk27.dim("\nSending task message..."));
+      try {
+        const escapedTask = options.task.replace(/'/g, "'\\''");
+        execSync13(`tmux send-keys -t "${status.tmuxSession}" '${escapedTask}' C-m`, { encoding: "utf-8" });
+        console.log(chalk27.green("\u2713 Task message sent"));
+      } catch (error) {
+        console.log(chalk27.red(`Failed to send message: ${error.message}`));
+      }
+    } else {
+      console.log(chalk27.dim("Use --task to send a message to the running specialist"));
+    }
+    console.log("");
+    return;
+  }
+  if (!status.enabled) {
+    console.log(chalk27.yellow(`Warning: Specialist '${specialistName}' is disabled in registry`));
+    console.log(chalk27.dim("You can still wake it manually, but it won't auto-wake\n"));
+  }
+  const sessionId = getSessionId(specialistName);
+  const tmuxSession = getTmuxSessionName(specialistName);
+  const cwd = process.env.HOME || "/home/eltmon";
+  try {
+    let claudeCmd = "claude --dangerously-skip-permissions";
+    if (sessionId) {
+      claudeCmd += ` --resume ${sessionId}`;
+      console.log(chalk27.dim(`Resuming session: ${sessionId.substring(0, 8)}...`));
+    } else {
+      console.log(chalk27.dim("Starting fresh session (no previous session found)"));
+    }
+    console.log(chalk27.dim(`Creating tmux session: ${tmuxSession}`));
+    execSync13(
+      `tmux new-session -d -s "${tmuxSession}" -c "${cwd}" "${claudeCmd}"`,
+      { encoding: "utf-8" }
+    );
+    execSync13("sleep 2", { encoding: "utf-8" });
+    if (options.task) {
+      console.log(chalk27.dim("Sending task message..."));
+      const escapedTask = options.task.replace(/'/g, "'\\''");
+      execSync13(`tmux send-keys -t "${tmuxSession}" '${escapedTask}' C-m`, { encoding: "utf-8" });
+    }
+    recordWake(specialistName);
+    console.log(chalk27.green(`\u2713 Specialist ${specialistName} woken up successfully`));
+    console.log(chalk27.dim(`  Tmux session: ${tmuxSession}`));
+    console.log(chalk27.dim(`  Attach with: tmux attach -t ${tmuxSession}`));
+    console.log("");
+  } catch (error) {
+    console.log(chalk27.red(`
+Failed to wake specialist: ${error.message}
+`));
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/specialists/queue.ts
+import chalk28 from "chalk";
+function queueCommand(name, options) {
+  const validNames = ["merge-agent", "review-agent", "test-agent"];
+  if (!validNames.includes(name)) {
+    console.log(chalk28.red(`
+Error: Unknown specialist '${name}'`));
+    console.log(`Valid specialists: ${validNames.join(", ")}
+`);
+    process.exit(1);
+  }
+  const specialistName = name;
+  const metadata = getSpecialistMetadata(specialistName);
+  if (!metadata) {
+    console.log(chalk28.red(`
+Error: Specialist '${specialistName}' not found in registry
+`));
+    process.exit(1);
+  }
+  const queueStatus = checkSpecialistQueue(specialistName);
+  if (options.json) {
+    console.log(JSON.stringify(queueStatus, null, 2));
+    return;
+  }
+  console.log(chalk28.bold(`
+${metadata.displayName} Queue:
+`));
+  if (!queueStatus.hasWork) {
+    console.log(chalk28.dim("Queue is empty - no pending work"));
+    console.log("");
+    return;
+  }
+  console.log(`Total items: ${chalk28.bold(queueStatus.items.length.toString())}`);
+  if (queueStatus.urgentCount > 0) {
+    console.log(`Urgent items: ${chalk28.red.bold(queueStatus.urgentCount.toString())}`);
+  }
+  console.log("");
+  for (let i = 0; i < queueStatus.items.length; i++) {
+    const item = queueStatus.items[i];
+    const position = i + 1;
+    const priorityColor = getPriorityColor(item.priority);
+    console.log(`${position}. ${priorityColor(item.priority.toUpperCase())}`);
+    console.log(`   ID: ${chalk28.dim(item.id)}`);
+    console.log(`   Source: ${chalk28.dim(item.source)}`);
+    if (item.payload) {
+      const payload = item.payload;
+      if (payload.issueId) {
+        console.log(`   Issue: ${chalk28.cyan(payload.issueId)}`);
+      }
+      if (payload.prUrl) {
+        console.log(`   PR: ${chalk28.dim(payload.prUrl)}`);
+      }
+      if (payload.workspace) {
+        console.log(`   Workspace: ${chalk28.dim(payload.workspace)}`);
+      }
+      if (payload.branch) {
+        console.log(`   Branch: ${chalk28.dim(payload.branch)}`);
+      }
+      if (payload.filesChanged && Array.isArray(payload.filesChanged)) {
+        const fileCount = payload.filesChanged.length;
+        console.log(`   Files: ${chalk28.dim(fileCount + " changed")}`);
+      }
+    }
+    const createdAt = new Date(item.createdAt);
+    const age = getAge(createdAt);
+    console.log(`   Age: ${chalk28.dim(age)}`);
+    console.log("");
+  }
+}
+function getPriorityColor(priority) {
+  switch (priority.toLowerCase()) {
+    case "urgent":
+      return chalk28.red.bold;
+    case "high":
+      return chalk28.yellow;
+    case "normal":
+      return chalk28.white;
+    case "low":
+      return chalk28.dim;
+    default:
+      return chalk28.white;
+  }
+}
+function getAge(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - date.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return "just now";
+}
+
+// src/cli/commands/specialists/reset.ts
+import chalk29 from "chalk";
+import { execSync as execSync14 } from "child_process";
+import * as readline from "readline";
+async function resetCommand(name, options) {
+  const validNames = ["merge-agent", "review-agent", "test-agent"];
+  if (!validNames.includes(name)) {
+    console.log(chalk29.red(`
+Error: Unknown specialist '${name}'`));
+    console.log(`Valid specialists: ${validNames.join(", ")}
+`);
+    process.exit(1);
+  }
+  const specialistName = name;
+  const status = getSpecialistStatus(specialistName);
+  console.log(chalk29.bold(`
+Resetting ${status.displayName}...
+`));
+  console.log(chalk29.dim("Current state:"));
+  console.log(`  Status: ${status.state}`);
+  if (status.isRunning) {
+    console.log(`  Running: ${chalk29.yellow("yes")} (tmux: ${status.tmuxSession})`);
+  }
+  if (status.sessionId) {
+    console.log(`  Session: ${status.sessionId.substring(0, 8)}...`);
+  }
+  if (status.contextTokens) {
+    console.log(`  Context: ${status.contextTokens.toLocaleString()} tokens`);
+  }
+  console.log("");
+  if (!options.force) {
+    const confirmed = await confirm(
+      "This will clear the session and all context. Continue?"
+    );
+    if (!confirmed) {
+      console.log(chalk29.dim("Reset cancelled\n"));
+      return;
+    }
+  }
+  if (status.isRunning) {
+    console.log(chalk29.dim("Stopping tmux session..."));
+    try {
+      execSync14(`tmux kill-session -t "${status.tmuxSession}"`, { encoding: "utf-8", stdio: "ignore" });
+      console.log(chalk29.green("\u2713 Tmux session stopped"));
+    } catch (error) {
+      console.log(chalk29.yellow("\u26A0 Failed to stop tmux session (may not be running)"));
+    }
+  }
+  console.log(chalk29.dim("Clearing session file..."));
+  const cleared = clearSessionId(specialistName);
+  if (cleared) {
+    console.log(chalk29.green("\u2713 Session file cleared"));
+  } else {
+    console.log(chalk29.dim("No session file to clear"));
+  }
+  console.log(chalk29.green(`
+\u2713 Specialist ${specialistName} has been reset`));
+  console.log(chalk29.dim("Next wake will start a fresh session\n"));
+}
+function confirm(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(chalk29.yellow(`${question} [y/N] `), (answer) => {
+      rl.close();
+      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+// src/cli/commands/specialists/index.ts
+function registerSpecialistsCommands(program2) {
+  const specialists = program2.command("specialists").description("Manage specialist agents (review-agent, test-agent, merge-agent)");
+  specialists.command("list").description("Show all specialists with their status").option("--json", "Output in JSON format").action(listCommand3);
+  specialists.command("wake <name>").description("Wake up a specialist agent (for testing/debugging)").option("--task <description>", "Optional task description to wake with").action(wakeCommand);
+  specialists.command("queue <name>").description("Show pending work in a specialist's queue").option("--json", "Output in JSON format").action(queueCommand);
+  specialists.command("reset <name>").description("Reset a specialist (clear session, start fresh)").option("--force", "Skip confirmation prompt").action(resetCommand);
+}
+
+// src/cli/commands/project.ts
+import chalk30 from "chalk";
 import { existsSync as existsSync28, readFileSync as readFileSync22 } from "fs";
 import { join as join28, resolve } from "path";
 async function projectAddCommand(projectPath, options = {}) {
   const fullPath = resolve(projectPath);
   if (!existsSync28(fullPath)) {
-    console.log(chalk26.red(`Path does not exist: ${fullPath}`));
+    console.log(chalk30.red(`Path does not exist: ${fullPath}`));
     return;
   }
   const name = options.name || fullPath.split("/").pop() || "unknown";
   const key = name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
   const existing = getProject(key);
   if (existing) {
-    console.log(chalk26.yellow(`Project already registered with key: ${key}`));
-    console.log(chalk26.dim(`Existing path: ${existing.path}`));
-    console.log(chalk26.dim(`To update, first run: pan project remove ${key}`));
+    console.log(chalk30.yellow(`Project already registered with key: ${key}`));
+    console.log(chalk30.dim(`Existing path: ${existing.path}`));
+    console.log(chalk30.dim(`To update, first run: pan project remove ${key}`));
     return;
   }
   let linearTeam = options.linearTeam;
@@ -6681,21 +6857,21 @@ async function projectAddCommand(projectPath, options = {}) {
     projectConfig.linear_team = linearTeam.toUpperCase();
   }
   registerProject(key, projectConfig);
-  console.log(chalk26.green(`\u2713 Added project: ${name}`));
-  console.log(chalk26.dim(`  Key: ${key}`));
-  console.log(chalk26.dim(`  Path: ${fullPath}`));
+  console.log(chalk30.green(`\u2713 Added project: ${name}`));
+  console.log(chalk30.dim(`  Key: ${key}`));
+  console.log(chalk30.dim(`  Path: ${fullPath}`));
   if (linearTeam) {
-    console.log(chalk26.dim(`  Linear team: ${linearTeam}`));
+    console.log(chalk30.dim(`  Linear team: ${linearTeam}`));
   }
   console.log("");
-  console.log(chalk26.dim(`Edit ${PROJECTS_CONFIG_FILE} to add issue routing rules.`));
+  console.log(chalk30.dim(`Edit ${PROJECTS_CONFIG_FILE} to add issue routing rules.`));
 }
 async function projectListCommand(options = {}) {
   const projects = listProjects();
   if (projects.length === 0) {
-    console.log(chalk26.dim("No projects registered."));
-    console.log(chalk26.dim("Add one with: pan project add <path> --linear-team <TEAM>"));
-    console.log(chalk26.dim(`Or edit: ${PROJECTS_CONFIG_FILE}`));
+    console.log(chalk30.dim("No projects registered."));
+    console.log(chalk30.dim("Add one with: pan project add <path> --linear-team <TEAM>"));
+    console.log(chalk30.dim(`Or edit: ${PROJECTS_CONFIG_FILE}`));
     return;
   }
   if (options.json) {
@@ -6706,51 +6882,51 @@ async function projectListCommand(options = {}) {
     console.log(JSON.stringify(output, null, 2));
     return;
   }
-  console.log(chalk26.bold("\nRegistered Projects:\n"));
+  console.log(chalk30.bold("\nRegistered Projects:\n"));
   for (const { key, config } of projects) {
     const exists = existsSync28(config.path);
-    const statusIcon = exists ? chalk26.green("\u2713") : chalk26.red("\u2717");
-    console.log(`${statusIcon} ${chalk26.bold(config.name)} ${chalk26.dim(`(${key})`)}`);
-    console.log(`  ${chalk26.dim(config.path)}`);
+    const statusIcon = exists ? chalk30.green("\u2713") : chalk30.red("\u2717");
+    console.log(`${statusIcon} ${chalk30.bold(config.name)} ${chalk30.dim(`(${key})`)}`);
+    console.log(`  ${chalk30.dim(config.path)}`);
     if (config.linear_team) {
-      console.log(`  ${chalk26.cyan(`Linear: ${config.linear_team}`)}`);
+      console.log(`  ${chalk30.cyan(`Linear: ${config.linear_team}`)}`);
     }
     if (config.issue_routing && config.issue_routing.length > 0) {
-      console.log(`  ${chalk26.dim(`Routes: ${config.issue_routing.length} rules`)}`);
+      console.log(`  ${chalk30.dim(`Routes: ${config.issue_routing.length} rules`)}`);
     }
     console.log("");
   }
-  console.log(chalk26.dim(`Config: ${PROJECTS_CONFIG_FILE}`));
+  console.log(chalk30.dim(`Config: ${PROJECTS_CONFIG_FILE}`));
 }
 async function projectRemoveCommand(nameOrPath) {
   const projects = listProjects();
   if (unregisterProject(nameOrPath)) {
-    console.log(chalk26.green(`\u2713 Removed project: ${nameOrPath}`));
+    console.log(chalk30.green(`\u2713 Removed project: ${nameOrPath}`));
     return;
   }
   for (const { key, config } of projects) {
     if (config.name === nameOrPath || config.path === resolve(nameOrPath)) {
       unregisterProject(key);
-      console.log(chalk26.green(`\u2713 Removed project: ${config.name}`));
+      console.log(chalk30.green(`\u2713 Removed project: ${config.name}`));
       return;
     }
   }
-  console.log(chalk26.red(`Project not found: ${nameOrPath}`));
-  console.log(chalk26.dim(`Use 'pan project list' to see registered projects.`));
+  console.log(chalk30.red(`Project not found: ${nameOrPath}`));
+  console.log(chalk30.dim(`Use 'pan project list' to see registered projects.`));
 }
 async function projectInitCommand() {
   if (existsSync28(PROJECTS_CONFIG_FILE)) {
-    console.log(chalk26.yellow(`Config already exists: ${PROJECTS_CONFIG_FILE}`));
+    console.log(chalk30.yellow(`Config already exists: ${PROJECTS_CONFIG_FILE}`));
     return;
   }
   initializeProjectsConfig();
-  console.log(chalk26.green("\u2713 Projects config initialized"));
+  console.log(chalk30.green("\u2713 Projects config initialized"));
   console.log("");
-  console.log(chalk26.dim(`Edit ${PROJECTS_CONFIG_FILE} to add your projects.`));
+  console.log(chalk30.dim(`Edit ${PROJECTS_CONFIG_FILE} to add your projects.`));
   console.log("");
-  console.log(chalk26.bold("Quick start:"));
+  console.log(chalk30.bold("Quick start:"));
   console.log(
-    chalk26.dim(
+    chalk30.dim(
       '  pan project add /path/to/project --name "My Project" --linear-team MIN'
     )
   );
@@ -6769,13 +6945,13 @@ async function projectShowCommand(keyOrName) {
     }
   }
   if (!found) {
-    console.error(chalk26.red(`Project not found: ${keyOrName}`));
-    console.log(chalk26.dim(`Use 'pan project list' to see registered projects.`));
+    console.error(chalk30.red(`Project not found: ${keyOrName}`));
+    console.log(chalk30.dim(`Use 'pan project list' to see registered projects.`));
     process.exit(1);
   }
   const pathExists = existsSync28(found.path);
-  const pathStatus = pathExists ? chalk26.green("\u2713") : chalk26.red("\u2717");
-  console.log(chalk26.bold(`
+  const pathStatus = pathExists ? chalk30.green("\u2713") : chalk30.red("\u2717");
+  console.log(chalk30.bold(`
 Project: ${foundKey}
 `));
   console.log(`  Name:   ${found.name}`);
@@ -6784,7 +6960,7 @@ Project: ${foundKey}
     console.log(`  Team:   ${found.linear_team}`);
   }
   if (found.issue_routing && found.issue_routing.length > 0) {
-    console.log("\n  " + chalk26.bold("Routing Rules:"));
+    console.log("\n  " + chalk30.bold("Routing Rules:"));
     for (const rule of found.issue_routing) {
       if (rule.labels) {
         console.log(`    Labels: ${rule.labels.join(", ")}`);
@@ -6799,16 +6975,14 @@ Project: ${foundKey}
 }
 
 // src/cli/commands/doctor.ts
-init_esm_shims();
-init_paths();
-import chalk27 from "chalk";
-import { existsSync as existsSync29, readdirSync as readdirSync15 } from "fs";
-import { execSync as execSync13 } from "child_process";
-import { homedir as homedir8 } from "os";
+import chalk31 from "chalk";
+import { existsSync as existsSync29, readdirSync as readdirSync15, readFileSync as readFileSync23 } from "fs";
+import { execSync as execSync15 } from "child_process";
+import { homedir as homedir9 } from "os";
 import { join as join29 } from "path";
 function checkCommand2(cmd) {
   try {
-    execSync13(`which ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
+    execSync15(`which ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -6826,8 +7000,8 @@ function countItems(path) {
   }
 }
 async function doctorCommand() {
-  console.log(chalk27.bold("\nPanopticon Doctor\n"));
-  console.log(chalk27.dim("Checking system health...\n"));
+  console.log(chalk31.bold("\nPanopticon Doctor\n"));
+  console.log(chalk31.dim("Checking system health...\n"));
   const checks = [];
   const requiredCommands = [
     { cmd: "git", name: "Git", fix: "Install git" },
@@ -6891,7 +7065,7 @@ async function doctorCommand() {
       fix: "Install Claude Code first"
     });
   }
-  const envFile = join29(homedir8(), ".panopticon.env");
+  const envFile = join29(homedir9(), ".panopticon.env");
   if (existsSync29(envFile)) {
     checks.push({ name: "Config File", status: "ok", message: "~/.panopticon.env exists" });
   } else {
@@ -6905,7 +7079,7 @@ async function doctorCommand() {
   if (process.env.LINEAR_API_KEY) {
     checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in environment" });
   } else if (existsSync29(envFile)) {
-    const content = __require("fs").readFileSync(envFile, "utf-8");
+    const content = readFileSync23(envFile, "utf-8");
     if (content.includes("LINEAR_API_KEY")) {
       checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in config file" });
     } else {
@@ -6925,7 +7099,7 @@ async function doctorCommand() {
     });
   }
   try {
-    const sessions = execSync13("tmux list-sessions 2>/dev/null || true", { encoding: "utf-8" });
+    const sessions = execSync15("tmux list-sessions 2>/dev/null || true", { encoding: "utf-8" });
     const agentSessions = sessions.split("\n").filter((s) => s.includes("agent-")).length;
     checks.push({
       name: "Running Agents",
@@ -6940,41 +7114,46 @@ async function doctorCommand() {
     });
   }
   const icons = {
-    ok: chalk27.green("\u2713"),
-    warn: chalk27.yellow("\u26A0"),
-    error: chalk27.red("\u2717")
+    ok: chalk31.green("\u2713"),
+    warn: chalk31.yellow("\u26A0"),
+    error: chalk31.red("\u2717")
   };
   let hasErrors = false;
   let hasWarnings = false;
   for (const check of checks) {
     const icon = icons[check.status];
-    const message = check.status === "error" ? chalk27.red(check.message) : check.status === "warn" ? chalk27.yellow(check.message) : chalk27.dim(check.message);
+    const message = check.status === "error" ? chalk31.red(check.message) : check.status === "warn" ? chalk31.yellow(check.message) : chalk31.dim(check.message);
     console.log(`${icon} ${check.name}: ${message}`);
     if (check.fix && check.status !== "ok") {
-      console.log(chalk27.dim(`  Fix: ${check.fix}`));
+      console.log(chalk31.dim(`  Fix: ${check.fix}`));
     }
     if (check.status === "error") hasErrors = true;
     if (check.status === "warn") hasWarnings = true;
   }
   console.log("");
   if (hasErrors) {
-    console.log(chalk27.red("Some required components are missing."));
-    console.log(chalk27.dim("Fix the errors above before using Panopticon."));
+    console.log(chalk31.red("Some required components are missing."));
+    console.log(chalk31.dim("Fix the errors above before using Panopticon."));
   } else if (hasWarnings) {
-    console.log(chalk27.yellow("System is functional with some optional features missing."));
+    console.log(chalk31.yellow("System is functional with some optional features missing."));
   } else {
-    console.log(chalk27.green("All systems operational!"));
+    console.log(chalk31.green("All systems operational!"));
   }
   console.log("");
 }
 
 // src/cli/commands/update.ts
-init_esm_shims();
-import { execSync as execSync14 } from "child_process";
-import chalk28 from "chalk";
+import { execSync as execSync16 } from "child_process";
+import chalk32 from "chalk";
+import { readFileSync as readFileSync24 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname5, join as join30 } from "path";
 function getCurrentVersion() {
   try {
-    const pkg = require_package();
+    const __filename3 = fileURLToPath2(import.meta.url);
+    const __dirname3 = dirname5(__filename3);
+    const pkgPath = join30(__dirname3, "..", "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync24(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "unknown";
@@ -6982,7 +7161,7 @@ function getCurrentVersion() {
 }
 async function getLatestVersion() {
   try {
-    const result = execSync14("npm view panopticon-cli version", {
+    const result = execSync16("npm view panopticon-cli version", {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -7007,49 +7186,49 @@ function isNewer(latest, current) {
   return l.patch > c.patch;
 }
 async function updateCommand(options) {
-  console.log(chalk28.bold("Panopticon Update\n"));
+  console.log(chalk32.bold("Panopticon Update\n"));
   const currentVersion = getCurrentVersion();
-  console.log(`Current version: ${chalk28.cyan(currentVersion)}`);
+  console.log(`Current version: ${chalk32.cyan(currentVersion)}`);
   let latestVersion;
   try {
-    console.log(chalk28.dim("Checking npm for latest version..."));
+    console.log(chalk32.dim("Checking npm for latest version..."));
     latestVersion = await getLatestVersion();
-    console.log(`Latest version:  ${chalk28.cyan(latestVersion)}`);
+    console.log(`Latest version:  ${chalk32.cyan(latestVersion)}`);
   } catch (error) {
-    console.error(chalk28.red("Failed to check for updates"));
-    console.error(chalk28.dim("Make sure you have internet connectivity"));
+    console.error(chalk32.red("Failed to check for updates"));
+    console.error(chalk32.dim("Make sure you have internet connectivity"));
     process.exit(1);
   }
   const needsUpdate = isNewer(latestVersion, currentVersion);
   if (!needsUpdate) {
-    console.log(chalk28.green("\n\u2713 You are on the latest version"));
+    console.log(chalk32.green("\n\u2713 You are on the latest version"));
     return;
   }
   console.log(
-    chalk28.yellow(`
+    chalk32.yellow(`
 \u2191 Update available: ${currentVersion} \u2192 ${latestVersion}`)
   );
   if (options.check) {
-    console.log(chalk28.dim("\nRun `pan update` to install"));
+    console.log(chalk32.dim("\nRun `pan update` to install"));
     return;
   }
-  console.log(chalk28.dim("\nUpdating Panopticon..."));
+  console.log(chalk32.dim("\nUpdating Panopticon..."));
   try {
-    execSync14("npm install -g panopticon-cli@latest", {
+    execSync16("npm install -g panopticon-cli@latest", {
       stdio: "inherit"
     });
-    console.log(chalk28.green(`
+    console.log(chalk32.green(`
 \u2713 Updated to ${latestVersion}`));
     const config = loadConfig();
     if (config.sync.auto_sync) {
-      console.log(chalk28.dim("\nRunning auto-sync..."));
+      console.log(chalk32.dim("\nRunning auto-sync..."));
       await syncCommand({});
     }
-    console.log(chalk28.dim("\nRestart any running agents to use the new version."));
+    console.log(chalk32.dim("\nRestart any running agents to use the new version."));
   } catch (error) {
-    console.error(chalk28.red("\nUpdate failed"));
+    console.error(chalk32.red("\nUpdate failed"));
     console.error(
-      chalk28.dim("Try running with sudo: sudo npm install -g panopticon-cli@latest")
+      chalk32.dim("Try running with sudo: sudo npm install -g panopticon-cli@latest")
     );
     process.exit(1);
   }
@@ -7068,120 +7247,140 @@ program.command("skills").description("List and manage skills").option("--json",
 registerWorkCommands(program);
 registerWorkspaceCommands(program);
 registerCloisterCommands(program);
+registerSpecialistsCommands(program);
 registerSetupCommands(program);
 registerInstallCommand(program);
 program.command("status").description("Show running agents (shorthand for work status)").option("--json", "Output as JSON").action(statusCommand);
 program.command("up").description("Start dashboard (and Traefik if enabled)").option("--detach", "Run in background").option("--skip-traefik", "Skip Traefik startup").action(async (options) => {
-  const { spawn, execSync: execSync15 } = await import("child_process");
-  const { join: join30, dirname: dirname5 } = await import("path");
-  const { fileURLToPath: fileURLToPath2 } = await import("url");
-  const { readFileSync: readFileSync23, existsSync: existsSync30 } = await import("fs");
+  const { spawn, execSync: execSync17 } = await import("child_process");
+  const { join: join31, dirname: dirname6 } = await import("path");
+  const { fileURLToPath: fileURLToPath3 } = await import("url");
+  const { readFileSync: readFileSync25, existsSync: existsSync30 } = await import("fs");
   const { parse: parse2 } = await import("@iarna/toml");
-  const __dirname3 = dirname5(fileURLToPath2(import.meta.url));
-  const dashboardDir = join30(__dirname3, "..", "dashboard");
-  const configFile = join30(process.env.HOME || "", ".panopticon", "config.toml");
+  const __dirname3 = dirname6(fileURLToPath3(import.meta.url));
+  const dashboardDir = join31(__dirname3, "..", "dashboard");
+  const configFile = join31(process.env.HOME || "", ".panopticon", "config.toml");
   let traefikEnabled = false;
   let traefikDomain = "pan.localhost";
   if (existsSync30(configFile)) {
     try {
-      const configContent = readFileSync23(configFile, "utf-8");
+      const configContent = readFileSync25(configFile, "utf-8");
       const config = parse2(configContent);
       traefikEnabled = config.traefik?.enabled === true;
       traefikDomain = config.traefik?.domain || "pan.localhost";
     } catch (error) {
-      console.log(chalk29.yellow("Warning: Could not read config.toml"));
+      console.log(chalk33.yellow("Warning: Could not read config.toml"));
     }
   }
-  console.log(chalk29.bold("Starting Panopticon...\n"));
+  console.log(chalk33.bold("Starting Panopticon...\n"));
   if (traefikEnabled && !options.skipTraefik) {
-    const traefikDir = join30(process.env.HOME || "", ".panopticon", "traefik");
+    const traefikDir = join31(process.env.HOME || "", ".panopticon", "traefik");
     if (existsSync30(traefikDir)) {
       try {
-        console.log(chalk29.dim("Starting Traefik..."));
-        execSync15("docker-compose up -d", {
+        console.log(chalk33.dim("Starting Traefik..."));
+        execSync17("docker-compose up -d", {
           cwd: traefikDir,
           stdio: "pipe"
         });
-        console.log(chalk29.green("\u2713 Traefik started"));
-        console.log(chalk29.dim(`  Dashboard: https://traefik.${traefikDomain}:8080
+        console.log(chalk33.green("\u2713 Traefik started"));
+        console.log(chalk33.dim(`  Dashboard: https://traefik.${traefikDomain}:8080
 `));
       } catch (error) {
-        console.log(chalk29.yellow("\u26A0 Failed to start Traefik (continuing anyway)"));
-        console.log(chalk29.dim("  Run with --skip-traefik to suppress this message\n"));
+        console.log(chalk33.yellow("\u26A0 Failed to start Traefik (continuing anyway)"));
+        console.log(chalk33.dim("  Run with --skip-traefik to suppress this message\n"));
       }
     }
   }
-  console.log(chalk29.dim("Starting dashboard..."));
+  try {
+    execSync17("npm --version", { stdio: "pipe" });
+  } catch {
+    console.error(chalk33.red("Error: npm not found in PATH"));
+    console.error(chalk33.dim("Make sure Node.js and npm are installed and in your PATH"));
+    process.exit(1);
+  }
+  console.log(chalk33.dim("Starting dashboard..."));
   if (options.detach) {
     const child = spawn("npm", ["run", "dev"], {
       cwd: dashboardDir,
       detached: true,
-      stdio: "ignore"
+      stdio: "ignore",
+      shell: true
+    });
+    let hasError = false;
+    child.on("error", (err) => {
+      hasError = true;
+      console.error(chalk33.red("Failed to start dashboard in background:"), err.message);
+      process.exit(1);
     });
-    child.unref();
-    console.log(chalk29.green("\u2713 Dashboard started in background"));
+    setTimeout(() => {
+      if (!hasError) {
+        child.unref();
+      }
+    }, 100);
+    console.log(chalk33.green("\u2713 Dashboard started in background"));
     if (traefikEnabled) {
-      console.log(`  Frontend: ${chalk29.cyan(`https://${traefikDomain}`)}`);
-      console.log(`  API:      ${chalk29.cyan(`https://${traefikDomain}/api`)}`);
+      console.log(`  Frontend: ${chalk33.cyan(`https://${traefikDomain}`)}`);
+      console.log(`  API:      ${chalk33.cyan(`https://${traefikDomain}/api`)}`);
     } else {
-      console.log(`  Frontend: ${chalk29.cyan("http://localhost:3001")}`);
-      console.log(`  API:      ${chalk29.cyan("http://localhost:3002")}`);
+      console.log(`  Frontend: ${chalk33.cyan("http://localhost:3001")}`);
+      console.log(`  API:      ${chalk33.cyan("http://localhost:3002")}`);
     }
   } else {
     if (traefikEnabled) {
-      console.log(`  Frontend: ${chalk29.cyan(`https://${traefikDomain}`)}`);
-      console.log(`  API:      ${chalk29.cyan(`https://${traefikDomain}/api`)}`);
+      console.log(`  Frontend: ${chalk33.cyan(`https://${traefikDomain}`)}`);
+      console.log(`  API:      ${chalk33.cyan(`https://${traefikDomain}/api`)}`);
     } else {
-      console.log(`  Frontend: ${chalk29.cyan("http://localhost:3001")}`);
-      console.log(`  API:      ${chalk29.cyan("http://localhost:3002")}`);
+      console.log(`  Frontend: ${chalk33.cyan("http://localhost:3001")}`);
+      console.log(`  API:      ${chalk33.cyan("http://localhost:3002")}`);
     }
-    console.log(chalk29.dim("\nPress Ctrl+C to stop\n"));
+    console.log(chalk33.dim("\nPress Ctrl+C to stop\n"));
     const child = spawn("npm", ["run", "dev"], {
       cwd: dashboardDir,
-      stdio: "inherit"
+      stdio: "inherit",
+      shell: true
     });
     child.on("error", (err) => {
-      console.error(chalk29.red("Failed to start dashboard:"), err.message);
+      console.error(chalk33.red("Failed to start dashboard:"), err.message);
       process.exit(1);
     });
   }
 });
 program.command("down").description("Stop dashboard (and Traefik if enabled)").option("--skip-traefik", "Skip Traefik shutdown").action(async (options) => {
-  const { execSync: execSync15 } = await import("child_process");
-  const { join: join30 } = await import("path");
-  const { readFileSync: readFileSync23, existsSync: existsSync30 } = await import("fs");
+  const { execSync: execSync17 } = await import("child_process");
+  const { join: join31 } = await import("path");
+  const { readFileSync: readFileSync25, existsSync: existsSync30 } = await import("fs");
   const { parse: parse2 } = await import("@iarna/toml");
-  console.log(chalk29.bold("Stopping Panopticon...\n"));
-  console.log(chalk29.dim("Stopping dashboard..."));
+  console.log(chalk33.bold("Stopping Panopticon...\n"));
+  console.log(chalk33.dim("Stopping dashboard..."));
   try {
-    execSync15("lsof -ti:3001 | xargs kill -9 2>/dev/null || true", { stdio: "pipe" });
-    execSync15("lsof -ti:3002 | xargs kill -9 2>/dev/null || true", { stdio: "pipe" });
-    console.log(chalk29.green("\u2713 Dashboard stopped"));
+    execSync17("lsof -ti:3001 | xargs kill -9 2>/dev/null || true", { stdio: "pipe" });
+    execSync17("lsof -ti:3002 | xargs kill -9 2>/dev/null || true", { stdio: "pipe" });
+    console.log(chalk33.green("\u2713 Dashboard stopped"));
   } catch {
-    console.log(chalk29.dim("  No dashboard processes found"));
+    console.log(chalk33.dim("  No dashboard processes found"));
   }
-  const configFile = join30(process.env.HOME || "", ".panopticon", "config.toml");
+  const configFile = join31(process.env.HOME || "", ".panopticon", "config.toml");
   let traefikEnabled = false;
   if (existsSync30(configFile)) {
     try {
-      const configContent = readFileSync23(configFile, "utf-8");
+      const configContent = readFileSync25(configFile, "utf-8");
       const config = parse2(configContent);
       traefikEnabled = config.traefik?.enabled === true;
     } catch (error) {
     }
   }
   if (traefikEnabled && !options.skipTraefik) {
-    const traefikDir = join30(process.env.HOME || "", ".panopticon", "traefik");
+    const traefikDir = join31(process.env.HOME || "", ".panopticon", "traefik");
     if (existsSync30(traefikDir)) {
-      console.log(chalk29.dim("Stopping Traefik..."));
+      console.log(chalk33.dim("Stopping Traefik..."));
       try {
-        execSync15("docker-compose down", {
+        execSync17("docker-compose down", {
           cwd: traefikDir,
           stdio: "pipe"
         });
-        console.log(chalk29.green("\u2713 Traefik stopped"));
+        console.log(chalk33.green("\u2713 Traefik stopped"));
       } catch (error) {
-        console.log(chalk29.yellow("\u26A0 Failed to stop Traefik"));
+        console.log(chalk33.yellow("\u26A0 Failed to stop Traefik"));
       }
     }
   }