panopticon-cli 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,3439 @@
+#!/usr/bin/env node
+import {
+  AGENTS_DIR,
+  CLAUDE_DIR,
+  CLAUDE_MD_TEMPLATES,
+  COMMANDS_DIR,
+  CONFIG_FILE,
+  INIT_DIRS,
+  PANOPTICON_HOME,
+  SKILLS_DIR,
+  SYNC_TARGETS,
+  __require,
+  addAlias,
+  createBackup,
+  detectShell,
+  executeSync,
+  getAliasInstructions,
+  getDefaultConfig,
+  getShellRcFile,
+  listBackups,
+  loadConfig,
+  planSync,
+  restoreBackup,
+  saveConfig
+} from "../chunk-FR2P66GU.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk23 from "chalk";
+
+// src/cli/commands/init.ts
+import { existsSync, mkdirSync } from "fs";
+import chalk from "chalk";
+import ora from "ora";
+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}`));
+    return;
+  }
+  try {
+    for (const dir of INIT_DIRS) {
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+    }
+    spinner.text = "Created directories...";
+    const config = getDefaultConfig();
+    saveConfig(config);
+    spinner.text = "Created config...";
+    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));
+      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));
+      console.log(chalk.yellow("!") + " Could not detect shell. Add alias manually:");
+      console.log(chalk.dim('    alias pan="panopticon"'));
+    }
+    console.log("");
+    console.log("Next steps:");
+    console.log(chalk.dim("  1. Add skills to ~/.panopticon/skills/"));
+    console.log(chalk.dim("  2. Run: pan sync"));
+  } catch (error) {
+    spinner.fail("Failed to initialize");
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+// 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.length === 0) {
+    console.log(chalk2.yellow("No sync targets configured."));
+    console.log(chalk2.dim("Edit ~/.panopticon/config.toml to add targets."));
+    return;
+  }
+  if (options.dryRun) {
+    console.log(chalk2.bold("Sync Plan (dry run):\n"));
+    for (const runtime of targets) {
+      const plan = planSync(runtime);
+      console.log(chalk2.cyan(`${runtime}:`));
+      if (plan.skills.length === 0 && plan.commands.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}`);
+      }
+      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 = targets.flatMap((r) => [
+      SYNC_TARGETS[r].skills,
+      SYNC_TARGETS[r].commands
+    ]);
+    const backup = createBackup(backupDirs);
+    if (backup.targets.length > 0) {
+      spinner2.succeed(`Backup created: ${backup.timestamp}`);
+    } else {
+      spinner2.info("No existing content to backup");
+    }
+    if (options.backupOnly) {
+      return;
+    }
+  }
+  const spinner = ora2("Syncing...").start();
+  let totalCreated = 0;
+  let totalConflicts = 0;
+  for (const runtime of targets) {
+    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 (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 ${targets.join(", ")}`);
+  }
+}
+
+// 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 (!timestamp) {
+    console.log(chalk3.bold("Available backups:\n"));
+    for (const backup of backups.slice(0, 10)) {
+      console.log(`  ${chalk3.cyan(backup.timestamp)} - ${backup.targets.join(", ")}`);
+    }
+    if (backups.length > 10) {
+      console.log(chalk3.dim(`  ... and ${backups.length - 10} more`));
+    }
+    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 } = 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;
+  }
+  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);
+  }
+}
+
+// src/cli/commands/skills.ts
+import { readdirSync, readFileSync, existsSync as existsSync2 } from "fs";
+import { join } from "path";
+import chalk4 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 listSkills() {
+  if (!existsSync2(SKILLS_DIR)) return [];
+  const skills = [];
+  const dirs = readdirSync(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const dir of dirs) {
+    const skillFile = join(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));
+}
+async function skillsCommand(options) {
+  const skills = listSkills();
+  if (options.json) {
+    console.log(JSON.stringify(skills, null, 2));
+    return;
+  }
+  console.log(chalk4.bold(`
+Panopticon Skills (${skills.length})
+`));
+  if (skills.length === 0) {
+    console.log(chalk4.yellow("No skills found."));
+    console.log(chalk4.dim("Skills should be in ~/.panopticon/skills/<name>/SKILL.md"));
+    return;
+  }
+  for (const skill of skills) {
+    console.log(chalk4.cyan(skill.name));
+    console.log(chalk4.dim(`  ${skill.description}`));
+  }
+  console.log(`
+${chalk4.dim('Run "pan sync" to sync skills to Claude Code')}`);
+}
+
+// src/cli/commands/work/issue.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+
+// src/lib/agents.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, readFileSync as readFileSync4, readdirSync as readdirSync4 } from "fs";
+import { join as join4 } from "path";
+
+// 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;
+  }
+}
+function createSession(name, cwd, initialCommand) {
+  const escapedCwd = cwd.replace(/"/g, '\\"');
+  const cmd = initialCommand ? `tmux new-session -d -s ${name} -c "${escapedCwd}" "${initialCommand.replace(/"/g, '\\"')}"` : `tmux new-session -d -s ${name} -c "${escapedCwd}"`;
+  execSync(cmd);
+}
+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-"));
+}
+
+// src/lib/hooks.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { join as join2 } from "path";
+function getHookDir(agentId) {
+  return join2(AGENTS_DIR, agentId);
+}
+function getHookFile(agentId) {
+  return join2(getHookDir(agentId), "hook.json");
+}
+function getMailDir(agentId) {
+  return join2(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));
+  }
+}
+function getHook(agentId) {
+  const hookFile = getHookFile(agentId);
+  if (!existsSync3(hookFile)) {
+    return null;
+  }
+  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 = readdirSync2(mailDir).filter((f) => f.endsWith(".json"));
+      if (mails.length > 0) {
+        const mailItems = mails.map((file) => {
+          try {
+            const content = readFileSync2(join2(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
+        };
+      }
+    }
+    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();
+  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));
+}
+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(
+    join2(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}`);
+    }
+    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/lib/cv.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, readdirSync as readdirSync3 } from "fs";
+import { join as join3 } from "path";
+function getCVFile(agentId) {
+  return join3(AGENTS_DIR, agentId, "cv.json");
+}
+function getAgentCV(agentId) {
+  const cvFile = getCVFile(agentId);
+  if (existsSync4(cvFile)) {
+    try {
+      return JSON.parse(readFileSync3(cvFile, "utf-8"));
+    } catch {
+    }
+  }
+  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 = join3(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);
+      }
+    }
+  }
+  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 = readdirSync3(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
+      });
+    }
+  }
+  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("");
+  }
+  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");
+}
+
+// src/lib/agents.ts
+function getAgentDir(agentId) {
+  return join4(AGENTS_DIR, agentId);
+}
+function getAgentState(agentId) {
+  const stateFile = join4(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(
+    join4(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()
+  };
+  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;
+    }
+  }
+  const claudeCmd = prompt ? `claude --model ${state.model} "${prompt.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"` : `claude --model ${state.model}`;
+  createSession(agentId, options.workspace, claudeCmd);
+  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 = readdirSync4(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)
+      });
+    }
+  }
+  return agents;
+}
+function stopAgent(agentId) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  if (sessionExists(normalizedId)) {
+    killSession(normalizedId);
+  }
+  const state = getAgentState(normalizedId);
+  if (state) {
+    state.status = "stopped";
+    saveAgentState(state);
+  }
+}
+function messageAgent(agentId, message) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  if (!sessionExists(normalizedId)) {
+    throw new Error(`Agent ${normalizedId} not running`);
+  }
+  sendKeys(normalizedId, message);
+  const mailDir = join4(getAgentDir(normalizedId), "mail");
+  mkdirSync4(mailDir, { recursive: true });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  writeFileSync3(
+    join4(mailDir, `${timestamp}.md`),
+    `# Message
+
+${message}
+`
+  );
+}
+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 = join4(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;
+  writeFileSync3(healthFile, JSON.stringify(health, null, 2));
+  const recoveryPrompt = generateRecoveryPrompt(state);
+  const claudeCmd = `claude --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;
+}
+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 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 { recovered, failed };
+}
+
+// src/cli/commands/work/issue.ts
+async function issueCommand(id, options) {
+  const spinner = ora4(`Preparing workspace for ${id}...`).start();
+  try {
+    const normalizedId = id.toLowerCase();
+    const workspace = process.cwd();
+    if (options.dryRun) {
+      spinner.info("Dry run mode");
+      console.log("");
+      console.log(chalk5.bold("Would create:"));
+      console.log(`  Agent ID:   agent-${normalizedId}`);
+      console.log(`  Workspace:  ${workspace}`);
+      console.log(`  Runtime:    ${options.runtime}`);
+      console.log(`  Model:      ${options.model}`);
+      return;
+    }
+    spinner.text = "Spawning agent...";
+    const agent = spawnAgent({
+      issueId: id,
+      workspace,
+      runtime: options.runtime,
+      model: options.model,
+      prompt: `You are working on issue ${id}. Check beads for context: bd show ${id}`
+    });
+    spinner.succeed(`Agent spawned: ${agent.id}`);
+    console.log("");
+    console.log(chalk5.bold("Agent Details:"));
+    console.log(`  Session:    ${chalk5.cyan(agent.id)}`);
+    console.log(`  Workspace:  ${workspace}`);
+    console.log(`  Runtime:    ${agent.runtime} (${agent.model})`);
+    console.log("");
+    console.log(chalk5.dim("Commands:"));
+    console.log(`  Attach:   tmux attach -t ${agent.id}`);
+    console.log(`  Message:  pan work tell ${id} "your message"`);
+    console.log(`  Kill:     pan work kill ${id}`);
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/work/status.ts
+import chalk6 from "chalk";
+async function statusCommand(options) {
+  const agents = listRunningAgents();
+  if (options.json) {
+    console.log(JSON.stringify(agents, null, 2));
+    return;
+  }
+  if (agents.length === 0) {
+    console.log(chalk6.dim("No running agents."));
+    console.log(chalk6.dim('Use "pan work issue <id>" to spawn one.'));
+    return;
+  }
+  console.log(chalk6.bold("\nRunning Agents\n"));
+  for (const agent of agents) {
+    const statusColor = agent.tmuxActive ? chalk6.green : chalk6.red;
+    const status = agent.tmuxActive ? "running" : "stopped";
+    const startedAt = new Date(agent.startedAt);
+    const duration = Math.floor((Date.now() - startedAt.getTime()) / 1e3 / 60);
+    console.log(`${chalk6.cyan(agent.id)}`);
+    console.log(`  Issue:    ${agent.issueId}`);
+    console.log(`  Status:   ${statusColor(status)}`);
+    console.log(`  Runtime:  ${agent.runtime} (${agent.model})`);
+    console.log(`  Duration: ${duration} min`);
+    console.log(`  Workspace: ${chalk6.dim(agent.workspace)}`);
+    console.log("");
+  }
+}
+
+// src/cli/commands/work/tell.ts
+import chalk7 from "chalk";
+async function tellCommand(id, message) {
+  const agentId = id.startsWith("agent-") ? id : `agent-${id.toLowerCase()}`;
+  try {
+    messageAgent(agentId, message);
+    console.log(chalk7.green("Message sent to " + agentId));
+    console.log(chalk7.dim(`  "${message}"`));
+  } catch (error) {
+    console.error(chalk7.red("Error: " + error.message));
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/work/kill.ts
+import chalk8 from "chalk";
+async function killCommand(id, options) {
+  const agentId = id.startsWith("agent-") ? id : `agent-${id.toLowerCase()}`;
+  const state = getAgentState(agentId);
+  const isRunning = sessionExists(agentId);
+  if (!state && !isRunning) {
+    console.log(chalk8.yellow(`Agent ${agentId} not found.`));
+    return;
+  }
+  if (!options.force && isRunning) {
+  }
+  try {
+    stopAgent(agentId);
+    console.log(chalk8.green(`Killed agent: ${agentId}`));
+  } catch (error) {
+    console.error(chalk8.red("Error: " + error.message));
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/work/pending.ts
+import chalk9 from "chalk";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+async function pendingCommand() {
+  const agents = listRunningAgents().filter((a) => !a.tmuxActive && a.status !== "error");
+  if (agents.length === 0) {
+    console.log(chalk9.dim("No pending reviews."));
+    console.log(chalk9.dim("Agents will appear here when they complete work."));
+    return;
+  }
+  console.log(chalk9.bold("\nPending Reviews\n"));
+  for (const agent of agents) {
+    console.log(`${chalk9.cyan(agent.issueId)}`);
+    console.log(`  Agent:     ${agent.id}`);
+    console.log(`  Workspace: ${chalk9.dim(agent.workspace)}`);
+    const completionFile = join5(AGENTS_DIR, agent.id, "completion.md");
+    if (existsSync6(completionFile)) {
+      const content = readFileSync5(completionFile, "utf8");
+      const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"));
+      if (firstLine) {
+        console.log(`  Summary:   ${chalk9.dim(firstLine.trim())}`);
+      }
+    }
+    console.log("");
+  }
+  console.log(chalk9.dim('Run "pan work approve <id>" to approve and merge.'));
+}
+
+// src/cli/commands/work/approve.ts
+import chalk10 from "chalk";
+import ora5 from "ora";
+import { existsSync as existsSync7, writeFileSync as writeFileSync4, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir } from "os";
+import { execSync as execSync2 } from "child_process";
+function getLinearApiKey() {
+  const envFile = join6(homedir(), ".panopticon.env");
+  if (existsSync7(envFile)) {
+    const content = readFileSync6(envFile, "utf-8");
+    const match = content.match(/LINEAR_API_KEY=(.+)/);
+    if (match) return match[1].trim();
+  }
+  return process.env.LINEAR_API_KEY || null;
+}
+function checkGhCli() {
+  try {
+    execSync2("which gh", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findPRForBranch(workspace) {
+  try {
+    const branch = execSync2("git rev-parse --abbrev-ref HEAD", {
+      cwd: workspace,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const prJson = execSync2(`gh pr list --head "${branch}" --json number,url --limit 1`, {
+      cwd: workspace,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const prs = JSON.parse(prJson);
+    if (prs.length > 0) {
+      return { number: prs[0].number, url: prs[0].url };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function mergePR(workspace, prNumber) {
+  try {
+    execSync2(`gh pr merge ${prNumber} --squash --delete-branch`, {
+      cwd: workspace,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+async function updateLinearStatus(apiKey, issueIdentifier) {
+  try {
+    const { LinearClient } = await import("@linear/sdk");
+    const client = new LinearClient({ apiKey });
+    const me = await client.viewer;
+    const teams = await me.teams();
+    const team = teams.nodes[0];
+    if (!team) return false;
+    const issues = await team.issues({ first: 100 });
+    const issue = issues.nodes.find(
+      (i) => i.identifier.toUpperCase() === issueIdentifier.toUpperCase()
+    );
+    if (!issue) return false;
+    const states = await team.states();
+    const doneState = states.nodes.find((s) => s.type === "completed" && s.name === "Done");
+    if (!doneState) return false;
+    await issue.update({ stateId: doneState.id });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function approveCommand(id, options = {}) {
+  const agentId = id.startsWith("agent-") ? id : `agent-${id.toLowerCase()}`;
+  const state = getAgentState(agentId);
+  if (!state) {
+    console.log(chalk10.yellow(`Agent ${agentId} not found.`));
+    console.log(chalk10.dim('Run "pan work status" to see running agents.'));
+    return;
+  }
+  const spinner = ora5("Approving work...").start();
+  try {
+    const workspace = state.workspace;
+    let prMerged = false;
+    let linearUpdated = false;
+    if (options.merge !== false) {
+      if (!checkGhCli()) {
+        spinner.warn("gh CLI not found - skipping PR merge");
+        console.log(chalk10.dim("  Install: https://cli.github.com/"));
+      } else {
+        spinner.text = "Looking for PR...";
+        const pr = findPRForBranch(workspace);
+        if (pr) {
+          spinner.text = `Merging PR #${pr.number}...`;
+          const result = mergePR(workspace, pr.number);
+          if (result.success) {
+            prMerged = true;
+            console.log(chalk10.green(`  \u2713 Merged PR #${pr.number}`));
+          } else {
+            console.log(chalk10.yellow(`  \u26A0 Failed to merge: ${result.error}`));
+            console.log(chalk10.dim(`    Merge manually: gh pr merge ${pr.number} --squash`));
+          }
+        } else {
+          console.log(chalk10.dim("  No PR found for this branch"));
+        }
+      }
+    }
+    if (options.noLinear !== true) {
+      const apiKey = getLinearApiKey();
+      if (apiKey) {
+        spinner.text = "Updating Linear status...";
+        linearUpdated = await updateLinearStatus(apiKey, state.issueId);
+        if (linearUpdated) {
+          console.log(chalk10.green(`  \u2713 Updated ${state.issueId} to Done`));
+        } else {
+          console.log(chalk10.yellow(`  \u26A0 Failed to update Linear status`));
+        }
+      } else {
+        console.log(chalk10.dim("  LINEAR_API_KEY not set - skipping status update"));
+      }
+    }
+    state.status = "stopped";
+    state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    saveAgentState(state);
+    const approvedFile = join6(AGENTS_DIR, agentId, "approved");
+    writeFileSync4(approvedFile, JSON.stringify({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      prMerged,
+      linearUpdated
+    }));
+    spinner.succeed(`Approved: ${state.issueId}`);
+    console.log("");
+    console.log(chalk10.bold("Summary:"));
+    console.log(`  Issue:   ${chalk10.cyan(state.issueId)}`);
+    console.log(`  PR:      ${prMerged ? chalk10.green("Merged") : chalk10.dim("Not merged")}`);
+    console.log(`  Linear:  ${linearUpdated ? chalk10.green("Updated to Done") : chalk10.dim("Not updated")}`);
+    console.log("");
+    console.log(chalk10.dim("Workspace can be cleaned up with:"));
+    console.log(chalk10.dim(`  pan workspace destroy ${state.issueId}`));
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/work/plan.ts
+import chalk11 from "chalk";
+import ora6 from "ora";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync8 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir2 } from "os";
+import { execSync as execSync3 } from "child_process";
+function getLinearApiKey2() {
+  const envFile = join7(homedir2(), ".panopticon.env");
+  if (existsSync8(envFile)) {
+    const content = readFileSync7(envFile, "utf-8");
+    const match = content.match(/LINEAR_API_KEY=(.+)/);
+    if (match) return match[1].trim();
+  }
+  return process.env.LINEAR_API_KEY || null;
+}
+function findPRDFiles(issueId) {
+  const found = [];
+  const cwd = process.cwd();
+  const searchPaths = [
+    "docs/prds",
+    "docs/prd",
+    "prds",
+    "docs"
+  ];
+  const issueIdLower = issueId.toLowerCase();
+  for (const searchPath of searchPaths) {
+    const fullPath = join7(cwd, searchPath);
+    if (!existsSync8(fullPath)) continue;
+    try {
+      const result = execSync3(
+        `find "${fullPath}" -type f -name "*.md" 2>/dev/null | xargs grep -l -i "${issueIdLower}" 2>/dev/null || true`,
+        { encoding: "utf-8" }
+      );
+      const files = result.trim().split("\n").filter((f) => f);
+      found.push(...files);
+    } catch {
+    }
+  }
+  return [...new Set(found)];
+}
+function generatePlan(issue, prdFiles) {
+  const sections = [];
+  sections.push(`# Execution Plan: ${issue.identifier}`);
+  sections.push("");
+  sections.push(`**Title:** ${issue.title}`);
+  sections.push(`**Status:** ${issue.state.name}`);
+  if (issue.project) {
+    sections.push(`**Project:** ${issue.project.name}`);
+  }
+  sections.push(`**Linear:** ${issue.url}`);
+  sections.push("");
+  if (issue.description) {
+    sections.push("## Issue Description");
+    sections.push("");
+    sections.push(issue.description);
+    sections.push("");
+  }
+  if (prdFiles.length > 0) {
+    sections.push("## Related PRDs");
+    sections.push("");
+    for (const prd of prdFiles) {
+      sections.push(`- [${prd.replace(process.cwd() + "/", "")}](${prd})`);
+    }
+    sections.push("");
+    sections.push("> **IMPORTANT:** Review the PRD before starting implementation.");
+    sections.push("");
+  }
+  sections.push("## Implementation Steps");
+  sections.push("");
+  sections.push("<!-- Edit these steps based on the issue requirements -->");
+  sections.push("");
+  sections.push("- [ ] Understand requirements and existing code");
+  sections.push("- [ ] Design approach (document in comments if complex)");
+  sections.push("- [ ] Implement core functionality");
+  sections.push("- [ ] Add tests");
+  sections.push("- [ ] Verify linting/type checks pass");
+  sections.push("- [ ] Manual testing");
+  sections.push("- [ ] Update documentation if needed");
+  sections.push("");
+  sections.push("## Files to Modify");
+  sections.push("");
+  sections.push("<!-- List files that will need changes -->");
+  sections.push("");
+  sections.push("- TBD after codebase exploration");
+  sections.push("");
+  sections.push("## Test Strategy");
+  sections.push("");
+  sections.push("<!-- Define how this will be tested -->");
+  sections.push("");
+  sections.push("- Unit tests: TBD");
+  sections.push("- Integration tests: TBD");
+  sections.push("- E2E tests: TBD");
+  sections.push("");
+  sections.push("## Acceptance Criteria");
+  sections.push("");
+  sections.push("<!-- What must be true for this to be complete? -->");
+  sections.push("");
+  sections.push("- [ ] Feature works as described");
+  sections.push("- [ ] Tests pass");
+  sections.push("- [ ] No regressions");
+  sections.push("");
+  sections.push("## Notes for Agent");
+  sections.push("");
+  sections.push("<!-- Add any special instructions or context -->");
+  sections.push("");
+  sections.push("- Review this plan before starting");
+  sections.push("- Ask clarifying questions if requirements are unclear");
+  sections.push("- Commit frequently with descriptive messages");
+  sections.push("");
+  return sections.join("\n");
+}
+async function planCommand(id, options = {}) {
+  const spinner = ora6(`Creating execution plan for ${id}...`).start();
+  try {
+    const apiKey = getLinearApiKey2();
+    if (!apiKey) {
+      spinner.fail("LINEAR_API_KEY not found");
+      console.log("");
+      console.log(chalk11.dim("Set it in ~/.panopticon.env:"));
+      console.log("  LINEAR_API_KEY=lin_api_xxxxx");
+      process.exit(1);
+    }
+    spinner.text = "Fetching issue from Linear...";
+    const { LinearClient } = await import("@linear/sdk");
+    const client = new LinearClient({ apiKey });
+    const me = await client.viewer;
+    const teams = await me.teams();
+    const team = teams.nodes[0];
+    if (!team) {
+      spinner.fail("No Linear team found");
+      process.exit(1);
+    }
+    const searchResult = await team.issues({
+      first: 100
+    });
+    const issue = searchResult.nodes.find(
+      (i) => i.identifier.toUpperCase() === id.toUpperCase()
+    );
+    if (!issue) {
+      spinner.fail(`Issue not found: ${id}`);
+      process.exit(1);
+    }
+    const state = await issue.state;
+    const assignee = await issue.assignee;
+    const project2 = await issue.project;
+    const labels = await issue.labels();
+    const issueData = {
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description || void 0,
+      state: { name: state?.name || "Unknown" },
+      priority: issue.priority,
+      url: issue.url,
+      labels: labels.nodes.map((l) => ({ name: l.name })),
+      assignee: assignee ? { name: assignee.name } : void 0,
+      project: project2 ? { name: project2.name } : void 0
+    };
+    spinner.text = "Searching for related PRDs...";
+    const prdFiles = findPRDFiles(id);
+    spinner.text = "Generating execution plan...";
+    const plan = generatePlan(issueData, prdFiles);
+    if (options.json) {
+      spinner.stop();
+      console.log(JSON.stringify({
+        issue: issueData,
+        prdFiles,
+        plan
+      }, null, 2));
+      return;
+    }
+    const outputPath = options.output || `PLAN-${issue.identifier}.md`;
+    writeFileSync5(outputPath, plan);
+    spinner.succeed(`Execution plan created: ${outputPath}`);
+    console.log("");
+    console.log(chalk11.bold("Issue Details:"));
+    console.log(`  ${chalk11.cyan(issue.identifier)} ${issue.title}`);
+    console.log(`  Status: ${state?.name}`);
+    if (prdFiles.length > 0) {
+      console.log(`  PRDs found: ${chalk11.green(prdFiles.length)}`);
+    }
+    console.log("");
+    console.log(chalk11.bold("Next steps:"));
+    console.log(`  1. Review and edit ${chalk11.cyan(outputPath)}`);
+    console.log(`  2. Run ${chalk11.cyan(`pan work issue ${id}`)} to spawn agent`);
+    console.log("");
+    if (prdFiles.length > 0) {
+      console.log(chalk11.yellow("PRD files found - agent will reference these:"));
+      for (const prd of prdFiles) {
+        console.log(`  ${chalk11.dim(prd.replace(process.cwd() + "/", ""))}`);
+      }
+      console.log("");
+    }
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/work/list.ts
+import chalk12 from "chalk";
+import ora7 from "ora";
+import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir3 } from "os";
+function getLinearApiKey3() {
+  const envFile = join8(homedir3(), ".panopticon.env");
+  if (existsSync9(envFile)) {
+    const content = readFileSync8(envFile, "utf-8");
+    const match = content.match(/LINEAR_API_KEY=(.+)/);
+    if (match) return match[1].trim();
+  }
+  return process.env.LINEAR_API_KEY || null;
+}
+var PRIORITY_LABELS = {
+  0: chalk12.dim("None"),
+  1: chalk12.red("Urgent"),
+  2: chalk12.yellow("High"),
+  3: chalk12.blue("Medium"),
+  4: chalk12.dim("Low")
+};
+var STATE_COLORS = {
+  "Backlog": chalk12.dim,
+  "Todo": chalk12.white,
+  "In Progress": chalk12.yellow,
+  "In Review": chalk12.magenta,
+  "Done": chalk12.green,
+  "Canceled": chalk12.strikethrough
+};
+async function listCommand(options) {
+  const spinner = ora7("Fetching issues from Linear...").start();
+  try {
+    const apiKey = getLinearApiKey3();
+    if (!apiKey) {
+      spinner.fail("LINEAR_API_KEY not found");
+      console.log("");
+      console.log(chalk12.dim("Set it in ~/.panopticon.env:"));
+      console.log("  LINEAR_API_KEY=lin_api_xxxxx");
+      process.exit(1);
+    }
+    const { LinearClient } = await import("@linear/sdk");
+    const client = new LinearClient({ apiKey });
+    const me = await client.viewer;
+    const teams = await me.teams();
+    const team = teams.nodes[0];
+    if (!team) {
+      spinner.fail("No Linear team found");
+      process.exit(1);
+    }
+    spinner.text = `Fetching issues from ${team.name}...`;
+    let issues;
+    if (options.mine) {
+      const assignedIssues = await me.assignedIssues({
+        first: 50,
+        filter: options.all ? {} : { state: { type: { neq: "completed" } } }
+      });
+      issues = assignedIssues.nodes;
+    } else {
+      const teamIssues = await team.issues({
+        first: 50,
+        filter: options.all ? {} : { state: { type: { neq: "completed" } } }
+      });
+      issues = teamIssues.nodes;
+    }
+    spinner.stop();
+    if (options.json) {
+      const formatted = await Promise.all(issues.map(async (issue) => {
+        const state = await issue.state;
+        const assignee = await issue.assignee;
+        return {
+          id: issue.id,
+          identifier: issue.identifier,
+          title: issue.title,
+          state: state?.name,
+          priority: issue.priority,
+          assignee: assignee?.name,
+          url: issue.url
+        };
+      }));
+      console.log(JSON.stringify(formatted, null, 2));
+      return;
+    }
+    if (issues.length === 0) {
+      console.log(chalk12.dim("No issues found."));
+      return;
+    }
+    console.log(chalk12.bold(`
+${team.name} Issues
+`));
+    const byState = {};
+    for (const issue of issues) {
+      const state = await issue.state;
+      const stateName = state?.name || "Unknown";
+      if (!byState[stateName]) byState[stateName] = [];
+      byState[stateName].push(issue);
+    }
+    const stateOrder = ["In Progress", "In Review", "Todo", "Backlog", "Done", "Canceled"];
+    for (const stateName of stateOrder) {
+      const stateIssues = byState[stateName];
+      if (!stateIssues || stateIssues.length === 0) continue;
+      const colorFn = STATE_COLORS[stateName] || chalk12.white;
+      console.log(colorFn(`\u2500\u2500 ${stateName} (${stateIssues.length}) \u2500\u2500`));
+      console.log("");
+      for (const issue of stateIssues) {
+        const assignee = await issue.assignee;
+        const priorityLabel = PRIORITY_LABELS[issue.priority] || "";
+        const assigneeStr = assignee ? chalk12.dim(` @${assignee.name.split(" ")[0]}`) : "";
+        console.log(`  ${chalk12.cyan(issue.identifier)} ${issue.title}${assigneeStr}`);
+        if (issue.priority > 0 && issue.priority < 3) {
+          console.log(`    ${priorityLabel}`);
+        }
+      }
+      console.log("");
+    }
+    console.log(chalk12.dim(`Showing ${issues.length} issues. Use --all to include completed.`));
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/work/triage.ts
+import chalk13 from "chalk";
+import ora8 from "ora";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync10 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir4 } from "os";
+function getConfig() {
+  const envFile = join9(homedir4(), ".panopticon.env");
+  const config = {};
+  if (existsSync10(envFile)) {
+    const content = readFileSync9(envFile, "utf-8");
+    const ghMatch = content.match(/GITHUB_TOKEN=(.+)/);
+    if (ghMatch) config.githubToken = ghMatch[1].trim();
+    const repoMatch = content.match(/GITHUB_REPO=(.+)/);
+    if (repoMatch) config.githubRepo = repoMatch[1].trim();
+    const linearMatch = content.match(/LINEAR_API_KEY=(.+)/);
+    if (linearMatch) config.linearApiKey = linearMatch[1].trim();
+  }
+  config.githubToken = config.githubToken || process.env.GITHUB_TOKEN;
+  config.githubRepo = config.githubRepo || process.env.GITHUB_REPO;
+  config.linearApiKey = config.linearApiKey || process.env.LINEAR_API_KEY;
+  return config;
+}
+function getTriageStatePath() {
+  return join9(homedir4(), ".panopticon", "triage-state.json");
+}
+function loadTriageState() {
+  const path = getTriageStatePath();
+  if (existsSync10(path)) {
+    return JSON.parse(readFileSync9(path, "utf-8"));
+  }
+  return { dismissed: [], created: {} };
+}
+function saveTriageState(state) {
+  const path = getTriageStatePath();
+  writeFileSync6(path, JSON.stringify(state, null, 2));
+}
+async function fetchGitHubIssues(token, repo) {
+  const response = await fetch(`https://api.github.com/repos/${repo}/issues?state=open&per_page=50`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+  }
+  const issues = await response.json();
+  return issues.filter((i) => !("pull_request" in i));
+}
+async function createLinearIssue(apiKey, title, description, githubUrl) {
+  const { LinearClient } = await import("@linear/sdk");
+  const client = new LinearClient({ apiKey });
+  const me = await client.viewer;
+  const teams = await me.teams();
+  const team = teams.nodes[0];
+  if (!team) {
+    throw new Error("No Linear team found");
+  }
+  const fullDescription = `${description}
+
+---
+
+**From GitHub:** ${githubUrl}`;
+  const result = await client.createIssue({
+    teamId: team.id,
+    title,
+    description: fullDescription
+  });
+  const issue = await result.issue;
+  return issue?.identifier || "unknown";
+}
+async function triageCommand(id, options = {}) {
+  const spinner = ora8("Loading triage queue...").start();
+  try {
+    const config = getConfig();
+    if (!config.githubToken || !config.githubRepo) {
+      spinner.info("GitHub integration not configured");
+      console.log("");
+      console.log(chalk13.bold("Setup Instructions:"));
+      console.log("");
+      console.log("Add to ~/.panopticon.env:");
+      console.log(chalk13.dim("  GITHUB_TOKEN=ghp_xxxxx"));
+      console.log(chalk13.dim("  GITHUB_REPO=owner/repo"));
+      console.log("");
+      console.log(chalk13.dim("Get a token at: https://github.com/settings/tokens"));
+      console.log(chalk13.dim("Required scopes: repo (for private repos) or public_repo"));
+      return;
+    }
+    const triageState = loadTriageState();
+    if (id) {
+      const issueNumber = parseInt(id.replace("#", ""), 10);
+      if (options.dismiss) {
+        if (!triageState.dismissed.includes(issueNumber)) {
+          triageState.dismissed.push(issueNumber);
+          saveTriageState(triageState);
+        }
+        spinner.succeed(`Dismissed #${issueNumber}: ${options.dismiss}`);
+        return;
+      }
+      if (options.create) {
+        if (!config.linearApiKey) {
+          spinner.fail("LINEAR_API_KEY not configured");
+          return;
+        }
+        spinner.text = `Fetching GitHub issue #${issueNumber}...`;
+        const response = await fetch(
+          `https://api.github.com/repos/${config.githubRepo}/issues/${issueNumber}`,
+          {
+            headers: {
+              Authorization: `Bearer ${config.githubToken}`,
+              Accept: "application/vnd.github.v3+json"
+            }
+          }
+        );
+        if (!response.ok) {
+          spinner.fail(`GitHub issue #${issueNumber} not found`);
+          return;
+        }
+        const ghIssue = await response.json();
+        spinner.text = "Creating Linear issue...";
+        const linearId = await createLinearIssue(
+          config.linearApiKey,
+          ghIssue.title,
+          ghIssue.body || "",
+          ghIssue.html_url
+        );
+        triageState.created[issueNumber] = linearId;
+        saveTriageState(triageState);
+        spinner.succeed(`Created ${linearId} from GitHub #${issueNumber}`);
+        console.log("");
+        console.log(`  GitHub: ${chalk13.dim(ghIssue.html_url)}`);
+        console.log(`  Linear: ${chalk13.cyan(linearId)}`);
+        return;
+      }
+    }
+    spinner.text = "Fetching GitHub issues...";
+    const issues = await fetchGitHubIssues(config.githubToken, config.githubRepo);
+    const pending = issues.filter(
+      (i) => !triageState.dismissed.includes(i.number) && !triageState.created[i.number]
+    );
+    spinner.stop();
+    if (pending.length === 0) {
+      console.log(chalk13.green("No issues pending triage."));
+      console.log(chalk13.dim(`${issues.length} total open, ${triageState.dismissed.length} dismissed, ${Object.keys(triageState.created).length} created`));
+      return;
+    }
+    console.log(chalk13.bold(`
+GitHub Issues Pending Triage (${pending.length})
+`));
+    for (const issue of pending) {
+      const labels = issue.labels.map((l) => chalk13.dim(`[${l.name}]`)).join(" ");
+      console.log(`  ${chalk13.cyan(`#${issue.number}`)} ${issue.title} ${labels}`);
+      console.log(`    ${chalk13.dim(issue.html_url)}`);
+    }
+    console.log("");
+    console.log(chalk13.bold("Commands:"));
+    console.log(`  ${chalk13.dim("Create Linear issue:")} pan work triage <number> --create`);
+    console.log(`  ${chalk13.dim("Dismiss from queue:")}  pan work triage <number> --dismiss "reason"`);
+    console.log("");
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/work/hook.ts
+import chalk14 from "chalk";
+async function hookCommand(action, idOrMessage, options = {}) {
+  const agentId = process.env.PANOPTICON_AGENT_ID || "default";
+  switch (action) {
+    case "check": {
+      const result = checkHook(idOrMessage || agentId);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (!result.hasWork) {
+        console.log(chalk14.green("\u2713 No pending work on hook"));
+        return;
+      }
+      console.log(chalk14.yellow(`\u26A0 ${result.items.length} item(s) on hook`));
+      if (result.urgentCount > 0) {
+        console.log(chalk14.red(`  ${result.urgentCount} URGENT`));
+      }
+      console.log("");
+      for (const item of result.items) {
+        const priorityColor = {
+          urgent: chalk14.red,
+          high: chalk14.yellow,
+          normal: chalk14.white,
+          low: chalk14.dim
+        }[item.priority];
+        console.log(`${priorityColor(`[${item.priority.toUpperCase()}]`)} ${item.id}`);
+        console.log(`  Type: ${item.type}`);
+        console.log(`  From: ${item.source}`);
+        if (item.payload.message) {
+          console.log(`  Message: ${item.payload.message}`);
+        }
+        console.log("");
+      }
+      break;
+    }
+    case "push": {
+      if (!idOrMessage) {
+        console.log(chalk14.red("Usage: pan work hook push <agent-id> <message>"));
+        process.exit(1);
+      }
+      const [targetAgent, ...messageParts] = idOrMessage.split(" ");
+      const message = messageParts.join(" ");
+      if (!message) {
+        console.log(chalk14.red("Message required"));
+        process.exit(1);
+      }
+      const item = pushToHook(targetAgent.startsWith("agent-") ? targetAgent : `agent-${targetAgent}`, {
+        type: "task",
+        priority: "normal",
+        source: "cli",
+        payload: { message }
+      });
+      console.log(chalk14.green(`\u2713 Pushed to hook: ${item.id}`));
+      break;
+    }
+    case "pop": {
+      if (!idOrMessage) {
+        console.log(chalk14.red("Usage: pan work hook pop <item-id>"));
+        process.exit(1);
+      }
+      const success = popFromHook(agentId, idOrMessage);
+      if (success) {
+        console.log(chalk14.green(`\u2713 Popped: ${idOrMessage}`));
+      } else {
+        console.log(chalk14.yellow(`Item not found: ${idOrMessage}`));
+      }
+      break;
+    }
+    case "clear": {
+      clearHook(idOrMessage || agentId);
+      console.log(chalk14.green("\u2713 Hook cleared"));
+      break;
+    }
+    case "mail": {
+      if (!idOrMessage) {
+        console.log(chalk14.red("Usage: pan work hook mail <agent-id> <message>"));
+        process.exit(1);
+      }
+      const [targetAgent, ...messageParts] = idOrMessage.split(" ");
+      const message = messageParts.join(" ");
+      if (!message) {
+        console.log(chalk14.red("Message required"));
+        process.exit(1);
+      }
+      sendMail(
+        targetAgent.startsWith("agent-") ? targetAgent : `agent-${targetAgent}`,
+        "cli",
+        message
+      );
+      console.log(chalk14.green(`\u2713 Mail sent to ${targetAgent}`));
+      break;
+    }
+    case "gupp": {
+      const prompt = generateGUPPPrompt(idOrMessage || agentId);
+      if (!prompt) {
+        console.log(chalk14.green("No GUPP work found"));
+        return;
+      }
+      console.log(prompt);
+      break;
+    }
+    default:
+      console.log(chalk14.bold("Hook Commands:"));
+      console.log("");
+      console.log(`  ${chalk14.cyan("pan work hook check [agent-id]")}  - Check for pending work`);
+      console.log(`  ${chalk14.cyan("pan work hook push <agent-id> <msg>")}  - Push task to hook`);
+      console.log(`  ${chalk14.cyan("pan work hook pop <item-id>")}  - Remove completed item`);
+      console.log(`  ${chalk14.cyan("pan work hook clear [agent-id]")}  - Clear all hook items`);
+      console.log(`  ${chalk14.cyan("pan work hook mail <agent-id> <msg>")}  - Send mail to agent`);
+      console.log(`  ${chalk14.cyan("pan work hook gupp [agent-id]")}  - Generate GUPP prompt`);
+  }
+}
+
+// src/cli/commands/work/recover.ts
+import chalk15 from "chalk";
+import ora9 from "ora";
+async function recoverCommand(id, options = {}) {
+  const spinner = ora9("Checking for crashed agents...").start();
+  try {
+    if (options.all || !id) {
+      const crashed = detectCrashedAgents();
+      if (crashed.length === 0) {
+        spinner.succeed("No crashed agents found");
+        return;
+      }
+      if (options.json) {
+        spinner.stop();
+        console.log(JSON.stringify({ crashed: crashed.map((a) => a.id) }, null, 2));
+        if (!options.all) {
+          console.log(chalk15.dim("\nUse --all to auto-recover all crashed agents"));
+          return;
+        }
+      }
+      if (!options.all) {
+        spinner.info(`Found ${crashed.length} crashed agent(s)`);
+        console.log("");
+        for (const agent of crashed) {
+          console.log(`  ${chalk15.red("\u25CF")} ${chalk15.cyan(agent.id)}`);
+          console.log(`    Issue: ${agent.issueId}`);
+          console.log(`    Started: ${agent.startedAt}`);
+          console.log("");
+        }
+        console.log(chalk15.dim("Use --all to auto-recover, or specify an agent ID"));
+        return;
+      }
+      spinner.text = "Auto-recovering agents...";
+      const result = autoRecoverAgents();
+      spinner.stop();
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (result.recovered.length > 0) {
+        console.log(chalk15.green(`\u2713 Recovered ${result.recovered.length} agent(s):`));
+        for (const agentId2 of result.recovered) {
+          console.log(`  ${chalk15.cyan(agentId2)}`);
+        }
+      }
+      if (result.failed.length > 0) {
+        console.log(chalk15.red(`\u2717 Failed to recover ${result.failed.length} agent(s):`));
+        for (const agentId2 of result.failed) {
+          console.log(`  ${chalk15.dim(agentId2)}`);
+        }
+      }
+      return;
+    }
+    const agentId = id.startsWith("agent-") ? id : `agent-${id.toLowerCase()}`;
+    spinner.text = `Recovering ${agentId}...`;
+    const state = recoverAgent(agentId);
+    if (!state) {
+      spinner.fail(`Agent not found: ${agentId}`);
+      process.exit(1);
+    }
+    spinner.succeed(`Recovered: ${agentId}`);
+    console.log("");
+    console.log(chalk15.bold("Agent Details:"));
+    console.log(`  Issue:     ${chalk15.cyan(state.issueId)}`);
+    console.log(`  Workspace: ${chalk15.dim(state.workspace)}`);
+    console.log(`  Model:     ${state.model}`);
+    console.log("");
+    console.log(chalk15.dim("Commands:"));
+    console.log(`  Attach:  tmux attach -t ${state.id}`);
+    console.log(`  Message: pan work tell ${state.issueId} "your message"`);
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/work/cv.ts
+import chalk16 from "chalk";
+async function cvCommand(agentId, options = {}) {
+  if (options.rankings || !agentId) {
+    const rankings = getAgentRankings();
+    if (options.json) {
+      console.log(JSON.stringify(rankings, null, 2));
+      return;
+    }
+    if (rankings.length === 0) {
+      console.log(chalk16.dim("No agent work history yet."));
+      console.log(chalk16.dim("CVs are created as agents complete work."));
+      return;
+    }
+    console.log(chalk16.bold("\nAgent Rankings\n"));
+    console.log(
+      `${"Agent".padEnd(25)} ${"Success".padStart(8)} ${"Total".padStart(6)} ${"Avg Time".padStart(10)}`
+    );
+    console.log(chalk16.dim("\u2500".repeat(52)));
+    for (let i = 0; i < rankings.length; i++) {
+      const r = rankings[i];
+      const medal = i === 0 ? "\u{1F947}" : i === 1 ? "\u{1F948}" : i === 2 ? "\u{1F949}" : "  ";
+      const successPct = `${(r.successRate * 100).toFixed(0)}%`;
+      const avgTime = r.avgDuration > 0 ? `${r.avgDuration}m` : "-";
+      console.log(
+        `${medal} ${r.agentId.padEnd(22)} ${successPct.padStart(8)} ${r.totalIssues.toString().padStart(6)} ${avgTime.padStart(10)}`
+      );
+    }
+    console.log("");
+    console.log(chalk16.dim(`Use: pan work cv <agent-id> for details`));
+    return;
+  }
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  const cv = getAgentCV(normalizedId);
+  if (options.json) {
+    console.log(JSON.stringify(cv, null, 2));
+    return;
+  }
+  console.log("");
+  console.log(formatCV(cv));
+}
+
+// src/cli/commands/work/context.ts
+import chalk17 from "chalk";
+
+// src/lib/context.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync7, appendFileSync, readdirSync as readdirSync6 } from "fs";
+import { join as join10 } from "path";
+function getStateFile(agentId) {
+  return join10(AGENTS_DIR, agentId, "STATE.md");
+}
+function readAgentState(agentId) {
+  const stateFile = getStateFile(agentId);
+  if (!existsSync11(stateFile)) return null;
+  try {
+    const content = readFileSync10(stateFile, "utf-8");
+    return parseStateMd(content);
+  } catch {
+    return null;
+  }
+}
+function writeAgentState(agentId, state) {
+  const dir = join10(AGENTS_DIR, agentId);
+  mkdirSync5(dir, { recursive: true });
+  const content = generateStateMd(state);
+  writeFileSync7(getStateFile(agentId), content);
+}
+function updateCheckpoint(agentId, checkpoint, resumePoint) {
+  const state = readAgentState(agentId);
+  if (!state) return;
+  state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  state.lastCheckpoint = checkpoint;
+  if (resumePoint) {
+    state.resumePoint = resumePoint;
+  }
+  writeAgentState(agentId, state);
+}
+function generateStateMd(state) {
+  const lines = [
+    `# Agent State: ${state.issueId}`,
+    "",
+    "## Current Position",
+    "",
+    `Issue: ${state.issueId}`,
+    `Status: ${state.status}`,
+    `Last activity: ${state.lastActivity}`,
+    ""
+  ];
+  if (state.lastCheckpoint) {
+    lines.push("## Session Continuity");
+    lines.push("");
+    lines.push(`Last checkpoint: "${state.lastCheckpoint}"`);
+    if (state.resumePoint) {
+      lines.push(`Resume point: "${state.resumePoint}"`);
+    }
+    lines.push("");
+  }
+  if (state.contextRefs.workspace || state.contextRefs.prd || state.contextRefs.beads) {
+    lines.push("## Context References");
+    lines.push("");
+    if (state.contextRefs.workspace) {
+      lines.push(`- Workspace: ${state.contextRefs.workspace}`);
+    }
+    if (state.contextRefs.prd) {
+      lines.push(`- PRD: ${state.contextRefs.prd}`);
+    }
+    if (state.contextRefs.beads) {
+      lines.push(`- Beads: ${state.contextRefs.beads}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function parseStateMd(content) {
+  const state = {
+    issueId: "",
+    status: "",
+    lastActivity: "",
+    contextRefs: {}
+  };
+  const titleMatch = content.match(/# Agent State: (.+)/);
+  if (titleMatch) state.issueId = titleMatch[1].trim();
+  const statusMatch = content.match(/Status: (.+)/);
+  if (statusMatch) state.status = statusMatch[1].trim();
+  const activityMatch = content.match(/Last activity: (.+)/);
+  if (activityMatch) state.lastActivity = activityMatch[1].trim();
+  const checkpointMatch = content.match(/Last checkpoint: "(.+)"/);
+  if (checkpointMatch) state.lastCheckpoint = checkpointMatch[1];
+  const resumeMatch = content.match(/Resume point: "(.+)"/);
+  if (resumeMatch) state.resumePoint = resumeMatch[1];
+  const workspaceMatch = content.match(/- Workspace: (.+)/);
+  if (workspaceMatch) state.contextRefs.workspace = workspaceMatch[1].trim();
+  const prdMatch = content.match(/- PRD: (.+)/);
+  if (prdMatch) state.contextRefs.prd = prdMatch[1].trim();
+  const beadsMatch = content.match(/- Beads: (.+)/);
+  if (beadsMatch) state.contextRefs.beads = beadsMatch[1].trim();
+  return state;
+}
+function getSummaryFile(agentId) {
+  return join10(AGENTS_DIR, agentId, "SUMMARY.md");
+}
+function appendSummary(agentId, summary) {
+  const dir = join10(AGENTS_DIR, agentId);
+  mkdirSync5(dir, { recursive: true });
+  const summaryFile = getSummaryFile(agentId);
+  const content = generateSummaryEntry(summary);
+  if (existsSync11(summaryFile)) {
+    appendFileSync(summaryFile, "\n---\n\n" + content);
+  } else {
+    writeFileSync7(summaryFile, "# Work Summaries\n\n" + content);
+  }
+}
+function generateSummaryEntry(summary) {
+  const lines = [
+    `## ${summary.title}`,
+    "",
+    `**Completed:** ${summary.completedAt}`
+  ];
+  if (summary.duration) {
+    lines.push(`**Duration:** ${summary.duration} minutes`);
+  }
+  lines.push("");
+  lines.push("### What Was Done");
+  lines.push("");
+  for (let i = 0; i < summary.whatWasDone.length; i++) {
+    lines.push(`${i + 1}. ${summary.whatWasDone[i]}`);
+  }
+  if (summary.keyInsights && summary.keyInsights.length > 0) {
+    lines.push("");
+    lines.push("### Key Insights");
+    lines.push("");
+    for (let i = 0; i < summary.keyInsights.length; i++) {
+      lines.push(`${i + 1}. ${summary.keyInsights[i]}`);
+    }
+  }
+  if (summary.filesModified && summary.filesModified.length > 0) {
+    lines.push("");
+    lines.push("### Files Modified");
+    lines.push("");
+    for (const file of summary.filesModified) {
+      lines.push(`- ${file}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function getHistoryDir(agentId) {
+  return join10(AGENTS_DIR, agentId, "history");
+}
+function logHistory(agentId, action, details) {
+  const historyDir = getHistoryDir(agentId);
+  mkdirSync5(historyDir, { recursive: true });
+  const date = /* @__PURE__ */ new Date();
+  const dateStr = date.toISOString().split("T")[0];
+  const historyFile = join10(historyDir, `${dateStr}.log`);
+  const timestamp = date.toISOString();
+  const detailsStr = details ? ` ${JSON.stringify(details)}` : "";
+  const logLine = `[${timestamp}] ${action}${detailsStr}
+`;
+  appendFileSync(historyFile, logLine);
+}
+function searchHistory(agentId, pattern) {
+  const historyDir = getHistoryDir(agentId);
+  if (!existsSync11(historyDir)) return [];
+  const results = [];
+  const regex = new RegExp(pattern, "i");
+  const files = readdirSync6(historyDir).filter((f) => f.endsWith(".log"));
+  files.sort().reverse();
+  for (const file of files) {
+    const content = readFileSync10(join10(historyDir, file), "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (regex.test(line)) {
+        results.push(line);
+      }
+    }
+  }
+  return results;
+}
+function getRecentHistory(agentId, limit = 20) {
+  const historyDir = getHistoryDir(agentId);
+  if (!existsSync11(historyDir)) return [];
+  const results = [];
+  const files = readdirSync6(historyDir).filter((f) => f.endsWith(".log"));
+  files.sort().reverse();
+  for (const file of files) {
+    if (results.length >= limit) break;
+    const content = readFileSync10(join10(historyDir, file), "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (const line of lines.reverse()) {
+      if (results.length >= limit) break;
+      results.push(line);
+    }
+  }
+  return results;
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function getMaterializedDir(agentId) {
+  return join10(AGENTS_DIR, agentId, "materialized");
+}
+function listMaterialized(agentId) {
+  const dir = getMaterializedDir(agentId);
+  if (!existsSync11(dir)) return [];
+  return readdirSync6(dir).filter((f) => f.endsWith(".md")).map((f) => {
+    const match = f.match(/^(.+)-(\d+)\.md$/);
+    if (!match) return null;
+    return {
+      tool: match[1],
+      timestamp: parseInt(match[2], 10),
+      file: join10(dir, f)
+    };
+  }).filter(Boolean);
+}
+function readMaterialized(filepath) {
+  if (!existsSync11(filepath)) return null;
+  return readFileSync10(filepath, "utf-8");
+}
+
+// src/cli/commands/work/context.ts
+import { readFileSync as readFileSync11, existsSync as existsSync12 } from "fs";
+async function contextCommand(action, arg1, arg2, options = {}) {
+  const agentId = process.env.PANOPTICON_AGENT_ID || arg1 || "default";
+  switch (action) {
+    case "state": {
+      const state = readAgentState(agentId);
+      if (options.json) {
+        console.log(JSON.stringify(state, null, 2));
+        return;
+      }
+      if (!state) {
+        console.log(chalk17.dim("No state found for agent."));
+        console.log(chalk17.dim("Initialize with: pan work context init <agent-id> <issue-id>"));
+        return;
+      }
+      console.log(chalk17.bold(`
+Agent State: ${state.issueId}
+`));
+      console.log(`Status: ${chalk17.cyan(state.status)}`);
+      console.log(`Last Activity: ${chalk17.dim(state.lastActivity)}`);
+      if (state.lastCheckpoint) {
+        console.log("");
+        console.log(chalk17.bold("Session Continuity:"));
+        console.log(`  Checkpoint: ${chalk17.yellow(state.lastCheckpoint)}`);
+        if (state.resumePoint) {
+          console.log(`  Resume: ${chalk17.green(state.resumePoint)}`);
+        }
+      }
+      if (state.contextRefs.workspace || state.contextRefs.prd) {
+        console.log("");
+        console.log(chalk17.bold("Context References:"));
+        if (state.contextRefs.workspace) {
+          console.log(`  Workspace: ${chalk17.dim(state.contextRefs.workspace)}`);
+        }
+        if (state.contextRefs.prd) {
+          console.log(`  PRD: ${chalk17.dim(state.contextRefs.prd)}`);
+        }
+        if (state.contextRefs.beads) {
+          console.log(`  Beads: ${chalk17.dim(state.contextRefs.beads)}`);
+        }
+      }
+      console.log("");
+      break;
+    }
+    case "init": {
+      const issueId = arg2 || arg1 || "UNKNOWN";
+      const targetAgent = arg2 ? arg1 : agentId;
+      const state = {
+        issueId: issueId.toUpperCase(),
+        status: "In Progress",
+        lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+        contextRefs: {}
+      };
+      writeAgentState(targetAgent, state);
+      logHistory(targetAgent, "context:init", { issueId });
+      console.log(chalk17.green(`\u2713 Initialized state for ${targetAgent}`));
+      break;
+    }
+    case "checkpoint": {
+      const checkpoint = arg1;
+      const resume = arg2;
+      if (!checkpoint) {
+        console.log(chalk17.red("Checkpoint message required"));
+        console.log(chalk17.dim('Usage: pan work context checkpoint "message" ["resume point"]'));
+        return;
+      }
+      updateCheckpoint(agentId, checkpoint, resume);
+      logHistory(agentId, "context:checkpoint", { checkpoint, resume });
+      console.log(chalk17.green(`\u2713 Checkpoint saved: "${checkpoint}"`));
+      if (resume) {
+        console.log(chalk17.dim(`  Resume point: "${resume}"`));
+      }
+      break;
+    }
+    case "summary": {
+      const title = arg1 || "Work Session";
+      const summary = {
+        title,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        whatWasDone: ["Completed assigned work"]
+      };
+      appendSummary(agentId, summary);
+      logHistory(agentId, "context:summary", { title });
+      console.log(chalk17.green(`\u2713 Summary added: "${title}"`));
+      break;
+    }
+    case "history": {
+      const pattern = arg1;
+      if (pattern) {
+        const results = searchHistory(agentId, pattern);
+        if (results.length === 0) {
+          console.log(chalk17.dim("No matches found."));
+          return;
+        }
+        console.log(chalk17.bold(`
+History matches for "${pattern}":
+`));
+        for (const line of results.slice(0, 50)) {
+          console.log(line);
+        }
+      } else {
+        const recent = getRecentHistory(agentId, 20);
+        if (recent.length === 0) {
+          console.log(chalk17.dim("No history yet."));
+          return;
+        }
+        console.log(chalk17.bold("\nRecent History:\n"));
+        for (const line of recent) {
+          console.log(line);
+        }
+      }
+      console.log("");
+      break;
+    }
+    case "materialize": {
+      const filepath = arg1;
+      if (filepath && existsSync12(filepath)) {
+        const content = readMaterialized(filepath);
+        if (content) {
+          console.log(content);
+        }
+        return;
+      }
+      const outputs = listMaterialized(agentId);
+      if (outputs.length === 0) {
+        console.log(chalk17.dim("No materialized outputs."));
+        return;
+      }
+      console.log(chalk17.bold("\nMaterialized Outputs:\n"));
+      for (const out of outputs) {
+        const date = new Date(out.timestamp).toLocaleString();
+        console.log(`  ${chalk17.cyan(out.tool)} ${chalk17.dim(date)}`);
+        console.log(`    ${chalk17.dim(out.file)}`);
+      }
+      console.log("");
+      break;
+    }
+    case "tokens": {
+      const target = arg1;
+      if (!target) {
+        console.log(chalk17.dim("Usage: pan work context tokens <file-or-text>"));
+        return;
+      }
+      let text = target;
+      if (existsSync12(target)) {
+        text = readFileSync11(target, "utf-8");
+      }
+      const tokens = estimateTokens(text);
+      console.log(`Estimated tokens: ${chalk17.cyan(tokens.toLocaleString())}`);
+      break;
+    }
+    default:
+      console.log(chalk17.bold("Context Commands:"));
+      console.log("");
+      console.log(`  ${chalk17.cyan("pan work context state [agent-id]")}     - Show current state`);
+      console.log(`  ${chalk17.cyan("pan work context init <agent> <issue>")} - Initialize state`);
+      console.log(`  ${chalk17.cyan('pan work context checkpoint "msg"')}     - Save checkpoint`);
+      console.log(`  ${chalk17.cyan("pan work context summary [title]")}      - Add work summary`);
+      console.log(`  ${chalk17.cyan("pan work context history [pattern]")}    - Search history`);
+      console.log(`  ${chalk17.cyan("pan work context materialize [file]")}   - List/read outputs`);
+      console.log(`  ${chalk17.cyan("pan work context tokens <file>")}        - Estimate token count`);
+      console.log("");
+  }
+}
+
+// src/cli/commands/work/health.ts
+import chalk18 from "chalk";
+
+// src/lib/health.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
+import { join as join11 } from "path";
+import { execSync as execSync4 } from "child_process";
+var DEFAULT_PING_TIMEOUT_MS = 30 * 1e3;
+var DEFAULT_CONSECUTIVE_FAILURES = 3;
+var DEFAULT_COOLDOWN_MS = 5 * 60 * 1e3;
+var DEFAULT_CHECK_INTERVAL_MS = 30 * 1e3;
+function getHealthFile(agentId) {
+  return join11(AGENTS_DIR, agentId, "health.json");
+}
+function getAgentHealth(agentId) {
+  const healthFile = getHealthFile(agentId);
+  const defaultHealth = {
+    agentId,
+    status: "healthy",
+    consecutiveFailures: 0,
+    forceKillCount: 0,
+    recoveryCount: 0,
+    inCooldown: false
+  };
+  if (existsSync13(healthFile)) {
+    try {
+      const stored = JSON.parse(readFileSync12(healthFile, "utf-8"));
+      return { ...defaultHealth, ...stored };
+    } catch {
+    }
+  }
+  return defaultHealth;
+}
+function saveAgentHealth(health) {
+  const dir = join11(AGENTS_DIR, health.agentId);
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync8(getHealthFile(health.agentId), JSON.stringify(health, null, 2));
+}
+function isAgentAlive(agentId) {
+  try {
+    execSync4(`tmux has-session -t "${agentId}" 2>/dev/null`, { encoding: "utf-8" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pingAgent(agentId, config = {
+  pingTimeoutMs: DEFAULT_PING_TIMEOUT_MS,
+  consecutiveFailures: DEFAULT_CONSECUTIVE_FAILURES,
+  cooldownMs: DEFAULT_COOLDOWN_MS,
+  checkIntervalMs: DEFAULT_CHECK_INTERVAL_MS
+}) {
+  const health = getAgentHealth(agentId);
+  health.lastPing = (/* @__PURE__ */ new Date()).toISOString();
+  const alive = isAgentAlive(agentId);
+  if (!alive) {
+    health.status = "dead";
+    health.consecutiveFailures++;
+  } else {
+    const state = getAgentState(agentId);
+    const lastActivity = state?.lastActivity ? new Date(state.lastActivity) : null;
+    if (lastActivity) {
+      const ageMs = Date.now() - lastActivity.getTime();
+      const ageMinutes = ageMs / (1e3 * 60);
+      if (ageMinutes > 30) {
+        health.status = "stuck";
+        health.consecutiveFailures++;
+      } else if (ageMinutes > 15) {
+        health.status = "warning";
+      } else {
+        health.status = "healthy";
+        health.consecutiveFailures = 0;
+      }
+    } else {
+      health.status = "healthy";
+      health.consecutiveFailures = 0;
+    }
+    health.lastPingResponse = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  if (health.lastForceKill) {
+    const timeSinceKill = Date.now() - new Date(health.lastForceKill).getTime();
+    health.inCooldown = timeSinceKill < config.cooldownMs;
+  } else {
+    health.inCooldown = false;
+  }
+  saveAgentHealth(health);
+  return health;
+}
+async function handleStuckAgent(agentId, config = {
+  pingTimeoutMs: DEFAULT_PING_TIMEOUT_MS,
+  consecutiveFailures: DEFAULT_CONSECUTIVE_FAILURES,
+  cooldownMs: DEFAULT_COOLDOWN_MS,
+  checkIntervalMs: DEFAULT_CHECK_INTERVAL_MS
+}) {
+  const health = getAgentHealth(agentId);
+  if (health.consecutiveFailures < config.consecutiveFailures) {
+    return {
+      action: "skipped",
+      reason: `Only ${health.consecutiveFailures} failures (need ${config.consecutiveFailures})`
+    };
+  }
+  if (health.lastForceKill) {
+    const timeSinceKill = Date.now() - new Date(health.lastForceKill).getTime();
+    if (timeSinceKill < config.cooldownMs) {
+      const remainingMs = config.cooldownMs - timeSinceKill;
+      const remainingMin = Math.ceil(remainingMs / (1e3 * 60));
+      return {
+        action: "cooldown",
+        reason: `In cooldown (${remainingMin}m remaining)`
+      };
+    }
+  }
+  try {
+    stopAgent(agentId);
+  } catch {
+  }
+  health.lastForceKill = (/* @__PURE__ */ new Date()).toISOString();
+  health.forceKillCount++;
+  health.consecutiveFailures = 0;
+  health.status = "dead";
+  health.inCooldown = true;
+  saveAgentHealth(health);
+  try {
+    const recovered = recoverAgent(agentId);
+    if (recovered) {
+      health.status = "healthy";
+      health.recoveryCount++;
+      saveAgentHealth(health);
+      return { action: "recovered", reason: "Force killed and respawned" };
+    }
+  } catch {
+  }
+  return { action: "recovered", reason: "Force killed (respawn failed)" };
+}
+async function runHealthCheck(config = {
+  pingTimeoutMs: DEFAULT_PING_TIMEOUT_MS,
+  consecutiveFailures: DEFAULT_CONSECUTIVE_FAILURES,
+  cooldownMs: DEFAULT_COOLDOWN_MS,
+  checkIntervalMs: DEFAULT_CHECK_INTERVAL_MS
+}) {
+  const results = {
+    checked: 0,
+    healthy: 0,
+    warning: 0,
+    stuck: 0,
+    dead: 0,
+    recovered: []
+  };
+  let sessions = [];
+  try {
+    const output = execSync4(
+      'tmux list-sessions -F "#{session_name}" 2>/dev/null || true',
+      { encoding: "utf-8" }
+    );
+    sessions = output.trim().split("\n").filter((s) => s.startsWith("agent-"));
+  } catch {
+  }
+  if (existsSync13(AGENTS_DIR)) {
+    const { readdirSync: readdirSync10 } = await import("fs");
+    const dirs = readdirSync10(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("agent-")).map((d) => d.name);
+    for (const dir of dirs) {
+      if (!sessions.includes(dir)) {
+        sessions.push(dir);
+      }
+    }
+  }
+  for (const agentId of sessions) {
+    results.checked++;
+    const health = pingAgent(agentId, config);
+    switch (health.status) {
+      case "healthy":
+        results.healthy++;
+        break;
+      case "warning":
+        results.warning++;
+        break;
+      case "stuck":
+        results.stuck++;
+        const result = await handleStuckAgent(agentId, config);
+        if (result.action === "recovered") {
+          results.recovered.push(agentId);
+        }
+        break;
+      case "dead":
+        results.dead++;
+        const deadResult = await handleStuckAgent(agentId, config);
+        if (deadResult.action === "recovered") {
+          results.recovered.push(agentId);
+        }
+        break;
+    }
+  }
+  return results;
+}
+function startHealthDaemon(config = {
+  pingTimeoutMs: DEFAULT_PING_TIMEOUT_MS,
+  consecutiveFailures: DEFAULT_CONSECUTIVE_FAILURES,
+  cooldownMs: DEFAULT_COOLDOWN_MS,
+  checkIntervalMs: DEFAULT_CHECK_INTERVAL_MS
+}, onCheck) {
+  let running = true;
+  const runLoop = async () => {
+    while (running) {
+      try {
+        const results = await runHealthCheck(config);
+        if (onCheck) {
+          onCheck(results);
+        }
+      } catch (error) {
+        console.error("Health check error:", error);
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, config.checkIntervalMs));
+    }
+  };
+  runLoop();
+  return () => {
+    running = false;
+  };
+}
+function formatHealthStatus(health) {
+  const statusIcons = {
+    healthy: "\u2705",
+    warning: "\u26A0\uFE0F",
+    stuck: "\u{1F7E0}",
+    dead: "\u274C"
+  };
+  const lines = [
+    `${statusIcons[health.status]} ${health.agentId}: ${health.status.toUpperCase()}`
+  ];
+  if (health.lastPing) {
+    lines.push(`  Last ping: ${health.lastPing}`);
+  }
+  if (health.consecutiveFailures > 0) {
+    lines.push(`  Consecutive failures: ${health.consecutiveFailures}`);
+  }
+  if (health.forceKillCount > 0) {
+    lines.push(`  Force kills: ${health.forceKillCount}`);
+  }
+  if (health.recoveryCount > 0) {
+    lines.push(`  Recoveries: ${health.recoveryCount}`);
+  }
+  if (health.inCooldown) {
+    lines.push(`  Status: IN COOLDOWN`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/work/health.ts
+async function healthCommand(action, arg, options = {}) {
+  const config = {
+    pingTimeoutMs: DEFAULT_PING_TIMEOUT_MS,
+    consecutiveFailures: DEFAULT_CONSECUTIVE_FAILURES,
+    cooldownMs: DEFAULT_COOLDOWN_MS,
+    checkIntervalMs: options.interval ? options.interval * 1e3 : DEFAULT_CHECK_INTERVAL_MS
+  };
+  switch (action) {
+    case "check": {
+      console.log(chalk18.bold("Running health check...\n"));
+      const results = await runHealthCheck(config);
+      if (options.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+      }
+      console.log(`Checked: ${results.checked} agents`);
+      console.log(`  ${chalk18.green("\u2705 Healthy:")} ${results.healthy}`);
+      console.log(`  ${chalk18.yellow("\u26A0\uFE0F Warning:")} ${results.warning}`);
+      console.log(`  ${chalk18.hex("#FFA500")("\u{1F7E0} Stuck:")} ${results.stuck}`);
+      console.log(`  ${chalk18.red("\u274C Dead:")} ${results.dead}`);
+      if (results.recovered.length > 0) {
+        console.log("");
+        console.log(chalk18.green("Recovered agents:"));
+        for (const agentId of results.recovered) {
+          console.log(`  - ${agentId}`);
+        }
+      }
+      break;
+    }
+    case "status": {
+      const agents = listRunningAgents();
+      if (agents.length === 0) {
+        console.log(chalk18.dim("No agents found."));
+        return;
+      }
+      const healthData = agents.map((agent) => {
+        const health = getAgentHealth(agent.id);
+        return { agent, health };
+      });
+      if (options.json) {
+        console.log(JSON.stringify(healthData.map((d) => d.health), null, 2));
+        return;
+      }
+      console.log(chalk18.bold("Agent Health Status:\n"));
+      for (const { health } of healthData) {
+        console.log(formatHealthStatus(health));
+        console.log("");
+      }
+      break;
+    }
+    case "ping": {
+      if (!arg) {
+        console.log(chalk18.red("Agent ID required"));
+        console.log(chalk18.dim("Usage: pan work health ping <agent-id>"));
+        return;
+      }
+      const agentId = arg.startsWith("agent-") ? arg : `agent-${arg.toLowerCase()}`;
+      console.log(chalk18.dim(`Pinging ${agentId}...`));
+      const health = pingAgent(agentId, config);
+      if (options.json) {
+        console.log(JSON.stringify(health, null, 2));
+        return;
+      }
+      console.log("");
+      console.log(formatHealthStatus(health));
+      break;
+    }
+    case "recover": {
+      if (!arg) {
+        console.log(chalk18.red("Agent ID required"));
+        console.log(chalk18.dim("Usage: pan work health recover <agent-id>"));
+        return;
+      }
+      const agentId = arg.startsWith("agent-") ? arg : `agent-${arg.toLowerCase()}`;
+      console.log(chalk18.dim(`Attempting recovery of ${agentId}...`));
+      const forceConfig = { ...config, consecutiveFailures: 0 };
+      const result = await handleStuckAgent(agentId, forceConfig);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+      if (result.action === "recovered") {
+        console.log(chalk18.green(`\u2705 ${result.reason}`));
+      } else if (result.action === "cooldown") {
+        console.log(chalk18.yellow(`\u26A0\uFE0F ${result.reason}`));
+      } else {
+        console.log(chalk18.dim(result.reason));
+      }
+      break;
+    }
+    case "daemon": {
+      console.log(chalk18.bold("Starting Panopticon Health Daemon"));
+      console.log(chalk18.dim(`Check interval: ${config.checkIntervalMs / 1e3}s`));
+      console.log(chalk18.dim(`Failure threshold: ${config.consecutiveFailures}`));
+      console.log(chalk18.dim(`Cooldown: ${config.cooldownMs / (1e3 * 60)}m`));
+      console.log("");
+      console.log(chalk18.dim("Press Ctrl+C to stop...\n"));
+      const stop = startHealthDaemon(config, (results) => {
+        const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        const statusParts = [
+          `[${timestamp}]`,
+          `\u2705${results.healthy}`,
+          `\u26A0\uFE0F${results.warning}`,
+          `\u{1F7E0}${results.stuck}`,
+          `\u274C${results.dead}`
+        ];
+        if (results.recovered.length > 0) {
+          statusParts.push(chalk18.green(`+${results.recovered.length} recovered`));
+        }
+        console.log(statusParts.join(" "));
+      });
+      process.on("SIGINT", () => {
+        console.log("\n" + chalk18.dim("Stopping health daemon..."));
+        stop();
+        process.exit(0);
+      });
+      await new Promise(() => {
+      });
+      break;
+    }
+    default:
+      console.log(chalk18.bold("Health Monitoring Commands:"));
+      console.log("");
+      console.log(`  ${chalk18.cyan("pan work health check")}         - Run single health check`);
+      console.log(`  ${chalk18.cyan("pan work health status")}        - Show all agent health`);
+      console.log(`  ${chalk18.cyan("pan work health ping <id>")}     - Ping specific agent`);
+      console.log(`  ${chalk18.cyan("pan work health recover <id>")}  - Force recover agent`);
+      console.log(`  ${chalk18.cyan("pan work health daemon")}        - Start health daemon`);
+      console.log("");
+      console.log(chalk18.bold("Options:"));
+      console.log(`  ${chalk18.dim("--json")}               Output as JSON`);
+      console.log(`  ${chalk18.dim("--interval <sec>")}     Check interval for daemon (default: 30)`);
+      console.log("");
+      console.log(chalk18.bold("Deacon Pattern Defaults:"));
+      console.log(`  Ping timeout: ${DEFAULT_PING_TIMEOUT_MS / 1e3}s`);
+      console.log(`  Consecutive failures: ${DEFAULT_CONSECUTIVE_FAILURES}`);
+      console.log(`  Cooldown after kill: ${DEFAULT_COOLDOWN_MS / (1e3 * 60)}m`);
+      console.log("");
+  }
+}
+
+// src/cli/commands/work/index.ts
+function registerWorkCommands(program2) {
+  const work = program2.command("work").description("Agent and work management");
+  work.command("issue <id>").description("Spawn agent for Linear issue").option("--model <model>", "Claude model (sonnet/opus/haiku)", "sonnet").option("--runtime <runtime>", "AI runtime (claude/codex)", "claude").option("--dry-run", "Show what would be created").action(issueCommand);
+  work.command("status").description("Show all running agents").option("--json", "Output as JSON").action(statusCommand);
+  work.command("tell <id> <message>").description("Send message to running agent").action(tellCommand);
+  work.command("kill <id>").description("Kill an agent").option("--force", "Kill without confirmation").action(killCommand);
+  work.command("pending").description("Show completed work awaiting review").action(pendingCommand);
+  work.command("approve <id>").description("Approve agent work, merge MR, update Linear").option("--no-merge", "Skip MR merge").option("--no-linear", "Skip Linear status update").action(approveCommand);
+  work.command("plan <id>").description("Create execution plan before spawning").option("-o, --output <path>", "Output file path").option("--json", "Output as JSON").action(planCommand);
+  work.command("list").description("List Linear issues").option("--all", "Include completed issues").option("--mine", "Show only my assigned issues").option("--json", "Output as JSON").action(listCommand);
+  work.command("triage [id]").description("Triage secondary tracker issues").option("--create", "Create primary issue from secondary").option("--dismiss <reason>", "Dismiss from triage").action(triageCommand);
+  work.command("hook [action] [idOrMessage...]").description("GUPP hooks: check, push, pop, clear, mail, gupp").option("--json", "Output as JSON").action((action, idOrMessage, options) => {
+    hookCommand(action || "help", idOrMessage?.join(" "), options);
+  });
+  work.command("recover [id]").description("Recover crashed agents").option("--all", "Auto-recover all crashed agents").option("--json", "Output as JSON").action(recoverCommand);
+  work.command("cv [agentId]").description("View agent CVs (work history) and rankings").option("--json", "Output as JSON").option("--rankings", "Show agent rankings").action(cvCommand);
+  work.command("context [action] [arg1] [arg2]").description("Context engineering: state, checkpoint, history, materialize").option("--json", "Output as JSON").action((action, arg1, arg2, options) => {
+    contextCommand(action || "help", arg1, arg2, options);
+  });
+  work.command("health [action] [id]").description("Health monitoring: check, status, ping, recover, daemon").option("--json", "Output as JSON").option("--interval <seconds>", "Daemon check interval", "30").action((action, id, options) => {
+    healthCommand(action || "help", id, {
+      json: options.json,
+      interval: parseInt(options.interval, 10)
+    });
+  });
+}
+
+// src/cli/commands/workspace.ts
+import chalk19 from "chalk";
+import ora10 from "ora";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { join as join14, basename as basename2 } from "path";
+
+// src/lib/worktree.ts
+import { execSync as execSync5 } from "child_process";
+import { mkdirSync as mkdirSync7 } from "fs";
+import { dirname } from "path";
+function listWorktrees(repoPath) {
+  const output = execSync5("git worktree list --porcelain", {
+    cwd: repoPath,
+    encoding: "utf8"
+  });
+  const worktrees = [];
+  let current = {};
+  for (const line of output.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) worktrees.push(current);
+      current = { path: line.slice(9), prunable: false };
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.slice(5);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.slice(7).replace("refs/heads/", "");
+    } else if (line === "prunable") {
+      current.prunable = true;
+    }
+  }
+  if (current.path) worktrees.push(current);
+  return worktrees;
+}
+function createWorktree(repoPath, targetPath, branchName) {
+  mkdirSync7(dirname(targetPath), { recursive: true });
+  try {
+    execSync5(`git show-ref --verify --quiet refs/heads/${branchName}`, {
+      cwd: repoPath
+    });
+    execSync5(`git worktree add "${targetPath}" "${branchName}"`, {
+      cwd: repoPath,
+      stdio: "pipe"
+    });
+  } catch {
+    execSync5(`git worktree add -b "${branchName}" "${targetPath}"`, {
+      cwd: repoPath,
+      stdio: "pipe"
+    });
+  }
+}
+function removeWorktree(repoPath, worktreePath) {
+  execSync5(`git worktree remove "${worktreePath}" --force`, {
+    cwd: repoPath,
+    stdio: "pipe"
+  });
+}
+
+// src/lib/template.ts
+import { readFileSync as readFileSync13, existsSync as existsSync14, readdirSync as readdirSync7 } from "fs";
+import { join as join12 } from "path";
+function loadTemplate(templatePath) {
+  if (!existsSync14(templatePath)) {
+    throw new Error(`Template not found: ${templatePath}`);
+  }
+  return readFileSync13(templatePath, "utf8");
+}
+function substituteVariables(template, variables) {
+  let result = template;
+  for (const [key, value] of Object.entries(variables)) {
+    if (value !== void 0) {
+      result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+      result = result.replace(new RegExp(`\\$\\{${key}\\}`, "g"), value);
+    }
+  }
+  return result;
+}
+function generateClaudeMd(projectPath, variables) {
+  const sections = [];
+  const defaultOrder = [
+    "workspace-info.md",
+    "beads.md",
+    "commands-skills.md",
+    "warnings.md"
+  ];
+  for (const section of defaultOrder) {
+    const sectionPath = join12(CLAUDE_MD_TEMPLATES, section);
+    if (existsSync14(sectionPath)) {
+      const content = loadTemplate(sectionPath);
+      sections.push(substituteVariables(content, variables));
+    }
+  }
+  const projectSections = join12(projectPath, ".panopticon", "claude-md", "sections");
+  if (existsSync14(projectSections)) {
+    const projectFiles = readdirSync7(projectSections).filter((f) => f.endsWith(".md")).sort();
+    for (const file of projectFiles) {
+      const content = loadTemplate(join12(projectSections, file));
+      sections.push(substituteVariables(content, variables));
+    }
+  }
+  if (sections.length === 0) {
+    return `# Workspace: ${variables.FEATURE_FOLDER}
+
+**Issue:** ${variables.ISSUE_ID}
+**Branch:** ${variables.BRANCH_NAME}
+**Path:** ${variables.WORKSPACE_PATH}
+
+## Getting Started
+
+This workspace was created by Panopticon. Use \`bd\` commands to track your work.
+`;
+  }
+  return sections.join("\n\n---\n\n");
+}
+
+// src/lib/skills-merge.ts
+import {
+  existsSync as existsSync15,
+  readdirSync as readdirSync8,
+  lstatSync,
+  readlinkSync,
+  symlinkSync,
+  mkdirSync as mkdirSync8,
+  appendFileSync as appendFileSync2
+} from "fs";
+import { join as join13 } from "path";
+import { execSync as execSync6 } from "child_process";
+function detectContentOrigin(path, repoPath) {
+  try {
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink()) {
+      const target = readlinkSync(path);
+      if (target.includes(".panopticon")) {
+        return "panopticon";
+      }
+    }
+    try {
+      execSync6(`git ls-files --error-unmatch "${path}" 2>/dev/null`, {
+        cwd: repoPath,
+        stdio: "pipe"
+      });
+      return "git-tracked";
+    } catch {
+      return "user-untracked";
+    }
+  } catch {
+    return "user-untracked";
+  }
+}
+function mergeSkillsIntoWorkspace(workspacePath) {
+  const skillsTarget = join13(workspacePath, ".claude", "skills");
+  const added = [];
+  const skipped = [];
+  mkdirSync8(skillsTarget, { recursive: true });
+  const existingSkills = /* @__PURE__ */ new Set();
+  if (existsSync15(skillsTarget)) {
+    for (const item of readdirSync8(skillsTarget)) {
+      existingSkills.add(item);
+    }
+  }
+  if (!existsSync15(SKILLS_DIR)) return { added, skipped };
+  const panopticonSkills = readdirSync8(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  for (const skill of panopticonSkills) {
+    const targetPath = join13(skillsTarget, skill);
+    const sourcePath = join13(SKILLS_DIR, skill);
+    if (existingSkills.has(skill)) {
+      const origin = detectContentOrigin(targetPath, workspacePath);
+      if (origin === "git-tracked") {
+        skipped.push(`${skill} (git-tracked)`);
+        continue;
+      }
+      if (origin === "panopticon") {
+        continue;
+      }
+    }
+    try {
+      symlinkSync(sourcePath, targetPath);
+      added.push(skill);
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        skipped.push(`${skill} (exists)`);
+      }
+    }
+  }
+  if (added.length > 0) {
+    updateGitignore(skillsTarget, added);
+  }
+  return { added, skipped };
+}
+function updateGitignore(skillsDir, skills) {
+  const gitignorePath = join13(skillsDir, ".gitignore");
+  const content = `# Panopticon-managed symlinks (not committed)
+${skills.join("\n")}
+`;
+  try {
+    appendFileSync2(gitignorePath, content);
+  } catch {
+  }
+}
+
+// src/cli/commands/workspace.ts
+function registerWorkspaceCommands(program2) {
+  const workspace = program2.command("workspace").description("Workspace management");
+  workspace.command("create <issueId>").description("Create workspace for issue").option("--dry-run", "Show what would be created").option("--no-skills", "Skip skills symlink setup").action(createCommand);
+  workspace.command("list").description("List all workspaces").option("--json", "Output as JSON").action(listCommand2);
+  workspace.command("destroy <issueId>").description("Destroy workspace").option("--force", "Force removal even with uncommitted changes").action(destroyCommand);
+}
+async function createCommand(issueId, options) {
+  const spinner = ora10("Creating workspace...").start();
+  try {
+    const normalizedId = issueId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    const branchName = `feature/${normalizedId}`;
+    const folderName = `feature-${normalizedId}`;
+    const projectRoot = process.cwd();
+    const workspacesDir = join14(projectRoot, "workspaces");
+    const workspacePath = join14(workspacesDir, folderName);
+    if (options.dryRun) {
+      spinner.info("Dry run mode");
+      console.log("");
+      console.log(chalk19.bold("Would create:"));
+      console.log(`  Workspace: ${chalk19.cyan(workspacePath)}`);
+      console.log(`  Branch:    ${chalk19.cyan(branchName)}`);
+      console.log(`  CLAUDE.md: ${chalk19.dim(join14(workspacePath, "CLAUDE.md"))}`);
+      if (options.skills !== false) {
+        console.log(`  Skills:    ${chalk19.dim(join14(workspacePath, ".claude", "skills"))}`);
+      }
+      return;
+    }
+    if (existsSync16(workspacePath)) {
+      spinner.fail(`Workspace already exists: ${workspacePath}`);
+      process.exit(1);
+    }
+    if (!existsSync16(join14(projectRoot, ".git"))) {
+      spinner.fail("Not a git repository. Run this from the project root.");
+      process.exit(1);
+    }
+    spinner.text = "Creating git worktree...";
+    createWorktree(projectRoot, workspacePath, branchName);
+    spinner.text = "Generating CLAUDE.md...";
+    const variables = {
+      FEATURE_FOLDER: folderName,
+      BRANCH_NAME: branchName,
+      ISSUE_ID: issueId.toUpperCase(),
+      WORKSPACE_PATH: workspacePath,
+      FRONTEND_URL: `https://${folderName}.localhost:3000`,
+      API_URL: `https://api-${folderName}.localhost:8080`
+    };
+    const claudeMd = generateClaudeMd(projectRoot, variables);
+    writeFileSync9(join14(workspacePath, "CLAUDE.md"), claudeMd);
+    let skillsResult = { added: [], skipped: [] };
+    if (options.skills !== false) {
+      spinner.text = "Merging skills...";
+      mkdirSync9(join14(workspacePath, ".claude", "skills"), { recursive: true });
+      skillsResult = mergeSkillsIntoWorkspace(workspacePath);
+    }
+    spinner.succeed("Workspace created!");
+    console.log("");
+    console.log(chalk19.bold("Workspace Details:"));
+    console.log(`  Path:   ${chalk19.cyan(workspacePath)}`);
+    console.log(`  Branch: ${chalk19.dim(branchName)}`);
+    console.log("");
+    if (options.skills !== false) {
+      console.log(chalk19.bold("Skills:"));
+      console.log(`  Added:   ${skillsResult.added.length} Panopticon skills`);
+      if (skillsResult.skipped.length > 0) {
+        console.log(`  Skipped: ${chalk19.dim(skillsResult.skipped.join(", "))}`);
+      }
+      console.log("");
+    }
+    console.log(chalk19.dim(`Next: cd ${workspacePath}`));
+  } catch (error) {
+    spinner.fail(error.message);
+    process.exit(1);
+  }
+}
+async function listCommand2(options) {
+  const projectRoot = process.cwd();
+  if (!existsSync16(join14(projectRoot, ".git"))) {
+    console.error(chalk19.red("Not a git repository."));
+    process.exit(1);
+  }
+  const worktrees = listWorktrees(projectRoot);
+  const workspaces = worktrees.filter(
+    (w) => w.path.includes("/workspaces/") || w.path.includes("\\workspaces\\")
+  );
+  if (options.json) {
+    console.log(JSON.stringify(workspaces, null, 2));
+    return;
+  }
+  if (workspaces.length === 0) {
+    console.log(chalk19.dim("No workspaces found."));
+    console.log(chalk19.dim("Create one with: pan workspace create <issue-id>"));
+    return;
+  }
+  console.log(chalk19.bold("\nWorkspaces\n"));
+  for (const ws of workspaces) {
+    const name = basename2(ws.path);
+    const status = ws.prunable ? chalk19.yellow(" (prunable)") : "";
+    console.log(`${chalk19.cyan(name)}${status}`);
+    console.log(`  Branch: ${ws.branch || chalk19.dim("(detached)")}`);
+    console.log(`  Path:   ${chalk19.dim(ws.path)}`);
+    console.log("");
+  }
+}
+async function destroyCommand(issueId, options) {
+  const spinner = ora10("Destroying workspace...").start();
+  try {
+    const normalizedId = issueId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    const folderName = `feature-${normalizedId}`;
+    const projectRoot = process.cwd();
+    const workspacePath = join14(projectRoot, "workspaces", folderName);
+    if (!existsSync16(workspacePath)) {
+      spinner.fail(`Workspace not found: ${workspacePath}`);
+      process.exit(1);
+    }
+    spinner.text = "Removing git worktree...";
+    removeWorktree(projectRoot, workspacePath);
+    spinner.succeed(`Workspace destroyed: ${folderName}`);
+  } catch (error) {
+    spinner.fail(error.message);
+    if (!options.force) {
+      console.log(chalk19.dim("Tip: Use --force to remove even with uncommitted changes"));
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/install.ts
+import chalk20 from "chalk";
+import ora11 from "ora";
+import { execSync as execSync7 } from "child_process";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, readFileSync as readFileSync14 } from "fs";
+import { join as join15 } from "path";
+import { 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);
+}
+function detectPlatform() {
+  const os = platform();
+  if (os === "linux") {
+    try {
+      const release = readFileSync14("/proc/version", "utf8").toLowerCase();
+      if (release.includes("microsoft") || release.includes("wsl")) {
+        return "wsl";
+      }
+    } catch {
+    }
+    return "linux";
+  }
+  return os;
+}
+function checkCommand(cmd) {
+  try {
+    execSync7(`which ${cmd}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkPrerequisites() {
+  const results = [];
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0]);
+  results.push({
+    name: "Node.js",
+    passed: nodeMajor >= 18,
+    message: nodeMajor >= 18 ? `v${nodeVersion}` : `v${nodeVersion} (need v18+)`,
+    fix: "Install Node.js 18+ from https://nodejs.org"
+  });
+  const hasGit = checkCommand("git");
+  results.push({
+    name: "Git",
+    passed: hasGit,
+    message: hasGit ? "installed" : "not found",
+    fix: "Install git from your package manager"
+  });
+  const hasDocker = checkCommand("docker");
+  let dockerRunning = false;
+  if (hasDocker) {
+    try {
+      execSync7("docker info", { stdio: "pipe" });
+      dockerRunning = true;
+    } catch {
+    }
+  }
+  results.push({
+    name: "Docker",
+    passed: dockerRunning,
+    message: dockerRunning ? "running" : hasDocker ? "not running" : "not found",
+    fix: hasDocker ? "Start Docker Desktop or docker service" : "Install Docker"
+  });
+  const hasTmux = checkCommand("tmux");
+  results.push({
+    name: "tmux",
+    passed: hasTmux,
+    message: hasTmux ? "installed" : "not found",
+    fix: "apt install tmux / brew install tmux"
+  });
+  const hasMkcert = checkCommand("mkcert");
+  results.push({
+    name: "mkcert",
+    passed: hasMkcert,
+    message: hasMkcert ? "installed" : "not found (optional)",
+    fix: "brew install mkcert / apt install mkcert"
+  });
+  const hasBeads = checkCommand("bd");
+  results.push({
+    name: "Beads CLI (bd)",
+    passed: hasBeads,
+    message: hasBeads ? "installed" : "not found",
+    fix: "cargo install beads-cli"
+  });
+  return {
+    results,
+    allPassed: results.filter((r) => r.name !== "mkcert").every((r) => r.passed)
+  };
+}
+function printPrereqStatus(prereqs) {
+  console.log(chalk20.bold("Prerequisites:\n"));
+  for (const result of prereqs.results) {
+    const icon = result.passed ? chalk20.green("\u2713") : chalk20.red("\u2717");
+    const msg = result.passed ? chalk20.dim(result.message) : chalk20.yellow(result.message);
+    console.log(`  ${icon} ${result.name}: ${msg}`);
+    if (!result.passed && result.fix) {
+      console.log(`    ${chalk20.dim("\u2192 " + result.fix)}`);
+    }
+  }
+  console.log("");
+}
+async function installCommand(options) {
+  console.log(chalk20.bold("\nPanopticon Installation\n"));
+  const plat = detectPlatform();
+  console.log(`Platform: ${chalk20.cyan(plat)}
+`);
+  const prereqs = checkPrerequisites();
+  if (options.check) {
+    printPrereqStatus(prereqs);
+    process.exit(prereqs.allPassed ? 0 : 1);
+  }
+  printPrereqStatus(prereqs);
+  if (!prereqs.allPassed) {
+    console.log(chalk20.red("Fix prerequisites above before continuing."));
+    console.log(chalk20.dim("Tip: Run with --minimal to skip optional components"));
+    process.exit(1);
+  }
+  const spinner = ora11("Initializing Panopticon directories...").start();
+  for (const dir of INIT_DIRS) {
+    mkdirSync10(dir, { recursive: true });
+  }
+  spinner.succeed("Directories initialized");
+  if (!options.skipDocker) {
+    spinner.start("Creating Docker network...");
+    try {
+      execSync7("docker network create panopticon 2>/dev/null || true", { stdio: "pipe" });
+      spinner.succeed("Docker network ready");
+    } catch (error) {
+      spinner.warn("Docker network setup failed (may already exist)");
+    }
+  }
+  if (!options.skipMkcert && !options.minimal) {
+    const hasMkcert = checkCommand("mkcert");
+    if (hasMkcert) {
+      spinner.start("Setting up mkcert CA...");
+      try {
+        execSync7("mkcert -install", { stdio: "pipe" });
+        const certsDir = join15(PANOPTICON_HOME, "certs");
+        mkdirSync10(certsDir, { recursive: true });
+        execSync7(
+          `mkcert -cert-file "${join15(certsDir, "localhost.pem")}" -key-file "${join15(certsDir, "localhost-key.pem")}" localhost "*.localhost" 127.0.0.1 ::1`,
+          { stdio: "pipe" }
+        );
+        spinner.succeed("mkcert certificates generated");
+      } catch (error) {
+        spinner.warn("mkcert setup failed (HTTPS may not work)");
+      }
+    } else {
+      spinner.info("Skipping mkcert (not installed)");
+    }
+  }
+  const configFile = join15(PANOPTICON_HOME, "config.toml");
+  if (!existsSync17(configFile)) {
+    spinner.start("Creating default config...");
+    writeFileSync10(
+      configFile,
+      `# Panopticon configuration
+[panopticon]
+version = "1.0.0"
+default_runtime = "claude"
+
+[dashboard]
+port = 3001
+api_port = 3002
+
+[sync]
+auto_sync = true
+strategy = "symlink"
+
+[health]
+ping_timeout = "30s"
+consecutive_failures = 3
+`
+    );
+    spinner.succeed("Config created");
+  }
+  console.log("");
+  console.log(chalk20.green.bold("Installation complete!"));
+  console.log("");
+  console.log(chalk20.bold("Next steps:"));
+  console.log(`  1. Run ${chalk20.cyan("pan sync")} to sync skills to ~/.claude/`);
+  console.log(`  2. Run ${chalk20.cyan("pan up")} to start the dashboard`);
+  console.log(`  3. Create a workspace with ${chalk20.cyan("pan workspace create <issue-id>")}`);
+  console.log("");
+}
+
+// src/cli/commands/project.ts
+import chalk21 from "chalk";
+import { existsSync as existsSync18, readFileSync as readFileSync15, writeFileSync as writeFileSync11, mkdirSync as mkdirSync11 } from "fs";
+import { join as join16, resolve } from "path";
+var PROJECTS_FILE = join16(PANOPTICON_HOME, "projects.json");
+function loadProjects() {
+  if (!existsSync18(PROJECTS_FILE)) {
+    return [];
+  }
+  try {
+    return JSON.parse(readFileSync15(PROJECTS_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveProjects(projects) {
+  mkdirSync11(PANOPTICON_HOME, { recursive: true });
+  writeFileSync11(PROJECTS_FILE, JSON.stringify(projects, null, 2));
+}
+async function projectAddCommand(projectPath, options = {}) {
+  const fullPath = resolve(projectPath);
+  if (!existsSync18(fullPath)) {
+    console.log(chalk21.red(`Path does not exist: ${fullPath}`));
+    return;
+  }
+  const projects = loadProjects();
+  const existing = projects.find((p) => p.path === fullPath);
+  if (existing) {
+    console.log(chalk21.yellow(`Project already registered: ${existing.name}`));
+    return;
+  }
+  const name = options.name || fullPath.split("/").pop() || "unknown";
+  let linearTeam = options.linearTeam;
+  if (!linearTeam) {
+    const projectToml = join16(fullPath, ".panopticon", "project.toml");
+    if (existsSync18(projectToml)) {
+      const content = readFileSync15(projectToml, "utf-8");
+      const match = content.match(/team\s*=\s*"([^"]+)"/);
+      if (match) linearTeam = match[1];
+    }
+  }
+  const project2 = {
+    name,
+    path: fullPath,
+    type: options.type || "standalone",
+    linearTeam,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  projects.push(project2);
+  saveProjects(projects);
+  console.log(chalk21.green(`\u2713 Added project: ${name}`));
+  console.log(chalk21.dim(`  Path: ${fullPath}`));
+  if (linearTeam) {
+    console.log(chalk21.dim(`  Linear team: ${linearTeam}`));
+  }
+}
+async function projectListCommand(options = {}) {
+  const projects = loadProjects();
+  if (projects.length === 0) {
+    console.log(chalk21.dim("No projects registered."));
+    console.log(chalk21.dim("Add one with: pan project add <path>"));
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(projects, null, 2));
+    return;
+  }
+  console.log(chalk21.bold("\nRegistered Projects:\n"));
+  for (const project2 of projects) {
+    const exists = existsSync18(project2.path);
+    const statusIcon = exists ? chalk21.green("\u2713") : chalk21.red("\u2717");
+    console.log(`${statusIcon} ${chalk21.bold(project2.name)}`);
+    console.log(`  ${chalk21.dim(project2.path)}`);
+    if (project2.linearTeam) {
+      console.log(`  ${chalk21.cyan(`Linear: ${project2.linearTeam}`)}`);
+    }
+    console.log(`  ${chalk21.dim(`Type: ${project2.type}`)}`);
+    console.log("");
+  }
+}
+async function projectRemoveCommand(nameOrPath) {
+  const projects = loadProjects();
+  const index = projects.findIndex(
+    (p) => p.name === nameOrPath || p.path === resolve(nameOrPath)
+  );
+  if (index === -1) {
+    console.log(chalk21.red(`Project not found: ${nameOrPath}`));
+    return;
+  }
+  const removed = projects.splice(index, 1)[0];
+  saveProjects(projects);
+  console.log(chalk21.green(`\u2713 Removed project: ${removed.name}`));
+}
+
+// src/cli/commands/doctor.ts
+import chalk22 from "chalk";
+import { existsSync as existsSync19, readdirSync as readdirSync9 } from "fs";
+import { execSync as execSync8 } from "child_process";
+import { homedir as homedir6 } from "os";
+import { join as join17 } from "path";
+function checkCommand2(cmd) {
+  try {
+    execSync8(`which ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkDirectory(path) {
+  return existsSync19(path);
+}
+function countItems(path) {
+  if (!existsSync19(path)) return 0;
+  try {
+    return readdirSync9(path).length;
+  } catch {
+    return 0;
+  }
+}
+async function doctorCommand() {
+  console.log(chalk22.bold("\nPanopticon Doctor\n"));
+  console.log(chalk22.dim("Checking system health...\n"));
+  const checks = [];
+  const requiredCommands = [
+    { cmd: "git", name: "Git", fix: "Install git" },
+    { cmd: "tmux", name: "tmux", fix: "Install tmux: apt install tmux / brew install tmux" },
+    { cmd: "node", name: "Node.js", fix: "Install Node.js 18+" },
+    { cmd: "claude", name: "Claude CLI", fix: "Install: npm install -g @anthropic-ai/claude-code" }
+  ];
+  for (const { cmd, name, fix } of requiredCommands) {
+    if (checkCommand2(cmd)) {
+      checks.push({ name, status: "ok", message: "Installed" });
+    } else {
+      checks.push({ name, status: "error", message: "Not found", fix });
+    }
+  }
+  const optionalCommands = [
+    { cmd: "gh", name: "GitHub CLI", fix: "Install: gh auth login" },
+    { cmd: "bd", name: "Beads CLI", fix: "Install beads for task tracking" },
+    { cmd: "docker", name: "Docker", fix: "Install Docker for workspace containers" }
+  ];
+  for (const { cmd, name, fix } of optionalCommands) {
+    if (checkCommand2(cmd)) {
+      checks.push({ name, status: "ok", message: "Installed" });
+    } else {
+      checks.push({ name, status: "warn", message: "Not installed (optional)", fix });
+    }
+  }
+  const directories = [
+    { path: PANOPTICON_HOME, name: "Panopticon Home", fix: "Run: pan init" },
+    { path: SKILLS_DIR, name: "Skills Directory", fix: "Run: pan init" },
+    { path: COMMANDS_DIR, name: "Commands Directory", fix: "Run: pan init" },
+    { path: AGENTS_DIR, name: "Agents Directory", fix: "Run: pan init" }
+  ];
+  for (const { path, name, fix } of directories) {
+    if (checkDirectory(path)) {
+      const count = countItems(path);
+      checks.push({ name, status: "ok", message: `Exists (${count} items)` });
+    } else {
+      checks.push({ name, status: "error", message: "Missing", fix });
+    }
+  }
+  if (checkDirectory(CLAUDE_DIR)) {
+    const skillsCount = countItems(join17(CLAUDE_DIR, "skills"));
+    const commandsCount = countItems(join17(CLAUDE_DIR, "commands"));
+    checks.push({
+      name: "Claude Code Skills",
+      status: skillsCount > 0 ? "ok" : "warn",
+      message: `${skillsCount} skills`,
+      fix: skillsCount === 0 ? "Run: pan sync" : void 0
+    });
+    checks.push({
+      name: "Claude Code Commands",
+      status: commandsCount > 0 ? "ok" : "warn",
+      message: `${commandsCount} commands`,
+      fix: commandsCount === 0 ? "Run: pan sync" : void 0
+    });
+  } else {
+    checks.push({
+      name: "Claude Code Directory",
+      status: "warn",
+      message: "Not found",
+      fix: "Install Claude Code first"
+    });
+  }
+  const envFile = join17(homedir6(), ".panopticon.env");
+  if (existsSync19(envFile)) {
+    checks.push({ name: "Config File", status: "ok", message: "~/.panopticon.env exists" });
+  } else {
+    checks.push({
+      name: "Config File",
+      status: "warn",
+      message: "~/.panopticon.env not found",
+      fix: "Create ~/.panopticon.env with LINEAR_API_KEY=..."
+    });
+  }
+  if (process.env.LINEAR_API_KEY) {
+    checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in environment" });
+  } else if (existsSync19(envFile)) {
+    const content = __require("fs").readFileSync(envFile, "utf-8");
+    if (content.includes("LINEAR_API_KEY")) {
+      checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in config file" });
+    } else {
+      checks.push({
+        name: "LINEAR_API_KEY",
+        status: "warn",
+        message: "Not configured",
+        fix: "Add LINEAR_API_KEY to ~/.panopticon.env"
+      });
+    }
+  } else {
+    checks.push({
+      name: "LINEAR_API_KEY",
+      status: "warn",
+      message: "Not configured",
+      fix: "Set LINEAR_API_KEY environment variable or add to ~/.panopticon.env"
+    });
+  }
+  try {
+    const sessions = execSync8("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",
+      status: "ok",
+      message: `${agentSessions} agent sessions`
+    });
+  } catch {
+    checks.push({
+      name: "Running Agents",
+      status: "ok",
+      message: "0 agent sessions"
+    });
+  }
+  const icons = {
+    ok: chalk22.green("\u2713"),
+    warn: chalk22.yellow("\u26A0"),
+    error: chalk22.red("\u2717")
+  };
+  let hasErrors = false;
+  let hasWarnings = false;
+  for (const check of checks) {
+    const icon = icons[check.status];
+    const message = check.status === "error" ? chalk22.red(check.message) : check.status === "warn" ? chalk22.yellow(check.message) : chalk22.dim(check.message);
+    console.log(`${icon} ${check.name}: ${message}`);
+    if (check.fix && check.status !== "ok") {
+      console.log(chalk22.dim(`  Fix: ${check.fix}`));
+    }
+    if (check.status === "error") hasErrors = true;
+    if (check.status === "warn") hasWarnings = true;
+  }
+  console.log("");
+  if (hasErrors) {
+    console.log(chalk22.red("Some required components are missing."));
+    console.log(chalk22.dim("Fix the errors above before using Panopticon."));
+  } else if (hasWarnings) {
+    console.log(chalk22.yellow("System is functional with some optional features missing."));
+  } else {
+    console.log(chalk22.green("All systems operational!"));
+  }
+  console.log("");
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("pan").description("Multi-agent orchestration for AI coding assistants").version("0.1.0");
+program.command("init").description("Initialize Panopticon (~/.panopticon/)").action(initCommand);
+program.command("sync").description("Sync skills/commands to AI tools").option("--dry-run", "Show what would be synced").option("--force", "Overwrite without prompts").option("--backup-only", "Only create backup").action(syncCommand);
+program.command("restore [timestamp]").description("Restore from backup").action(restoreCommand);
+program.command("skills").description("List and manage skills").option("--json", "Output as JSON").action(skillsCommand);
+registerWorkCommands(program);
+registerWorkspaceCommands(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").option("--detach", "Run in background").action(async (options) => {
+  const { spawn, execSync: execSync9 } = await import("child_process");
+  const { join: join18, dirname: dirname2 } = await import("path");
+  const { fileURLToPath } = await import("url");
+  const __dirname2 = dirname2(fileURLToPath(import.meta.url));
+  const dashboardDir = join18(__dirname2, "..", "dashboard");
+  console.log(chalk23.bold("Starting Panopticon dashboard...\n"));
+  if (options.detach) {
+    const child = spawn("npm", ["run", "dev"], {
+      cwd: dashboardDir,
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    console.log(chalk23.green("Dashboard started in background"));
+    console.log(`Frontend: ${chalk23.cyan("http://localhost:3001")}`);
+    console.log(`API:      ${chalk23.cyan("http://localhost:3002")}`);
+  } else {
+    console.log(`Frontend: ${chalk23.cyan("http://localhost:3001")}`);
+    console.log(`API:      ${chalk23.cyan("http://localhost:3002")}`);
+    console.log(chalk23.dim("\nPress Ctrl+C to stop\n"));
+    const child = spawn("npm", ["run", "dev"], {
+      cwd: dashboardDir,
+      stdio: "inherit"
+    });
+    child.on("error", (err) => {
+      console.error(chalk23.red("Failed to start dashboard:"), err.message);
+      process.exit(1);
+    });
+  }
+});
+program.command("down").description("Stop dashboard").action(async () => {
+  const { execSync: execSync9 } = await import("child_process");
+  try {
+    execSync9("lsof -ti:3001 | xargs kill -9 2>/dev/null || true", { stdio: "pipe" });
+    execSync9("lsof -ti:3002 | xargs kill -9 2>/dev/null || true", { stdio: "pipe" });
+    console.log(chalk23.green("Dashboard stopped"));
+  } catch {
+    console.log(chalk23.dim("No dashboard processes found"));
+  }
+});
+var project = program.command("project").description("Project management");
+project.command("add <path>").description("Register a project with Panopticon").option("--name <name>", "Project name").option("--type <type>", "Project type (standalone/monorepo)", "standalone").option("--linear-team <team>", "Linear team prefix").action(projectAddCommand);
+project.command("list").description("List all managed projects").option("--json", "Output as JSON").action(projectListCommand);
+project.command("remove <nameOrPath>").description("Remove a project from Panopticon").action(projectRemoveCommand);
+program.command("doctor").description("Check system health and dependencies").action(doctorCommand);
+program.parse();
+//# sourceMappingURL=index.js.map