panopticon-cli 0.1.3 → 0.1.6

package/dist/cli/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   AGENTS_DIR,
+  CERTS_DIR,
   CLAUDE_DIR,
   CLAUDE_MD_TEMPLATES,
   COMMANDS_DIR,
@@ -8,10 +9,16 @@ import {
   INIT_DIRS,
   PANOPTICON_HOME,
   SKILLS_DIR,
+  SOURCE_TRAEFIK_TEMPLATES,
   SYNC_TARGETS,
+  TRAEFIK_CERTS_DIR,
+  TRAEFIK_DIR,
+  __commonJS,
   __require,
   addAlias,
+  cleanOldBackups,
   createBackup,
+  createTracker,
   detectShell,
   executeSync,
   getAliasInstructions,
@@ -22,22 +29,122 @@ import {
   planSync,
   restoreBackup,
   saveConfig
-} from "../chunk-FR2P66GU.js";
+} from "../chunk-RM3WGTFO.js";
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "panopticon-cli",
+      version: "0.1.6",
+      description: "Multi-agent orchestration for AI coding assistants (Claude Code, Codex, Cursor, Gemini CLI)",
+      keywords: [
+        "ai-agents",
+        "orchestration",
+        "claude-code",
+        "codex",
+        "cursor",
+        "gemini",
+        "multi-agent",
+        "devtools",
+        "linear"
+      ],
+      author: "Edward Becker <edward.becker@mindyournow.com>",
+      license: "MIT",
+      repository: {
+        type: "git",
+        url: "https://github.com/eltmon/panopticon-cli.git"
+      },
+      homepage: "https://github.com/eltmon/panopticon-cli#readme",
+      bugs: {
+        url: "https://github.com/eltmon/panopticon-cli/issues"
+      },
+      type: "module",
+      bin: {
+        pan: "./dist/cli/index.js",
+        panopticon: "./dist/cli/index.js"
+      },
+      main: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      files: [
+        "dist",
+        "templates",
+        "README.md",
+        "LICENSE"
+      ],
+      engines: {
+        node: ">=18.0.0"
+      },
+      scripts: {
+        dev: "tsx watch src/cli/index.ts",
+        build: "tsup",
+        typecheck: "tsc --noEmit",
+        lint: "eslint src/",
+        test: "vitest",
+        prepublishOnly: "npm run build"
+      },
+      dependencies: {
+        "@iarna/toml": "^2.2.5",
+        "@linear/sdk": "^70.0.0",
+        "@octokit/rest": "^22.0.1",
+        chalk: "^5.6.2",
+        commander: "^12.1.0",
+        conf: "^12.0.0",
+        execa: "^8.0.1",
+        inquirer: "^9.3.8",
+        ora: "^8.2.0"
+      },
+      devDependencies: {
+        "@types/inquirer": "^9.0.9",
+        "@types/node": "^20.10.0",
+        eslint: "^8.55.0",
+        tsup: "^8.0.1",
+        tsx: "^4.6.2",
+        typescript: "^5.3.2",
+        vitest: "^1.0.4"
+      }
+    };
+  }
+});
 
 // src/cli/index.ts
 import { Command } from "commander";
-import chalk23 from "chalk";
+import chalk25 from "chalk";
 
 // src/cli/commands/init.ts
-import { existsSync, mkdirSync } from "fs";
+import { existsSync, mkdirSync, readdirSync, cpSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 import chalk from "chalk";
 import ora from "ora";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var PACKAGE_ROOT = join(__dirname, "..", "..");
+var BUNDLED_SKILLS_DIR = join(PACKAGE_ROOT, "skills");
+function copyBundledSkills() {
+  if (!existsSync(BUNDLED_SKILLS_DIR)) {
+    return 0;
+  }
+  if (!existsSync(SKILLS_DIR)) {
+    mkdirSync(SKILLS_DIR, { recursive: true });
+  }
+  const skills = readdirSync(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  let copied = 0;
+  for (const skill of skills) {
+    const sourcePath = join(BUNDLED_SKILLS_DIR, skill.name);
+    const targetPath = join(SKILLS_DIR, skill.name);
+    cpSync(sourcePath, targetPath, { recursive: true });
+    copied++;
+  }
+  return copied;
+}
 async function initCommand() {
   const spinner = ora("Initializing Panopticon...").start();
   if (existsSync(CONFIG_FILE)) {
     spinner.info("Panopticon already initialized");
     console.log(chalk.dim(`  Config: ${CONFIG_FILE}`));
     console.log(chalk.dim(`  Home: ${PANOPTICON_HOME}`));
+    console.log(chalk.dim("  Run `pan sync` to update skills"));
     return;
   }
   try {
@@ -50,6 +157,8 @@ async function initCommand() {
     const config = getDefaultConfig();
     saveConfig(config);
     spinner.text = "Created config...";
+    spinner.text = "Installing bundled skills...";
+    const skillsCopied = copyBundledSkills();
     const shell = detectShell();
     const rcFile = getShellRcFile(shell);
     if (rcFile && existsSync(rcFile)) {
@@ -58,19 +167,25 @@ async function initCommand() {
       console.log("");
       console.log(chalk.green("\u2713") + " Created " + chalk.cyan(PANOPTICON_HOME));
       console.log(chalk.green("\u2713") + " Created " + chalk.cyan(CONFIG_FILE));
+      if (skillsCopied > 0) {
+        console.log(chalk.green("\u2713") + ` Installed ${skillsCopied} bundled skills`);
+      }
       console.log(chalk.green("\u2713") + " " + getAliasInstructions(shell));
     } else {
       spinner.succeed("Panopticon initialized!");
       console.log("");
       console.log(chalk.green("\u2713") + " Created " + chalk.cyan(PANOPTICON_HOME));
       console.log(chalk.green("\u2713") + " Created " + chalk.cyan(CONFIG_FILE));
+      if (skillsCopied > 0) {
+        console.log(chalk.green("\u2713") + ` Installed ${skillsCopied} bundled skills`);
+      }
       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"));
+    console.log(chalk.dim("  1. Run: pan sync"));
+    console.log(chalk.dim("  2. Start dashboard: pan up"));
   } catch (error) {
     spinner.fail("Failed to initialize");
     console.error(chalk.red(error.message));
@@ -119,9 +234,9 @@ async function syncCommand(options) {
       SYNC_TARGETS[r].skills,
       SYNC_TARGETS[r].commands
     ]);
-    const backup = createBackup(backupDirs);
-    if (backup.targets.length > 0) {
-      spinner2.succeed(`Backup created: ${backup.timestamp}`);
+    const backup2 = createBackup(backupDirs);
+    if (backup2.targets.length > 0) {
+      spinner2.succeed(`Backup created: ${backup2.timestamp}`);
     } else {
       spinner2.info("No existing content to backup");
     }
@@ -166,8 +281,8 @@ async function restoreCommand(timestamp) {
   }
   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(", ")}`);
+    for (const backup2 of backups.slice(0, 10)) {
+      console.log(`  ${chalk3.cyan(backup2.timestamp)} - ${backup2.targets.join(", ")}`);
     }
     if (backups.length > 10) {
       console.log(chalk3.dim(`  ... and ${backups.length - 10} more`));
@@ -218,10 +333,42 @@ async function restoreCommand(timestamp) {
   }
 }
 
-// src/cli/commands/skills.ts
-import { readdirSync, readFileSync, existsSync as existsSync2 } from "fs";
-import { join } from "path";
+// src/cli/commands/backup.ts
 import chalk4 from "chalk";
+async function backupListCommand(options) {
+  const backups = listBackups();
+  if (options.json) {
+    console.log(JSON.stringify(backups, null, 2));
+    return;
+  }
+  if (backups.length === 0) {
+    console.log(chalk4.dim("No backups found."));
+    console.log(chalk4.dim("Backups are created automatically during sync."));
+    return;
+  }
+  console.log(chalk4.bold("Backups:\n"));
+  for (const backup2 of backups) {
+    console.log(`  ${chalk4.cyan(backup2.timestamp)}`);
+    console.log(`    ${chalk4.dim("Contains:")} ${backup2.targets.join(", ")}`);
+  }
+  console.log();
+  console.log(chalk4.dim(`Total: ${backups.length} backups`));
+  console.log(chalk4.dim("Use `pan restore <timestamp>` to restore a backup."));
+}
+async function backupCleanCommand(options) {
+  const keepCount = parseInt(options.keep || "10", 10);
+  const removed = cleanOldBackups(keepCount);
+  if (removed === 0) {
+    console.log(chalk4.dim(`No backups removed (keeping ${keepCount}).`));
+  } else {
+    console.log(chalk4.green(`Removed ${removed} old backup(s), keeping ${keepCount}.`));
+  }
+}
+
+// src/cli/commands/skills.ts
+import { readdirSync as readdirSync2, readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import chalk5 from "chalk";
 function parseSkillFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return {};
@@ -233,9 +380,9 @@ function parseSkillFrontmatter(content) {
 function listSkills() {
   if (!existsSync2(SKILLS_DIR)) return [];
   const skills = [];
-  const dirs = readdirSync(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  const dirs = readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
   for (const dir of dirs) {
-    const skillFile = join(SKILLS_DIR, dir.name, "SKILL.md");
+    const skillFile = join2(SKILLS_DIR, dir.name, "SKILL.md");
     if (!existsSync2(skillFile)) continue;
     const content = readFileSync(skillFile, "utf8");
     const { name, description } = parseSkillFrontmatter(content);
@@ -253,29 +400,32 @@ async function skillsCommand(options) {
     console.log(JSON.stringify(skills, null, 2));
     return;
   }
-  console.log(chalk4.bold(`
+  console.log(chalk5.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"));
+    console.log(chalk5.yellow("No skills found."));
+    console.log(chalk5.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(chalk5.cyan(skill.name));
+    console.log(chalk5.dim(`  ${skill.description}`));
   }
   console.log(`
-${chalk4.dim('Run "pan sync" to sync skills to Claude Code')}`);
+${chalk5.dim('Run "pan sync" to sync skills to Claude Code')}`);
 }
 
 // src/cli/commands/work/issue.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import ora4 from "ora";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join6, dirname as dirname2 } from "path";
 
 // src/lib/agents.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, readFileSync as readFileSync4, readdirSync as readdirSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, readFileSync as readFileSync4, readdirSync as readdirSync5 } from "fs";
+import { join as join5 } from "path";
+import { execSync as execSync2 } from "child_process";
 
 // src/lib/tmux.ts
 import { execSync } from "child_process";
@@ -307,8 +457,20 @@ function sessionExists(name) {
 }
 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);
+  if (initialCommand && (initialCommand.includes("`") || initialCommand.includes("\n") || initialCommand.length > 500)) {
+    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"`);
+    execSync("sleep 0.5");
+    const tmpFile = `/tmp/pan-cmd-${name}.sh`;
+    const fs = __require("fs");
+    fs.writeFileSync(tmpFile, initialCommand);
+    fs.chmodSync(tmpFile, "755");
+    execSync(`tmux send-keys -t ${name} "bash ${tmpFile}" Enter`);
+  } else if (initialCommand) {
+    const cmd = `tmux new-session -d -s ${name} -c "${escapedCwd}" "${initialCommand.replace(/"/g, '\\"')}"`;
+    execSync(cmd);
+  } else {
+    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"`);
+  }
 }
 function killSession(name) {
   execSync(`tmux kill-session -t ${name}`);
@@ -323,16 +485,16 @@ function getAgentSessions() {
 }
 
 // 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";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync, readdirSync as readdirSync3, unlinkSync } from "fs";
+import { join as join3 } from "path";
 function getHookDir(agentId) {
-  return join2(AGENTS_DIR, agentId);
+  return join3(AGENTS_DIR, agentId);
 }
 function getHookFile(agentId) {
-  return join2(getHookDir(agentId), "hook.json");
+  return join3(getHookDir(agentId), "hook.json");
 }
 function getMailDir(agentId) {
-  return join2(getHookDir(agentId), "mail");
+  return join3(getHookDir(agentId), "mail");
 }
 function initHook(agentId) {
   const hookDir = getHookDir(agentId);
@@ -377,11 +539,11 @@ function checkHook(agentId) {
   if (!hook || hook.items.length === 0) {
     const mailDir = getMailDir(agentId);
     if (existsSync3(mailDir)) {
-      const mails = readdirSync2(mailDir).filter((f) => f.endsWith(".json"));
+      const mails = readdirSync3(mailDir).filter((f) => f.endsWith(".json"));
       if (mails.length > 0) {
         const mailItems = mails.map((file) => {
           try {
-            const content = readFileSync2(join2(mailDir, file), "utf-8");
+            const content = readFileSync2(join3(mailDir, file), "utf-8");
             return JSON.parse(content);
           } catch {
             return null;
@@ -440,7 +602,7 @@ function sendMail(toAgentId, from, message, priority = "normal") {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writeFileSync(
-    join2(mailDir, `${mailItem.id}.json`),
+    join3(mailDir, `${mailItem.id}.json`),
     JSON.stringify(mailItem, null, 2)
   );
 }
@@ -487,10 +649,10 @@ function generateGUPPPrompt(agentId) {
 }
 
 // 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";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, readdirSync as readdirSync4 } from "fs";
+import { join as join4 } from "path";
 function getCVFile(agentId) {
-  return join3(AGENTS_DIR, agentId, "cv.json");
+  return join4(AGENTS_DIR, agentId, "cv.json");
 }
 function getAgentCV(agentId) {
   const cvFile = getCVFile(agentId);
@@ -521,7 +683,7 @@ function getAgentCV(agentId) {
   return cv;
 }
 function saveAgentCV(cv) {
-  const dir = join3(AGENTS_DIR, cv.agentId);
+  const dir = join4(AGENTS_DIR, cv.agentId);
   mkdirSync3(dir, { recursive: true });
   writeFileSync2(getCVFile(cv.agentId), JSON.stringify(cv, null, 2));
 }
@@ -551,7 +713,7 @@ function startWork(agentId, issueId, skills) {
 function getAgentRankings() {
   const rankings = [];
   if (!existsSync4(AGENTS_DIR)) return rankings;
-  const dirs = readdirSync3(AGENTS_DIR, { withFileTypes: true }).filter(
+  const dirs = readdirSync4(AGENTS_DIR, { withFileTypes: true }).filter(
     (d) => d.isDirectory()
   );
   for (const dir of dirs) {
@@ -620,10 +782,10 @@ function formatCV(cv) {
 
 // src/lib/agents.ts
 function getAgentDir(agentId) {
-  return join4(AGENTS_DIR, agentId);
+  return join5(AGENTS_DIR, agentId);
 }
 function getAgentState(agentId) {
-  const stateFile = join4(getAgentDir(agentId), "state.json");
+  const stateFile = join5(getAgentDir(agentId), "state.json");
   if (!existsSync5(stateFile)) return null;
   const content = readFileSync4(stateFile, "utf8");
   return JSON.parse(content);
@@ -632,7 +794,7 @@ function saveAgentState(state) {
   const dir = getAgentDir(state.id);
   mkdirSync4(dir, { recursive: true });
   writeFileSync3(
-    join4(dir, "state.json"),
+    join5(dir, "state.json"),
     JSON.stringify(state, null, 2)
   );
 }
@@ -660,8 +822,34 @@ function spawnAgent(options) {
       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}`;
+  const promptFile = join5(getAgentDir(agentId), "initial-prompt.md");
+  if (prompt) {
+    writeFileSync3(promptFile, prompt);
+  }
+  const claudeCmd = `claude --dangerously-skip-permissions --model ${state.model}`;
   createSession(agentId, options.workspace, claudeCmd);
+  if (prompt) {
+    let ready = false;
+    for (let i = 0; i < 15; i++) {
+      execSync2("sleep 1");
+      try {
+        const pane = execSync2(`tmux capture-pane -t ${agentId} -p`, { encoding: "utf-8" });
+        if (pane.includes("\u276F") || pane.includes(">")) {
+          ready = true;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (ready) {
+      execSync2(`tmux load-buffer "${promptFile}"`);
+      execSync2(`tmux paste-buffer -t ${agentId}`);
+      execSync2("sleep 0.5");
+      execSync2(`tmux send-keys -t ${agentId} Enter`);
+    } else {
+      console.error("Claude did not become ready in time, prompt not sent");
+    }
+  }
   state.status = "running";
   saveAgentState(state);
   startWork(agentId, options.issueId);
@@ -672,7 +860,7 @@ function listRunningAgents() {
   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());
+  const dirs = readdirSync5(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
   for (const dir of dirs) {
     const state = getAgentState(dir.name);
     if (state) {
@@ -701,11 +889,11 @@ function messageAgent(agentId, message) {
     throw new Error(`Agent ${normalizedId} not running`);
   }
   sendKeys(normalizedId, message);
-  const mailDir = join4(getAgentDir(normalizedId), "mail");
+  const mailDir = join5(getAgentDir(normalizedId), "mail");
   mkdirSync4(mailDir, { recursive: true });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   writeFileSync3(
-    join4(mailDir, `${timestamp}.md`),
+    join5(mailDir, `${timestamp}.md`),
     `# Message
 
 ${message}
@@ -727,7 +915,7 @@ function recoverAgent(agentId) {
   if (sessionExists(normalizedId)) {
     return state;
   }
-  const healthFile = join4(getAgentDir(normalizedId), "health.json");
+  const healthFile = join5(getAgentDir(normalizedId), "health.json");
   let health = { consecutiveFailures: 0, killCount: 0, recoveryCount: 0 };
   if (existsSync5(healthFile)) {
     try {
@@ -738,7 +926,7 @@ function recoverAgent(agentId) {
   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")}"`;
+  const claudeCmd = `claude --dangerously-skip-permissions --model ${state.model} "${recoveryPrompt.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
   createSession(normalizedId, state.workspace, claudeCmd);
   state.status = "running";
   state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
@@ -797,37 +985,203 @@ function autoRecoverAgents() {
 }
 
 // src/cli/commands/work/issue.ts
+function findWorkspace(issueId) {
+  const normalizedId = issueId.toLowerCase();
+  let dir = process.cwd();
+  for (let i = 0; i < 10; i++) {
+    const workspacesDir = join6(dir, "workspaces");
+    if (existsSync6(workspacesDir)) {
+      const workspaceName = `feature-${normalizedId}`;
+      const workspacePath = join6(workspacesDir, workspaceName);
+      if (existsSync6(workspacePath)) {
+        return workspacePath;
+      }
+      const altPath = join6(workspacesDir, normalizedId);
+      if (existsSync6(altPath)) {
+        return altPath;
+      }
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function findProjectRoot() {
+  let dir = process.cwd();
+  for (let i = 0; i < 10; i++) {
+    if (existsSync6(join6(dir, "workspaces")) || existsSync6(join6(dir, ".git")) || existsSync6(join6(dir, "CLAUDE.md"))) {
+      return dir;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+function readPlanningContext(workspacePath) {
+  const statePath = join6(workspacePath, ".planning", "STATE.md");
+  if (existsSync6(statePath)) {
+    return readFileSync5(statePath, "utf-8");
+  }
+  return null;
+}
+function extractBeadsIdsFromState(stateContent) {
+  const ids = [];
+  const backtickMatches = stateContent.match(/`([a-z]+-[a-z0-9]+)`/g) || [];
+  for (const match of backtickMatches) {
+    const id = match.replace(/`/g, "");
+    if (id.match(/^[a-z]+-[a-z0-9]{2,4}$/)) {
+      ids.push(id);
+    }
+  }
+  return [...new Set(ids)];
+}
+function readBeadsTasks(workspacePath, projectRoot, issueId) {
+  const tasks = [];
+  const normalizedId = issueId.toLowerCase();
+  const stateContent = readPlanningContext(workspacePath);
+  const beadsIds = stateContent ? extractBeadsIdsFromState(stateContent) : [];
+  const beadsPaths = [
+    join6(workspacePath, ".beads", "issues.jsonl"),
+    join6(projectRoot, ".beads", "issues.jsonl")
+  ];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const beadsPath of beadsPaths) {
+    if (!existsSync6(beadsPath)) continue;
+    try {
+      const content = readFileSync5(beadsPath, "utf-8");
+      const lines = content.split("\n").filter((line) => line.trim());
+      for (const line of lines) {
+        try {
+          const task = JSON.parse(line);
+          if (seenIds.has(task.id)) continue;
+          const tags = task.tags || [];
+          const isMatch = beadsIds.includes(task.id) || tags.some((t) => t.toLowerCase().includes(normalizedId)) || task.title?.toLowerCase().includes(normalizedId);
+          if (isMatch) {
+            seenIds.add(task.id);
+            tasks.push(`- [${task.status || "open"}] ${task.title} (${task.id})`);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return tasks;
+}
+function buildAgentPrompt(issueId, workspacePath, projectRoot) {
+  const lines = [
+    `# Working on Issue: ${issueId}`,
+    "",
+    `**Workspace:** ${workspacePath}`,
+    ""
+  ];
+  const hasStateFile = existsSync6(join6(workspacePath, ".planning", "STATE.md"));
+  const hasClaudeMd = existsSync6(join6(workspacePath, "CLAUDE.md"));
+  const hasProjectClaudeMd = existsSync6(join6(projectRoot, "CLAUDE.md"));
+  lines.push("## IMPORTANT: Read Context Files First");
+  lines.push("");
+  lines.push("Before starting any work, you MUST read these files to understand the full context:");
+  lines.push("");
+  if (hasStateFile) {
+    lines.push(`1. **Read \`.planning/STATE.md\`** - Contains the full planning context, decisions made, and current status for this issue.`);
+  }
+  if (hasClaudeMd) {
+    lines.push(`2. **Read \`CLAUDE.md\`** (in workspace) - Contains workspace-specific instructions and warnings.`);
+  }
+  if (hasProjectClaudeMd && projectRoot !== workspacePath) {
+    lines.push(`3. **Read \`${projectRoot}/CLAUDE.md\`** - Contains project-wide development guidelines.`);
+  }
+  lines.push("");
+  lines.push("These files contain critical context that may have been updated since the last session.");
+  lines.push("");
+  const beadsTasks = readBeadsTasks(workspacePath, projectRoot, issueId);
+  if (beadsTasks.length > 0) {
+    lines.push("## Beads Tasks");
+    lines.push("");
+    lines.push("Tasks created during planning (check STATE.md for which are complete):");
+    lines.push("");
+    lines.push(beadsTasks.join("\n"));
+    lines.push("");
+    lines.push("Use `bd show <task-id>` to see task details, `bd update <task-id> --status in_progress` to start work.");
+    lines.push("");
+  }
+  lines.push("## Your Task");
+  lines.push("");
+  lines.push("1. Read the context files listed above");
+  lines.push("2. Check STATE.md for current status and what work remains");
+  lines.push("3. Continue implementing the planned work");
+  lines.push("4. Mark beads tasks as complete as you finish them: `bd update <task-id> --status closed`");
+  lines.push("");
+  lines.push("## CRITICAL: Keep STATE.md Updated");
+  lines.push("");
+  lines.push("**You may be interrupted, crash, or be stopped at any time.** To ensure the next agent can continue:");
+  lines.push("");
+  lines.push("1. **Update `.planning/STATE.md` frequently** as you complete work");
+  lines.push('2. After completing each task or significant milestone, update the "Current Status" section');
+  lines.push("3. Document any decisions made or blockers encountered");
+  lines.push('4. Keep the "Remaining Work" section accurate');
+  lines.push("");
+  lines.push("The next agent will read STATE.md to know exactly where to pick up. Beads tasks track individual items,");
+  lines.push("but STATE.md provides the narrative context and current state that beads alone cannot capture.");
+  lines.push("");
+  return lines.join("\n");
+}
 async function issueCommand(id, options) {
   const spinner = ora4(`Preparing workspace for ${id}...`).start();
   try {
     const normalizedId = id.toLowerCase();
-    const workspace = process.cwd();
+    const projectRoot = findProjectRoot();
+    let workspace = findWorkspace(id);
+    if (!workspace) {
+      spinner.warn(`No workspace found for ${id}, using project root`);
+      workspace = projectRoot;
+    } else {
+      spinner.text = `Found workspace: ${workspace}`;
+    }
     if (options.dryRun) {
       spinner.info("Dry run mode");
       console.log("");
-      console.log(chalk5.bold("Would create:"));
+      console.log(chalk6.bold("Would create:"));
       console.log(`  Agent ID:   agent-${normalizedId}`);
       console.log(`  Workspace:  ${workspace}`);
       console.log(`  Runtime:    ${options.runtime}`);
       console.log(`  Model:      ${options.model}`);
+      const planningContext2 = readPlanningContext(workspace);
+      const beadsTasks2 = readBeadsTasks(workspace, projectRoot, id);
+      console.log("");
+      console.log(chalk6.bold("Context:"));
+      console.log(`  Planning:   ${planningContext2 ? "Found (.planning/STATE.md)" : "None"}`);
+      console.log(`  Beads:      ${beadsTasks2.length} tasks`);
       return;
     }
+    spinner.text = "Building agent prompt with planning context...";
+    const prompt = buildAgentPrompt(id, workspace, projectRoot);
     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}`
+      prompt
     });
     spinner.succeed(`Agent spawned: ${agent.id}`);
     console.log("");
-    console.log(chalk5.bold("Agent Details:"));
-    console.log(`  Session:    ${chalk5.cyan(agent.id)}`);
+    console.log(chalk6.bold("Agent Details:"));
+    console.log(`  Session:    ${chalk6.cyan(agent.id)}`);
     console.log(`  Workspace:  ${workspace}`);
     console.log(`  Runtime:    ${agent.runtime} (${agent.model})`);
+    const planningContext = readPlanningContext(workspace);
+    const beadsTasks = readBeadsTasks(workspace, projectRoot, id);
+    if (planningContext || beadsTasks.length > 0) {
+      console.log("");
+      console.log(chalk6.bold("Context Loaded:"));
+      if (planningContext) console.log(`  Planning:   ${chalk6.green("\u2713")} STATE.md`);
+      if (beadsTasks.length > 0) console.log(`  Beads:      ${chalk6.green("\u2713")} ${beadsTasks.length} tasks`);
+    }
     console.log("");
-    console.log(chalk5.dim("Commands:"));
+    console.log(chalk6.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}`);
@@ -838,7 +1192,7 @@ async function issueCommand(id, options) {
 }
 
 // src/cli/commands/work/status.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 async function statusCommand(options) {
   const agents = listRunningAgents();
   if (options.json) {
@@ -846,101 +1200,101 @@ async function statusCommand(options) {
     return;
   }
   if (agents.length === 0) {
-    console.log(chalk6.dim("No running agents."));
-    console.log(chalk6.dim('Use "pan work issue <id>" to spawn one.'));
+    console.log(chalk7.dim("No running agents."));
+    console.log(chalk7.dim('Use "pan work issue <id>" to spawn one.'));
     return;
   }
-  console.log(chalk6.bold("\nRunning Agents\n"));
+  console.log(chalk7.bold("\nRunning Agents\n"));
   for (const agent of agents) {
-    const statusColor = agent.tmuxActive ? chalk6.green : chalk6.red;
+    const statusColor = agent.tmuxActive ? chalk7.green : chalk7.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(`${chalk7.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(`  Workspace: ${chalk7.dim(agent.workspace)}`);
     console.log("");
   }
 }
 
 // src/cli/commands/work/tell.ts
-import chalk7 from "chalk";
+import chalk8 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}"`));
+    console.log(chalk8.green("Message sent to " + agentId));
+    console.log(chalk8.dim(`  "${message}"`));
   } catch (error) {
-    console.error(chalk7.red("Error: " + error.message));
+    console.error(chalk8.red("Error: " + error.message));
     process.exit(1);
   }
 }
 
 // src/cli/commands/work/kill.ts
-import chalk8 from "chalk";
+import chalk9 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.`));
+    console.log(chalk9.yellow(`Agent ${agentId} not found.`));
     return;
   }
   if (!options.force && isRunning) {
   }
   try {
     stopAgent(agentId);
-    console.log(chalk8.green(`Killed agent: ${agentId}`));
+    console.log(chalk9.green(`Killed agent: ${agentId}`));
   } catch (error) {
-    console.error(chalk8.red("Error: " + error.message));
+    console.error(chalk9.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";
+import chalk10 from "chalk";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } 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."));
+    console.log(chalk10.dim("No pending reviews."));
+    console.log(chalk10.dim("Agents will appear here when they complete work."));
     return;
   }
-  console.log(chalk9.bold("\nPending Reviews\n"));
+  console.log(chalk10.bold("\nPending Reviews\n"));
   for (const agent of agents) {
-    console.log(`${chalk9.cyan(agent.issueId)}`);
+    console.log(`${chalk10.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");
+    console.log(`  Workspace: ${chalk10.dim(agent.workspace)}`);
+    const completionFile = join7(AGENTS_DIR, agent.id, "completion.md");
+    if (existsSync7(completionFile)) {
+      const content = readFileSync6(completionFile, "utf8");
       const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"));
       if (firstLine) {
-        console.log(`  Summary:   ${chalk9.dim(firstLine.trim())}`);
+        console.log(`  Summary:   ${chalk10.dim(firstLine.trim())}`);
       }
     }
     console.log("");
   }
-  console.log(chalk9.dim('Run "pan work approve <id>" to approve and merge.'));
+  console.log(chalk10.dim('Run "pan work approve <id>" to approve and merge.'));
 }
 
 // src/cli/commands/work/approve.ts
-import chalk10 from "chalk";
+import chalk11 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 { existsSync as existsSync8, writeFileSync as writeFileSync4, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
 import { homedir } from "os";
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function getLinearApiKey() {
-  const envFile = join6(homedir(), ".panopticon.env");
-  if (existsSync7(envFile)) {
-    const content = readFileSync6(envFile, "utf-8");
+  const envFile = join8(homedir(), ".panopticon.env");
+  if (existsSync8(envFile)) {
+    const content = readFileSync7(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -948,7 +1302,7 @@ function getLinearApiKey() {
 }
 function checkGhCli() {
   try {
-    execSync2("which gh", { stdio: "pipe" });
+    execSync3("which gh", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -956,12 +1310,12 @@ function checkGhCli() {
 }
 function findPRForBranch(workspace) {
   try {
-    const branch = execSync2("git rev-parse --abbrev-ref HEAD", {
+    const branch = execSync3("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`, {
+    const prJson = execSync3(`gh pr list --head "${branch}" --json number,url --limit 1`, {
       cwd: workspace,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -977,7 +1331,7 @@ function findPRForBranch(workspace) {
 }
 function mergePR(workspace, prNumber) {
   try {
-    execSync2(`gh pr merge ${prNumber} --squash --delete-branch`, {
+    execSync3(`gh pr merge ${prNumber} --squash --delete-branch`, {
       cwd: workspace,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -1013,8 +1367,8 @@ 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.'));
+    console.log(chalk11.yellow(`Agent ${agentId} not found.`));
+    console.log(chalk11.dim('Run "pan work status" to see running agents.'));
     return;
   }
   const spinner = ora5("Approving work...").start();
@@ -1025,7 +1379,7 @@ async function approveCommand(id, options = {}) {
     if (options.merge !== false) {
       if (!checkGhCli()) {
         spinner.warn("gh CLI not found - skipping PR merge");
-        console.log(chalk10.dim("  Install: https://cli.github.com/"));
+        console.log(chalk11.dim("  Install: https://cli.github.com/"));
       } else {
         spinner.text = "Looking for PR...";
         const pr = findPRForBranch(workspace);
@@ -1034,13 +1388,13 @@ async function approveCommand(id, options = {}) {
           const result = mergePR(workspace, pr.number);
           if (result.success) {
             prMerged = true;
-            console.log(chalk10.green(`  \u2713 Merged PR #${pr.number}`));
+            console.log(chalk11.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`));
+            console.log(chalk11.yellow(`  \u26A0 Failed to merge: ${result.error}`));
+            console.log(chalk11.dim(`    Merge manually: gh pr merge ${pr.number} --squash`));
           }
         } else {
-          console.log(chalk10.dim("  No PR found for this branch"));
+          console.log(chalk11.dim("  No PR found for this branch"));
         }
       }
     }
@@ -1050,18 +1404,18 @@ async function approveCommand(id, options = {}) {
         spinner.text = "Updating Linear status...";
         linearUpdated = await updateLinearStatus(apiKey, state.issueId);
         if (linearUpdated) {
-          console.log(chalk10.green(`  \u2713 Updated ${state.issueId} to Done`));
+          console.log(chalk11.green(`  \u2713 Updated ${state.issueId} to Done`));
         } else {
-          console.log(chalk10.yellow(`  \u26A0 Failed to update Linear status`));
+          console.log(chalk11.yellow(`  \u26A0 Failed to update Linear status`));
         }
       } else {
-        console.log(chalk10.dim("  LINEAR_API_KEY not set - skipping status update"));
+        console.log(chalk11.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");
+    const approvedFile = join8(AGENTS_DIR, agentId, "approved");
     writeFileSync4(approvedFile, JSON.stringify({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       prMerged,
@@ -1069,13 +1423,13 @@ async function approveCommand(id, options = {}) {
     }));
     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(chalk11.bold("Summary:"));
+    console.log(`  Issue:   ${chalk11.cyan(state.issueId)}`);
+    console.log(`  PR:      ${prMerged ? chalk11.green("Merged") : chalk11.dim("Not merged")}`);
+    console.log(`  Linear:  ${linearUpdated ? chalk11.green("Updated to Done") : chalk11.dim("Not updated")}`);
     console.log("");
-    console.log(chalk10.dim("Workspace can be cleaned up with:"));
-    console.log(chalk10.dim(`  pan workspace destroy ${state.issueId}`));
+    console.log(chalk11.dim("Workspace can be cleaned up with:"));
+    console.log(chalk11.dim(`  pan workspace destroy ${state.issueId}`));
   } catch (error) {
     spinner.fail(error.message);
     process.exit(1);
@@ -1083,16 +1437,17 @@ async function approveCommand(id, options = {}) {
 }
 
 // src/cli/commands/work/plan.ts
-import chalk11 from "chalk";
+import chalk12 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 inquirer2 from "inquirer";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
+import { join as join9, dirname as dirname3 } from "path";
 import { homedir as homedir2 } from "os";
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function getLinearApiKey2() {
-  const envFile = join7(homedir2(), ".panopticon.env");
-  if (existsSync8(envFile)) {
-    const content = readFileSync7(envFile, "utf-8");
+  const envFile = join9(homedir2(), ".panopticon.env");
+  if (existsSync9(envFile)) {
+    const content = readFileSync8(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -1102,6 +1457,8 @@ function findPRDFiles(issueId) {
   const found = [];
   const cwd = process.cwd();
   const searchPaths = [
+    "docs/prds/active",
+    "docs/prds/planned",
     "docs/prds",
     "docs/prd",
     "prds",
@@ -1109,10 +1466,10 @@ function findPRDFiles(issueId) {
   ];
   const issueIdLower = issueId.toLowerCase();
   for (const searchPath of searchPaths) {
-    const fullPath = join7(cwd, searchPath);
-    if (!existsSync8(fullPath)) continue;
+    const fullPath = join9(cwd, searchPath);
+    if (!existsSync9(fullPath)) continue;
     try {
-      const result = execSync3(
+      const result = execSync4(
         `find "${fullPath}" -type f -name "*.md" 2>/dev/null | xargs grep -l -i "${issueIdLower}" 2>/dev/null || true`,
         { encoding: "utf-8" }
       );
@@ -1123,76 +1480,352 @@ function findPRDFiles(issueId) {
   }
   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("");
+function analyzeComplexity(issue, prdFiles) {
+  const reasons = [];
+  const subsystems = [];
+  let estimatedTasks = 1;
+  const desc = (issue.description || "").toLowerCase();
+  const title = issue.title.toLowerCase();
+  const combined = `${title} ${desc}`;
+  if (combined.includes("frontend") || combined.includes("ui") || combined.includes("component")) {
+    subsystems.push("frontend");
+  }
+  if (combined.includes("backend") || combined.includes("api") || combined.includes("endpoint")) {
+    subsystems.push("backend");
+  }
+  if (combined.includes("database") || combined.includes("migration") || combined.includes("schema")) {
+    subsystems.push("database");
+  }
+  if (combined.includes("test") || combined.includes("e2e") || combined.includes("playwright")) {
+    subsystems.push("tests");
+  }
+  if (subsystems.length > 1) {
+    reasons.push(`Multiple subsystems involved: ${subsystems.join(", ")}`);
+    estimatedTasks += subsystems.length;
+  }
+  const ambiguousPatterns = [
+    "should we",
+    "maybe",
+    "or",
+    "consider",
+    "option",
+    "approach",
+    "tbd",
+    "to be determined",
+    "needs discussion",
+    "unclear"
+  ];
+  for (const pattern of ambiguousPatterns) {
+    if (combined.includes(pattern)) {
+      reasons.push("Requirements may be ambiguous");
+      break;
+    }
+  }
+  const architecturePatterns = [
+    "refactor",
+    "architecture",
+    "redesign",
+    "restructure",
+    "migrate",
+    "integration",
+    "authentication",
+    "authorization",
+    "security"
+  ];
+  for (const pattern of architecturePatterns) {
+    if (combined.includes(pattern)) {
+      reasons.push(`Architecture decision needed: ${pattern}`);
+      estimatedTasks += 2;
+      break;
+    }
+  }
+  if (desc.length > 500) {
+    reasons.push("Detailed description suggests complexity");
+    estimatedTasks += 1;
   }
   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");
+    reasons.push(`PRD exists - complexity already documented`);
+  }
+  const complexLabels = ["complex", "large", "epic", "multi-phase", "architecture"];
+  for (const label of issue.labels || []) {
+    if (complexLabels.some((cl) => label.name.toLowerCase().includes(cl))) {
+      reasons.push(`Label indicates complexity: ${label.name}`);
+      estimatedTasks += 2;
+    }
+  }
+  const isComplex = reasons.length >= 2 || subsystems.length > 1 || estimatedTasks >= 4;
+  return {
+    isComplex,
+    reasons,
+    subsystems,
+    estimatedTasks: Math.max(estimatedTasks, subsystems.length + 1)
+  };
+}
+async function runDiscoveryPhase(issue, complexity, prdContent) {
+  const decisions = [];
+  const tasks = [];
+  console.log("");
+  console.log(chalk12.bold.cyan("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+  console.log(chalk12.bold.cyan("                    DISCOVERY PHASE"));
+  console.log(chalk12.bold.cyan("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+  console.log("");
+  console.log(chalk12.dim("Answer questions to create a detailed execution plan."));
+  console.log(chalk12.dim("Press Enter to skip optional questions."));
+  console.log("");
+  console.log(chalk12.bold("Issue:"), `${issue.identifier} - ${issue.title}`);
+  if (complexity.subsystems.length > 0) {
+    console.log(chalk12.bold("Detected subsystems:"), complexity.subsystems.join(", "));
+  }
+  console.log("");
+  const scopeAnswer = await inquirer2.prompt([{
+    type: "input",
+    name: "scope",
+    message: "What specific changes are needed? (be specific about files/components):",
+    default: issue.description?.slice(0, 100) || ""
+  }]);
+  if (scopeAnswer.scope) {
+    decisions.push({ question: "Scope", answer: scopeAnswer.scope });
+  }
+  const approachAnswer = await inquirer2.prompt([{
+    type: "input",
+    name: "approach",
+    message: "Any specific technical approach or patterns to follow?"
+  }]);
+  if (approachAnswer.approach) {
+    decisions.push({ question: "Technical approach", answer: approachAnswer.approach });
+  }
+  const edgeCasesAnswer = await inquirer2.prompt([{
+    type: "input",
+    name: "edgeCases",
+    message: "Any edge cases or error scenarios to handle?"
+  }]);
+  if (edgeCasesAnswer.edgeCases) {
+    decisions.push({ question: "Edge cases", answer: edgeCasesAnswer.edgeCases });
+  }
+  const testingAnswer = await inquirer2.prompt([{
+    type: "checkbox",
+    name: "testing",
+    message: "What testing is required?",
+    choices: [
+      { name: "Unit tests", value: "unit", checked: true },
+      { name: "Integration tests", value: "integration" },
+      { name: "E2E tests (Playwright)", value: "e2e" },
+      { name: "Manual testing only", value: "manual" }
+    ]
+  }]);
+  if (testingAnswer.testing.length > 0) {
+    decisions.push({ question: "Testing", answer: testingAnswer.testing.join(", ") });
+  }
+  const outOfScopeAnswer = await inquirer2.prompt([{
+    type: "input",
+    name: "outOfScope",
+    message: "Anything explicitly OUT of scope for this issue?"
+  }]);
+  if (outOfScopeAnswer.outOfScope) {
+    decisions.push({ question: "Out of scope", answer: outOfScopeAnswer.outOfScope });
+  }
+  console.log("");
+  console.log(chalk12.bold("Define execution tasks:"));
+  console.log(chalk12.dim("Enter tasks in order. Empty task name to finish."));
+  console.log("");
+  const suggestedTasks = [
+    { name: "Understand requirements", description: "Review issue, PRD, and existing code" }
+  ];
+  if (complexity.subsystems.length > 1) {
+    suggestedTasks.push({ name: "Design approach", description: "Document architecture decisions", dependsOn: "Understand requirements" });
+  }
+  for (const subsystem of complexity.subsystems) {
+    suggestedTasks.push({
+      name: `Implement ${subsystem}`,
+      description: `Core ${subsystem} changes`,
+      dependsOn: complexity.subsystems.length > 1 ? "Design approach" : "Understand requirements"
+    });
+  }
+  if (suggestedTasks.length === 1) {
+    suggestedTasks.push({ name: "Implement changes", description: "Core implementation", dependsOn: "Understand requirements" });
+  }
+  if (testingAnswer.testing.includes("unit") || testingAnswer.testing.includes("integration")) {
+    suggestedTasks.push({ name: "Add tests", description: "Unit and/or integration tests", dependsOn: suggestedTasks[suggestedTasks.length - 1].name });
+  }
+  if (testingAnswer.testing.includes("e2e")) {
+    suggestedTasks.push({ name: "Add E2E tests", description: "Playwright E2E tests", dependsOn: "Add tests" });
+  }
+  suggestedTasks.push({ name: "Verify and cleanup", description: "Lint, type check, final review", dependsOn: suggestedTasks[suggestedTasks.length - 1].name });
+  console.log(chalk12.bold("Suggested tasks:"));
+  for (let i = 0; i < suggestedTasks.length; i++) {
+    const task = suggestedTasks[i];
+    console.log(`  ${i + 1}. ${task.name}${task.dependsOn ? chalk12.dim(` (after: ${task.dependsOn})`) : ""}`);
+  }
+  console.log("");
+  const useDefaultAnswer = await inquirer2.prompt([{
+    type: "confirm",
+    name: "useDefault",
+    message: "Use these suggested tasks?",
+    default: true
+  }]);
+  if (useDefaultAnswer.useDefault) {
+    tasks.push(...suggestedTasks);
+  } else {
+    let taskIndex = 1;
+    let previousTask = "";
+    while (true) {
+      const taskAnswer = await inquirer2.prompt([{
+        type: "input",
+        name: "name",
+        message: `Task ${taskIndex} name (empty to finish):`
+      }]);
+      if (!taskAnswer.name) break;
+      const descAnswer = await inquirer2.prompt([{
+        type: "input",
+        name: "description",
+        message: `Task ${taskIndex} description:`,
+        default: taskAnswer.name
+      }]);
+      tasks.push({
+        name: taskAnswer.name,
+        description: descAnswer.description,
+        dependsOn: previousTask || void 0
+      });
+      previousTask = taskAnswer.name;
+      taskIndex++;
+    }
+  }
+  return { tasks, decisions };
+}
+function generateStateFile(issue, decisions, tasks) {
+  const lines = [
+    `# Agent State: ${issue.identifier}`,
+    "",
+    `**Last Updated:** ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    "",
+    "## Current Position",
+    "",
+    `- **Issue:** ${issue.identifier}`,
+    `- **Title:** ${issue.title}`,
+    `- **Status:** Planning complete, ready for execution`,
+    `- **Linear:** ${issue.url}`,
+    "",
+    "## Decisions Made During Planning",
+    ""
+  ];
+  if (decisions.length > 0) {
+    for (const decision of decisions) {
+      lines.push(`- **${decision.question}:** ${decision.answer}`);
+    }
+  } else {
+    lines.push("- No specific decisions recorded");
+  }
+  lines.push("");
+  lines.push("## Planned Tasks");
+  lines.push("");
+  for (const task of tasks) {
+    lines.push(`- [ ] ${task.name}${task.dependsOn ? ` (after: ${task.dependsOn})` : ""}`);
+  }
+  lines.push("");
+  lines.push("## Blockers/Concerns");
+  lines.push("");
+  lines.push("- None identified during planning");
+  lines.push("");
+  lines.push("## Notes");
+  lines.push("");
+  lines.push("<!-- Add notes as work progresses -->");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateWorkspaceFile(issue, prdFiles) {
+  const lines = [
+    `# Workspace: ${issue.identifier}`,
+    "",
+    `> ${issue.title}`,
+    "",
+    "## Quick Links",
+    "",
+    `- [Linear Issue](${issue.url})`
+  ];
+  for (const prd of prdFiles) {
+    const relativePath = prd.replace(process.cwd() + "/", "");
+    lines.push(`- [PRD](${relativePath})`);
+  }
+  lines.push("");
+  lines.push("## Context Files");
+  lines.push("");
+  lines.push("- `STATE.md` - Current progress and decisions");
+  lines.push("- `WORKSPACE.md` - This file");
+  lines.push("");
+  lines.push("## Beads");
+  lines.push("");
+  lines.push("Check current task status:");
+  lines.push("```bash");
+  lines.push("bd ready  # Next actionable task");
+  lines.push(`bd list --tag ${issue.identifier}  # All tasks for this issue`);
+  lines.push("```");
+  lines.push("");
+  lines.push("## Agent Instructions");
+  lines.push("");
+  lines.push("1. Run `bd ready` to get next task");
+  lines.push("2. Complete the task following relevant skills");
+  lines.push('3. Run `bd close "<task name>" --reason "..."` when done');
+  lines.push("4. Update STATE.md with progress");
+  lines.push("5. Repeat until all tasks complete");
+  lines.push("");
+  return lines.join("\n");
+}
+function createBeadsTasks(issue, tasks) {
+  const created = [];
+  const errors = [];
+  const taskIds = /* @__PURE__ */ new Map();
+  try {
+    execSync4("which bd", { encoding: "utf-8" });
+  } catch {
+    return { success: false, created: [], errors: ["bd (beads) CLI not found in PATH"] };
+  }
+  for (const task of tasks) {
+    const fullName = `${issue.identifier}: ${task.name}`;
+    try {
+      const escapedName = fullName.replace(/"/g, '\\"');
+      let cmd = `bd create "${escapedName}" --type task -l "${issue.identifier},linear"`;
+      if (task.dependsOn) {
+        const depName = `${issue.identifier}: ${task.dependsOn}`;
+        const depId = taskIds.get(depName);
+        if (depId) {
+          cmd += ` --deps "blocks:${depId}"`;
+        }
+      }
+      if (task.description) {
+        const escapedDesc = task.description.replace(/"/g, '\\"');
+        cmd += ` -d "${escapedDesc}"`;
+      }
+      const result = execSync4(cmd, { encoding: "utf-8", cwd: process.cwd() });
+      const idMatch = result.match(/bd-[a-f0-9]+/i) || result.match(/([a-f0-9-]{8,})/i);
+      if (idMatch) {
+        taskIds.set(fullName, idMatch[0]);
+      }
+      created.push(fullName);
+    } catch (error) {
+      const errMsg = error.stderr?.toString() || error.message;
+      errors.push(`Failed to create "${task.name}": ${errMsg.split("\n")[0]}`);
+    }
+  }
+  if (created.length > 0) {
+    try {
+      execSync4("bd flush", { encoding: "utf-8", cwd: process.cwd() });
+    } catch {
+    }
+  }
+  return { success: errors.length === 0, created, errors };
+}
+function copyToPRDDirectory(issue, stateContent) {
+  const cwd = process.cwd();
+  const prdDir = join9(cwd, "docs", "prds", "active");
+  try {
+    mkdirSync5(prdDir, { recursive: true });
+    const filename = `${issue.identifier.toLowerCase()}-plan.md`;
+    const prdPath = join9(prdDir, filename);
+    writeFileSync5(prdPath, stateContent);
+    return prdPath;
+  } catch {
+    return null;
+  }
 }
 async function planCommand(id, options = {}) {
   const spinner = ora6(`Creating execution plan for ${id}...`).start();
@@ -1201,7 +1834,7 @@ async function planCommand(id, options = {}) {
     if (!apiKey) {
       spinner.fail("LINEAR_API_KEY not found");
       console.log("");
-      console.log(chalk11.dim("Set it in ~/.panopticon.env:"));
+      console.log(chalk12.dim("Set it in ~/.panopticon.env:"));
       console.log("  LINEAR_API_KEY=lin_api_xxxxx");
       process.exit(1);
     }
@@ -1215,9 +1848,7 @@ async function planCommand(id, options = {}) {
       spinner.fail("No Linear team found");
       process.exit(1);
     }
-    const searchResult = await team.issues({
-      first: 100
-    });
+    const searchResult = await team.issues({ first: 100 });
     const issue = searchResult.nodes.find(
       (i) => i.identifier.toUpperCase() === id.toUpperCase()
     );
@@ -1243,161 +1874,271 @@ async function planCommand(id, options = {}) {
     };
     spinner.text = "Searching for related PRDs...";
     const prdFiles = findPRDFiles(id);
-    spinner.text = "Generating execution plan...";
-    const plan = generatePlan(issueData, prdFiles);
+    spinner.text = "Analyzing complexity...";
+    const complexity = analyzeComplexity(issueData, prdFiles);
+    spinner.stop();
+    console.log("");
+    console.log(chalk12.bold("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+    console.log(chalk12.bold(`  ${issueData.identifier}: ${issueData.title}`));
+    console.log(chalk12.bold("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+    console.log("");
+    console.log(chalk12.bold("Complexity Analysis:"));
+    console.log(`  Level: ${complexity.isComplex ? chalk12.yellow("COMPLEX") : chalk12.green("SIMPLE")}`);
+    console.log(`  Estimated tasks: ${complexity.estimatedTasks}`);
+    if (complexity.subsystems.length > 0) {
+      console.log(`  Subsystems: ${complexity.subsystems.join(", ")}`);
+    }
+    if (complexity.reasons.length > 0) {
+      console.log(`  Reasons:`);
+      for (const reason of complexity.reasons) {
+        console.log(`    - ${reason}`);
+      }
+    }
+    console.log("");
+    if (prdFiles.length > 0) {
+      console.log(chalk12.bold("Related PRDs found:"));
+      for (const prd of prdFiles) {
+        console.log(`  - ${prd.replace(process.cwd() + "/", "")}`);
+      }
+      console.log("");
+    }
+    if (!complexity.isComplex && !options.force) {
+      const skipAnswer = await inquirer2.prompt([{
+        type: "confirm",
+        name: "skip",
+        message: "This looks simple. Skip planning and go straight to /work-issue?",
+        default: true
+      }]);
+      if (skipAnswer.skip) {
+        console.log("");
+        console.log(chalk12.cyan(`Run: pan work issue ${id}`));
+        console.log("");
+        return;
+      }
+    }
+    let tasks;
+    let decisions;
+    if (options.skipDiscovery) {
+      tasks = [
+        { name: "Understand requirements", description: "Review issue and existing code" },
+        { name: "Implement changes", description: "Core implementation", dependsOn: "Understand requirements" },
+        { name: "Add tests", description: "Unit/integration tests", dependsOn: "Implement changes" },
+        { name: "Verify and cleanup", description: "Lint, type check, final review", dependsOn: "Add tests" }
+      ];
+      decisions = [];
+    } else {
+      const discovery = await runDiscoveryPhase(issueData, complexity);
+      tasks = discovery.tasks;
+      decisions = discovery.decisions;
+    }
+    const spinnerCreate = ora6("Creating context files...").start();
+    const stateContent = generateStateFile(issueData, decisions, tasks);
+    const workspaceContent = generateWorkspaceFile(issueData, prdFiles);
+    const outputDir = options.output ? dirname3(options.output) : process.cwd();
+    const planningDir = join9(outputDir, ".planning");
+    mkdirSync5(planningDir, { recursive: true });
+    const statePath = join9(planningDir, "STATE.md");
+    writeFileSync5(statePath, stateContent);
+    const workspacePath = join9(planningDir, "WORKSPACE.md");
+    writeFileSync5(workspacePath, workspaceContent);
+    spinnerCreate.succeed("Context files created");
+    const spinnerBeads = ora6("Creating Beads tasks...").start();
+    const beadsResult = createBeadsTasks(issueData, tasks);
+    if (beadsResult.success) {
+      spinnerBeads.succeed(`Created ${beadsResult.created.length} Beads tasks`);
+    } else {
+      spinnerBeads.warn(`Created ${beadsResult.created.length} tasks with errors`);
+      for (const error of beadsResult.errors) {
+        console.log(chalk12.red(`  - ${error}`));
+      }
+    }
+    const prdPath = copyToPRDDirectory(issueData, stateContent);
+    if (prdPath) {
+      console.log(chalk12.dim(`Plan copied to: ${prdPath.replace(process.cwd() + "/", "")}`));
+    }
     if (options.json) {
-      spinner.stop();
       console.log(JSON.stringify({
         issue: issueData,
-        prdFiles,
-        plan
+        complexity,
+        tasks,
+        decisions,
+        files: {
+          state: statePath,
+          workspace: workspacePath,
+          prd: prdPath
+        },
+        beads: beadsResult
       }, 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(chalk12.bold.green("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+    console.log(chalk12.bold.green("                    PLAN COMPLETE"));
+    console.log(chalk12.bold.green("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
     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(chalk12.bold("Files created:"));
+    console.log(`  ${chalk12.cyan(statePath.replace(process.cwd() + "/", ""))}`);
+    console.log(`  ${chalk12.cyan(workspacePath.replace(process.cwd() + "/", ""))}`);
     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(chalk12.bold("Beads tasks:"));
+    for (const task of tasks) {
+      console.log(`  ${chalk12.dim("\u25CB")} ${issueData.identifier}: ${task.name}`);
+    }
+    console.log("");
+    if (decisions.length > 0) {
+      console.log(chalk12.bold("Decisions recorded:"));
+      for (const decision of decisions) {
+        console.log(`  - ${decision.question}: ${chalk12.dim(decision.answer.slice(0, 50))}${decision.answer.length > 50 ? "..." : ""}`);
       }
       console.log("");
     }
+    console.log(chalk12.bold("Next steps:"));
+    console.log(`  1. Review ${chalk12.cyan(".planning/STATE.md")}`);
+    console.log(`  2. Run ${chalk12.cyan(`pan work issue ${id}`)} to spawn agent`);
+    console.log(`  3. Agent will use ${chalk12.cyan("bd ready")} to get tasks`);
+    console.log("");
   } catch (error) {
-    spinner.fail(error.message);
+    console.error(chalk12.red(`Error: ${error.message}`));
     process.exit(1);
   }
 }
 
 // src/cli/commands/work/list.ts
-import chalk12 from "chalk";
+import chalk13 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")
+  0: chalk13.dim("None"),
+  1: chalk13.red("Urgent"),
+  2: chalk13.yellow("High"),
+  3: chalk13.blue("Medium"),
+  4: chalk13.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
+  "open": chalk13.white,
+  "in_progress": chalk13.yellow,
+  "closed": chalk13.green
 };
+function getTrackerConfig(trackerType) {
+  const config = loadConfig();
+  const trackerConfig = config.trackers[trackerType];
+  if (!trackerConfig) {
+    return null;
+  }
+  return {
+    type: trackerType,
+    apiKeyEnv: trackerConfig.api_key_env,
+    team: trackerConfig.team,
+    tokenEnv: trackerConfig.token_env,
+    owner: trackerConfig.owner,
+    repo: trackerConfig.repo,
+    projectId: trackerConfig.project_id
+  };
+}
+function getConfiguredTrackers() {
+  const config = loadConfig();
+  const trackers = [];
+  if (config.trackers.linear) trackers.push("linear");
+  if (config.trackers.github) trackers.push("github");
+  if (config.trackers.gitlab) trackers.push("gitlab");
+  return trackers;
+}
+function displayIssues(issues, trackerName) {
+  if (issues.length === 0) {
+    console.log(chalk13.dim(`  No issues found in ${trackerName}`));
+    return;
+  }
+  const byState = {};
+  for (const issue of issues) {
+    if (!byState[issue.state]) byState[issue.state] = [];
+    byState[issue.state].push(issue);
+  }
+  const stateOrder = ["in_progress", "open", "closed"];
+  for (const state of stateOrder) {
+    const stateIssues = byState[state];
+    if (!stateIssues || stateIssues.length === 0) continue;
+    const colorFn = STATE_COLORS[state] || chalk13.white;
+    const displayState = state.replace("_", " ").replace(/\b\w/g, (l) => l.toUpperCase());
+    console.log(colorFn(`  \u2500\u2500 ${displayState} (${stateIssues.length}) \u2500\u2500`));
+    for (const issue of stateIssues) {
+      const priorityLabel = issue.priority ? PRIORITY_LABELS[issue.priority] || "" : "";
+      const assigneeStr = issue.assignee ? chalk13.dim(` @${issue.assignee.split(" ")[0]}`) : "";
+      const priorityStr = issue.priority && issue.priority < 3 ? ` ${priorityLabel}` : "";
+      console.log(`    ${chalk13.cyan(issue.ref)} ${issue.title}${assigneeStr}${priorityStr}`);
+    }
+    console.log("");
+  }
+}
 async function listCommand(options) {
-  const spinner = ora7("Fetching issues from Linear...").start();
+  const spinner = ora7("Fetching issues...").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 config = loadConfig();
+    const trackersToQuery = [];
+    if (options.tracker) {
+      const trackerType = options.tracker;
+      if (!["linear", "github", "gitlab"].includes(trackerType)) {
+        spinner.fail(`Unknown tracker: ${options.tracker}`);
+        console.log(chalk13.dim("Valid trackers: linear, github, gitlab"));
+        process.exit(1);
+      }
+      trackersToQuery.push(trackerType);
+    } else if (options.allTrackers) {
+      trackersToQuery.push(...getConfiguredTrackers());
+    } else {
+      trackersToQuery.push(config.trackers.primary);
     }
-    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");
+    if (trackersToQuery.length === 0) {
+      spinner.fail("No trackers configured");
+      console.log(chalk13.dim("Configure trackers in ~/.panopticon/config.toml"));
       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;
+    const allIssues = [];
+    for (const trackerType of trackersToQuery) {
+      spinner.text = `Fetching from ${trackerType}...`;
+      const trackerConfig = getTrackerConfig(trackerType);
+      if (!trackerConfig) {
+        console.log(chalk13.yellow(`
+Warning: ${trackerType} not configured, skipping`));
+        continue;
+      }
+      try {
+        const tracker = createTracker(trackerConfig);
+        const issues = await tracker.listIssues({
+          includeClosed: options.all,
+          assignee: options.mine ? "me" : void 0
+        });
+        allIssues.push({ tracker: trackerType, issues });
+      } catch (error) {
+        console.log(chalk13.yellow(`
+Warning: Failed to fetch from ${trackerType}: ${error.message}`));
+      }
     }
     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));
+      const output = allIssues.flatMap(
+        ({ tracker, issues }) => issues.map((issue) => ({ ...issue, source: tracker }))
+      );
+      console.log(JSON.stringify(output, null, 2));
       return;
     }
-    if (issues.length === 0) {
-      console.log(chalk12.dim("No issues found."));
+    const totalIssues = allIssues.reduce((sum, { issues }) => sum + issues.length, 0);
+    if (totalIssues === 0) {
+      console.log(chalk13.dim("\nNo issues found."));
       return;
     }
-    console.log(chalk12.bold(`
-${team.name} Issues
+    for (const { tracker, issues } of allIssues) {
+      console.log(chalk13.bold(`
+${tracker.toUpperCase()} (${issues.length} 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("");
+      displayIssues(issues, tracker);
+    }
+    const trackerNames = trackersToQuery.join(", ");
+    console.log(chalk13.dim(`Showing ${totalIssues} issues from ${trackerNames}.`));
+    if (!options.all) {
+      console.log(chalk13.dim("Use --all to include closed issues."));
+    }
+    if (!options.allTrackers && trackersToQuery.length === 1) {
+      console.log(chalk13.dim("Use --all-trackers to query all configured trackers."));
     }
-    console.log(chalk12.dim(`Showing ${issues.length} issues. Use --all to include completed.`));
   } catch (error) {
     spinner.fail(error.message);
     process.exit(1);
@@ -1405,164 +2146,175 @@ ${team.name} Issues
 }
 
 // src/cli/commands/work/triage.ts
-import chalk13 from "chalk";
+import chalk14 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;
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync10, mkdirSync as mkdirSync6 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir3 } from "os";
+function getTrackerConfig2(trackerType) {
+  const config = loadConfig();
+  const trackerConfig = config.trackers[trackerType];
+  if (!trackerConfig) {
+    return null;
+  }
+  return {
+    type: trackerType,
+    apiKeyEnv: trackerConfig.api_key_env,
+    team: trackerConfig.team,
+    tokenEnv: trackerConfig.token_env,
+    owner: trackerConfig.owner,
+    repo: trackerConfig.repo,
+    projectId: trackerConfig.project_id
+  };
 }
 function getTriageStatePath() {
-  return join9(homedir4(), ".panopticon", "triage-state.json");
+  return join10(homedir3(), ".panopticon", "triage-state.json");
 }
 function loadTriageState() {
   const path = getTriageStatePath();
   if (existsSync10(path)) {
-    return JSON.parse(readFileSync9(path, "utf-8"));
+    try {
+      return JSON.parse(readFileSync9(path, "utf-8"));
+    } catch {
+      return { dismissed: [], created: {} };
+    }
   }
   return { dismissed: [], created: {} };
 }
 function saveTriageState(state) {
+  const dir = join10(homedir3(), ".panopticon");
+  if (!existsSync10(dir)) {
+    mkdirSync6(dir, { recursive: true });
+  }
   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:"));
+    const config = loadConfig();
+    const primaryType = config.trackers.primary;
+    const secondaryType = config.trackers.secondary;
+    if (!secondaryType) {
+      spinner.info("No secondary tracker configured");
       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(chalk14.bold("Setup Instructions:"));
       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"));
+      console.log("Add secondary tracker to ~/.panopticon/config.toml:");
+      console.log(chalk14.dim(`
+[trackers]
+primary = "linear"
+secondary = "github"
+
+[trackers.github]
+type = "github"
+token_env = "GITHUB_TOKEN"
+owner = "your-org"
+repo = "your-repo"
+`));
+      return;
+    }
+    const primaryConfig = getTrackerConfig2(primaryType);
+    const secondaryConfig = getTrackerConfig2(secondaryType);
+    if (!primaryConfig) {
+      spinner.fail(`Primary tracker (${primaryType}) not configured`);
+      return;
+    }
+    if (!secondaryConfig) {
+      spinner.fail(`Secondary tracker (${secondaryType}) not configured`);
       return;
     }
     const triageState = loadTriageState();
     if (id) {
-      const issueNumber = parseInt(id.replace("#", ""), 10);
+      const issueRef = id.startsWith("#") ? id : `#${id}`;
       if (options.dismiss) {
-        if (!triageState.dismissed.includes(issueNumber)) {
-          triageState.dismissed.push(issueNumber);
+        if (!triageState.dismissed.includes(issueRef)) {
+          triageState.dismissed.push(issueRef);
           saveTriageState(triageState);
         }
-        spinner.succeed(`Dismissed #${issueNumber}: ${options.dismiss}`);
+        spinner.succeed(`Dismissed ${issueRef}: ${options.dismiss}`);
         return;
       }
       if (options.create) {
-        if (!config.linearApiKey) {
-          spinner.fail("LINEAR_API_KEY not configured");
+        spinner.text = `Fetching ${secondaryType} issue ${issueRef}...`;
+        let secondaryTracker2;
+        try {
+          secondaryTracker2 = createTracker(secondaryConfig);
+        } catch (error) {
+          spinner.fail(`Failed to connect to ${secondaryType}: ${error.message}`);
           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`);
+        let sourceIssue;
+        try {
+          sourceIssue = await secondaryTracker2.getIssue(id);
+        } catch (error) {
+          spinner.fail(`Issue ${issueRef} not found in ${secondaryType}`);
           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;
+        spinner.text = `Creating ${primaryType} issue...`;
+        let primaryTracker;
+        try {
+          primaryTracker = createTracker(primaryConfig);
+        } catch (error) {
+          spinner.fail(`Failed to connect to ${primaryType}: ${error.message}`);
+          return;
+        }
+        const newIssue = await primaryTracker.createIssue({
+          title: sourceIssue.title,
+          description: `${sourceIssue.description}
+
+---
+
+**From ${secondaryType}:** ${sourceIssue.url}`,
+          team: primaryConfig.team
+        });
+        try {
+          await secondaryTracker2.addComment(
+            id,
+            `Internal tracking: ${newIssue.ref} (${primaryType})`
+          );
+        } catch {
+          console.log(chalk14.yellow("\nNote: Could not add link comment to source issue"));
+        }
+        triageState.created[sourceIssue.ref] = newIssue.ref;
         saveTriageState(triageState);
-        spinner.succeed(`Created ${linearId} from GitHub #${issueNumber}`);
+        spinner.succeed(`Created ${newIssue.ref} from ${sourceIssue.ref}`);
         console.log("");
-        console.log(`  GitHub: ${chalk13.dim(ghIssue.html_url)}`);
-        console.log(`  Linear: ${chalk13.cyan(linearId)}`);
+        console.log(`  ${secondaryType}: ${chalk14.dim(sourceIssue.url)}`);
+        console.log(`  ${primaryType}: ${chalk14.cyan(newIssue.ref)}`);
         return;
       }
     }
-    spinner.text = "Fetching GitHub issues...";
-    const issues = await fetchGitHubIssues(config.githubToken, config.githubRepo);
+    spinner.text = `Fetching ${secondaryType} issues...`;
+    let secondaryTracker;
+    try {
+      secondaryTracker = createTracker(secondaryConfig);
+    } catch (error) {
+      spinner.fail(`Failed to connect to ${secondaryType}: ${error.message}`);
+      return;
+    }
+    const issues = await secondaryTracker.listIssues({ includeClosed: false });
     const pending = issues.filter(
-      (i) => !triageState.dismissed.includes(i.number) && !triageState.created[i.number]
+      (i) => !triageState.dismissed.includes(i.ref) && !triageState.created[i.ref]
     );
     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`));
+      console.log(chalk14.green("No issues pending triage."));
+      console.log(chalk14.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})
+    console.log(chalk14.bold(`
+${secondaryType.toUpperCase()} 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)}`);
+      const labels = issue.labels.map((l) => chalk14.dim(`[${l}]`)).join(" ");
+      console.log(`  ${chalk14.cyan(issue.ref)} ${issue.title} ${labels}`);
+      console.log(`    ${chalk14.dim(issue.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(chalk14.bold("Commands:"));
+    console.log(`  ${chalk14.dim(`Create ${primaryType} issue:`)} pan work triage <id> --create`);
+    console.log(`  ${chalk14.dim("Dismiss from queue:")}  pan work triage <id> --dismiss "reason"`);
     console.log("");
   } catch (error) {
     spinner.fail(error.message);
@@ -1571,7 +2323,7 @@ GitHub Issues Pending Triage (${pending.length})
 }
 
 // src/cli/commands/work/hook.ts
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 async function hookCommand(action, idOrMessage, options = {}) {
   const agentId = process.env.PANOPTICON_AGENT_ID || "default";
   switch (action) {
@@ -1582,20 +2334,20 @@ async function hookCommand(action, idOrMessage, options = {}) {
         return;
       }
       if (!result.hasWork) {
-        console.log(chalk14.green("\u2713 No pending work on hook"));
+        console.log(chalk15.green("\u2713 No pending work on hook"));
         return;
       }
-      console.log(chalk14.yellow(`\u26A0 ${result.items.length} item(s) on hook`));
+      console.log(chalk15.yellow(`\u26A0 ${result.items.length} item(s) on hook`));
       if (result.urgentCount > 0) {
-        console.log(chalk14.red(`  ${result.urgentCount} URGENT`));
+        console.log(chalk15.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
+          urgent: chalk15.red,
+          high: chalk15.yellow,
+          normal: chalk15.white,
+          low: chalk15.dim
         }[item.priority];
         console.log(`${priorityColor(`[${item.priority.toUpperCase()}]`)} ${item.id}`);
         console.log(`  Type: ${item.type}`);
@@ -1609,13 +2361,13 @@ async function hookCommand(action, idOrMessage, options = {}) {
     }
     case "push": {
       if (!idOrMessage) {
-        console.log(chalk14.red("Usage: pan work hook push <agent-id> <message>"));
+        console.log(chalk15.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"));
+        console.log(chalk15.red("Message required"));
         process.exit(1);
       }
       const item = pushToHook(targetAgent.startsWith("agent-") ? targetAgent : `agent-${targetAgent}`, {
@@ -1624,36 +2376,36 @@ async function hookCommand(action, idOrMessage, options = {}) {
         source: "cli",
         payload: { message }
       });
-      console.log(chalk14.green(`\u2713 Pushed to hook: ${item.id}`));
+      console.log(chalk15.green(`\u2713 Pushed to hook: ${item.id}`));
       break;
     }
     case "pop": {
       if (!idOrMessage) {
-        console.log(chalk14.red("Usage: pan work hook pop <item-id>"));
+        console.log(chalk15.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}`));
+        console.log(chalk15.green(`\u2713 Popped: ${idOrMessage}`));
       } else {
-        console.log(chalk14.yellow(`Item not found: ${idOrMessage}`));
+        console.log(chalk15.yellow(`Item not found: ${idOrMessage}`));
       }
       break;
     }
     case "clear": {
       clearHook(idOrMessage || agentId);
-      console.log(chalk14.green("\u2713 Hook cleared"));
+      console.log(chalk15.green("\u2713 Hook cleared"));
       break;
     }
     case "mail": {
       if (!idOrMessage) {
-        console.log(chalk14.red("Usage: pan work hook mail <agent-id> <message>"));
+        console.log(chalk15.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"));
+        console.log(chalk15.red("Message required"));
         process.exit(1);
       }
       sendMail(
@@ -1661,32 +2413,32 @@ async function hookCommand(action, idOrMessage, options = {}) {
         "cli",
         message
       );
-      console.log(chalk14.green(`\u2713 Mail sent to ${targetAgent}`));
+      console.log(chalk15.green(`\u2713 Mail sent to ${targetAgent}`));
       break;
     }
     case "gupp": {
       const prompt = generateGUPPPrompt(idOrMessage || agentId);
       if (!prompt) {
-        console.log(chalk14.green("No GUPP work found"));
+        console.log(chalk15.green("No GUPP work found"));
         return;
       }
       console.log(prompt);
       break;
     }
     default:
-      console.log(chalk14.bold("Hook Commands:"));
+      console.log(chalk15.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`);
+      console.log(`  ${chalk15.cyan("pan work hook check [agent-id]")}  - Check for pending work`);
+      console.log(`  ${chalk15.cyan("pan work hook push <agent-id> <msg>")}  - Push task to hook`);
+      console.log(`  ${chalk15.cyan("pan work hook pop <item-id>")}  - Remove completed item`);
+      console.log(`  ${chalk15.cyan("pan work hook clear [agent-id]")}  - Clear all hook items`);
+      console.log(`  ${chalk15.cyan("pan work hook mail <agent-id> <msg>")}  - Send mail to agent`);
+      console.log(`  ${chalk15.cyan("pan work hook gupp [agent-id]")}  - Generate GUPP prompt`);
   }
 }
 
 // src/cli/commands/work/recover.ts
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import ora9 from "ora";
 async function recoverCommand(id, options = {}) {
   const spinner = ora9("Checking for crashed agents...").start();
@@ -1701,7 +2453,7 @@ async function recoverCommand(id, options = {}) {
         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"));
+          console.log(chalk16.dim("\nUse --all to auto-recover all crashed agents"));
           return;
         }
       }
@@ -1709,12 +2461,12 @@ async function recoverCommand(id, options = {}) {
         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(`  ${chalk16.red("\u25CF")} ${chalk16.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"));
+        console.log(chalk16.dim("Use --all to auto-recover, or specify an agent ID"));
         return;
       }
       spinner.text = "Auto-recovering agents...";
@@ -1725,15 +2477,15 @@ async function recoverCommand(id, options = {}) {
         return;
       }
       if (result.recovered.length > 0) {
-        console.log(chalk15.green(`\u2713 Recovered ${result.recovered.length} agent(s):`));
+        console.log(chalk16.green(`\u2713 Recovered ${result.recovered.length} agent(s):`));
         for (const agentId2 of result.recovered) {
-          console.log(`  ${chalk15.cyan(agentId2)}`);
+          console.log(`  ${chalk16.cyan(agentId2)}`);
         }
       }
       if (result.failed.length > 0) {
-        console.log(chalk15.red(`\u2717 Failed to recover ${result.failed.length} agent(s):`));
+        console.log(chalk16.red(`\u2717 Failed to recover ${result.failed.length} agent(s):`));
         for (const agentId2 of result.failed) {
-          console.log(`  ${chalk15.dim(agentId2)}`);
+          console.log(`  ${chalk16.dim(agentId2)}`);
         }
       }
       return;
@@ -1747,12 +2499,12 @@ async function recoverCommand(id, options = {}) {
     }
     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(chalk16.bold("Agent Details:"));
+    console.log(`  Issue:     ${chalk16.cyan(state.issueId)}`);
+    console.log(`  Workspace: ${chalk16.dim(state.workspace)}`);
     console.log(`  Model:     ${state.model}`);
     console.log("");
-    console.log(chalk15.dim("Commands:"));
+    console.log(chalk16.dim("Commands:"));
     console.log(`  Attach:  tmux attach -t ${state.id}`);
     console.log(`  Message: pan work tell ${state.issueId} "your message"`);
   } catch (error) {
@@ -1762,7 +2514,7 @@ async function recoverCommand(id, options = {}) {
 }
 
 // src/cli/commands/work/cv.ts
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 async function cvCommand(agentId, options = {}) {
   if (options.rankings || !agentId) {
     const rankings = getAgentRankings();
@@ -1771,15 +2523,15 @@ async function cvCommand(agentId, options = {}) {
       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."));
+      console.log(chalk17.dim("No agent work history yet."));
+      console.log(chalk17.dim("CVs are created as agents complete work."));
       return;
     }
-    console.log(chalk16.bold("\nAgent Rankings\n"));
+    console.log(chalk17.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)));
+    console.log(chalk17.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}" : "  ";
@@ -1790,7 +2542,7 @@ async function cvCommand(agentId, options = {}) {
       );
     }
     console.log("");
-    console.log(chalk16.dim(`Use: pan work cv <agent-id> for details`));
+    console.log(chalk17.dim(`Use: pan work cv <agent-id> for details`));
     return;
   }
   const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
@@ -1804,13 +2556,13 @@ async function cvCommand(agentId, options = {}) {
 }
 
 // src/cli/commands/work/context.ts
-import chalk17 from "chalk";
+import chalk18 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";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7, appendFileSync, readdirSync as readdirSync8 } from "fs";
+import { join as join11 } from "path";
 function getStateFile(agentId) {
-  return join10(AGENTS_DIR, agentId, "STATE.md");
+  return join11(AGENTS_DIR, agentId, "STATE.md");
 }
 function readAgentState(agentId) {
   const stateFile = getStateFile(agentId);
@@ -1823,8 +2575,8 @@ function readAgentState(agentId) {
   }
 }
 function writeAgentState(agentId, state) {
-  const dir = join10(AGENTS_DIR, agentId);
-  mkdirSync5(dir, { recursive: true });
+  const dir = join11(AGENTS_DIR, agentId);
+  mkdirSync7(dir, { recursive: true });
   const content = generateStateMd(state);
   writeFileSync7(getStateFile(agentId), content);
 }
@@ -1900,11 +2652,11 @@ function parseStateMd(content) {
   return state;
 }
 function getSummaryFile(agentId) {
-  return join10(AGENTS_DIR, agentId, "SUMMARY.md");
+  return join11(AGENTS_DIR, agentId, "SUMMARY.md");
 }
 function appendSummary(agentId, summary) {
-  const dir = join10(AGENTS_DIR, agentId);
-  mkdirSync5(dir, { recursive: true });
+  const dir = join11(AGENTS_DIR, agentId);
+  mkdirSync7(dir, { recursive: true });
   const summaryFile = getSummaryFile(agentId);
   const content = generateSummaryEntry(summary);
   if (existsSync11(summaryFile)) {
@@ -1948,14 +2700,14 @@ function generateSummaryEntry(summary) {
   return lines.join("\n");
 }
 function getHistoryDir(agentId) {
-  return join10(AGENTS_DIR, agentId, "history");
+  return join11(AGENTS_DIR, agentId, "history");
 }
 function logHistory(agentId, action, details) {
   const historyDir = getHistoryDir(agentId);
-  mkdirSync5(historyDir, { recursive: true });
+  mkdirSync7(historyDir, { recursive: true });
   const date = /* @__PURE__ */ new Date();
   const dateStr = date.toISOString().split("T")[0];
-  const historyFile = join10(historyDir, `${dateStr}.log`);
+  const historyFile = join11(historyDir, `${dateStr}.log`);
   const timestamp = date.toISOString();
   const detailsStr = details ? ` ${JSON.stringify(details)}` : "";
   const logLine = `[${timestamp}] ${action}${detailsStr}
@@ -1967,10 +2719,10 @@ function searchHistory(agentId, pattern) {
   if (!existsSync11(historyDir)) return [];
   const results = [];
   const regex = new RegExp(pattern, "i");
-  const files = readdirSync6(historyDir).filter((f) => f.endsWith(".log"));
+  const files = readdirSync8(historyDir).filter((f) => f.endsWith(".log"));
   files.sort().reverse();
   for (const file of files) {
-    const content = readFileSync10(join10(historyDir, file), "utf-8");
+    const content = readFileSync10(join11(historyDir, file), "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       if (regex.test(line)) {
@@ -1984,11 +2736,11 @@ function getRecentHistory(agentId, limit = 20) {
   const historyDir = getHistoryDir(agentId);
   if (!existsSync11(historyDir)) return [];
   const results = [];
-  const files = readdirSync6(historyDir).filter((f) => f.endsWith(".log"));
+  const files = readdirSync8(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 content = readFileSync10(join11(historyDir, file), "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     for (const line of lines.reverse()) {
       if (results.length >= limit) break;
@@ -2001,18 +2753,18 @@ function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 function getMaterializedDir(agentId) {
-  return join10(AGENTS_DIR, agentId, "materialized");
+  return join11(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) => {
+  return readdirSync8(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)
+      file: join11(dir, f)
     };
   }).filter(Boolean);
 }
@@ -2033,34 +2785,34 @@ async function contextCommand(action, arg1, arg2, options = {}) {
         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>"));
+        console.log(chalk18.dim("No state found for agent."));
+        console.log(chalk18.dim("Initialize with: pan work context init <agent-id> <issue-id>"));
         return;
       }
-      console.log(chalk17.bold(`
+      console.log(chalk18.bold(`
 Agent State: ${state.issueId}
 `));
-      console.log(`Status: ${chalk17.cyan(state.status)}`);
-      console.log(`Last Activity: ${chalk17.dim(state.lastActivity)}`);
+      console.log(`Status: ${chalk18.cyan(state.status)}`);
+      console.log(`Last Activity: ${chalk18.dim(state.lastActivity)}`);
       if (state.lastCheckpoint) {
         console.log("");
-        console.log(chalk17.bold("Session Continuity:"));
-        console.log(`  Checkpoint: ${chalk17.yellow(state.lastCheckpoint)}`);
+        console.log(chalk18.bold("Session Continuity:"));
+        console.log(`  Checkpoint: ${chalk18.yellow(state.lastCheckpoint)}`);
         if (state.resumePoint) {
-          console.log(`  Resume: ${chalk17.green(state.resumePoint)}`);
+          console.log(`  Resume: ${chalk18.green(state.resumePoint)}`);
         }
       }
       if (state.contextRefs.workspace || state.contextRefs.prd) {
         console.log("");
-        console.log(chalk17.bold("Context References:"));
+        console.log(chalk18.bold("Context References:"));
         if (state.contextRefs.workspace) {
-          console.log(`  Workspace: ${chalk17.dim(state.contextRefs.workspace)}`);
+          console.log(`  Workspace: ${chalk18.dim(state.contextRefs.workspace)}`);
         }
         if (state.contextRefs.prd) {
-          console.log(`  PRD: ${chalk17.dim(state.contextRefs.prd)}`);
+          console.log(`  PRD: ${chalk18.dim(state.contextRefs.prd)}`);
         }
         if (state.contextRefs.beads) {
-          console.log(`  Beads: ${chalk17.dim(state.contextRefs.beads)}`);
+          console.log(`  Beads: ${chalk18.dim(state.contextRefs.beads)}`);
         }
       }
       console.log("");
@@ -2077,22 +2829,22 @@ Agent State: ${state.issueId}
       };
       writeAgentState(targetAgent, state);
       logHistory(targetAgent, "context:init", { issueId });
-      console.log(chalk17.green(`\u2713 Initialized state for ${targetAgent}`));
+      console.log(chalk18.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"]'));
+        console.log(chalk18.red("Checkpoint message required"));
+        console.log(chalk18.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}"`));
+      console.log(chalk18.green(`\u2713 Checkpoint saved: "${checkpoint}"`));
       if (resume) {
-        console.log(chalk17.dim(`  Resume point: "${resume}"`));
+        console.log(chalk18.dim(`  Resume point: "${resume}"`));
       }
       break;
     }
@@ -2105,7 +2857,7 @@ Agent State: ${state.issueId}
       };
       appendSummary(agentId, summary);
       logHistory(agentId, "context:summary", { title });
-      console.log(chalk17.green(`\u2713 Summary added: "${title}"`));
+      console.log(chalk18.green(`\u2713 Summary added: "${title}"`));
       break;
     }
     case "history": {
@@ -2113,10 +2865,10 @@ Agent State: ${state.issueId}
       if (pattern) {
         const results = searchHistory(agentId, pattern);
         if (results.length === 0) {
-          console.log(chalk17.dim("No matches found."));
+          console.log(chalk18.dim("No matches found."));
           return;
         }
-        console.log(chalk17.bold(`
+        console.log(chalk18.bold(`
 History matches for "${pattern}":
 `));
         for (const line of results.slice(0, 50)) {
@@ -2125,10 +2877,10 @@ History matches for "${pattern}":
       } else {
         const recent = getRecentHistory(agentId, 20);
         if (recent.length === 0) {
-          console.log(chalk17.dim("No history yet."));
+          console.log(chalk18.dim("No history yet."));
           return;
         }
-        console.log(chalk17.bold("\nRecent History:\n"));
+        console.log(chalk18.bold("\nRecent History:\n"));
         for (const line of recent) {
           console.log(line);
         }
@@ -2147,14 +2899,14 @@ History matches for "${pattern}":
       }
       const outputs = listMaterialized(agentId);
       if (outputs.length === 0) {
-        console.log(chalk17.dim("No materialized outputs."));
+        console.log(chalk18.dim("No materialized outputs."));
         return;
       }
-      console.log(chalk17.bold("\nMaterialized Outputs:\n"));
+      console.log(chalk18.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(`  ${chalk18.cyan(out.tool)} ${chalk18.dim(date)}`);
+        console.log(`    ${chalk18.dim(out.file)}`);
       }
       console.log("");
       break;
@@ -2162,7 +2914,7 @@ History matches for "${pattern}":
     case "tokens": {
       const target = arg1;
       if (!target) {
-        console.log(chalk17.dim("Usage: pan work context tokens <file-or-text>"));
+        console.log(chalk18.dim("Usage: pan work context tokens <file-or-text>"));
         return;
       }
       let text = target;
@@ -2170,36 +2922,36 @@ History matches for "${pattern}":
         text = readFileSync11(target, "utf-8");
       }
       const tokens = estimateTokens(text);
-      console.log(`Estimated tokens: ${chalk17.cyan(tokens.toLocaleString())}`);
+      console.log(`Estimated tokens: ${chalk18.cyan(tokens.toLocaleString())}`);
       break;
     }
     default:
-      console.log(chalk17.bold("Context Commands:"));
+      console.log(chalk18.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(`  ${chalk18.cyan("pan work context state [agent-id]")}     - Show current state`);
+      console.log(`  ${chalk18.cyan("pan work context init <agent> <issue>")} - Initialize state`);
+      console.log(`  ${chalk18.cyan('pan work context checkpoint "msg"')}     - Save checkpoint`);
+      console.log(`  ${chalk18.cyan("pan work context summary [title]")}      - Add work summary`);
+      console.log(`  ${chalk18.cyan("pan work context history [pattern]")}    - Search history`);
+      console.log(`  ${chalk18.cyan("pan work context materialize [file]")}   - List/read outputs`);
+      console.log(`  ${chalk18.cyan("pan work context tokens <file>")}        - Estimate token count`);
       console.log("");
   }
 }
 
 // src/cli/commands/work/health.ts
-import chalk18 from "chalk";
+import chalk19 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";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
+import { join as join12 } from "path";
+import { execSync as execSync5 } 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");
+  return join12(AGENTS_DIR, agentId, "health.json");
 }
 function getAgentHealth(agentId) {
   const healthFile = getHealthFile(agentId);
@@ -2221,13 +2973,13 @@ function getAgentHealth(agentId) {
   return defaultHealth;
 }
 function saveAgentHealth(health) {
-  const dir = join11(AGENTS_DIR, health.agentId);
-  mkdirSync6(dir, { recursive: true });
+  const dir = join12(AGENTS_DIR, health.agentId);
+  mkdirSync8(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" });
+    execSync5(`tmux has-session -t "${agentId}" 2>/dev/null`, { encoding: "utf-8" });
     return true;
   } catch {
     return false;
@@ -2337,7 +3089,7 @@ async function runHealthCheck(config = {
   };
   let sessions = [];
   try {
-    const output = execSync4(
+    const output = execSync5(
       'tmux list-sessions -F "#{session_name}" 2>/dev/null || true',
       { encoding: "utf-8" }
     );
@@ -2345,8 +3097,8 @@ async function runHealthCheck(config = {
   } 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);
+    const { readdirSync: readdirSync13 } = await import("fs");
+    const dirs = readdirSync13(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);
@@ -2444,20 +3196,20 @@ async function healthCommand(action, arg, options = {}) {
   };
   switch (action) {
     case "check": {
-      console.log(chalk18.bold("Running health check...\n"));
+      console.log(chalk19.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}`);
+      console.log(`  ${chalk19.green("\u2705 Healthy:")} ${results.healthy}`);
+      console.log(`  ${chalk19.yellow("\u26A0\uFE0F Warning:")} ${results.warning}`);
+      console.log(`  ${chalk19.hex("#FFA500")("\u{1F7E0} Stuck:")} ${results.stuck}`);
+      console.log(`  ${chalk19.red("\u274C Dead:")} ${results.dead}`);
       if (results.recovered.length > 0) {
         console.log("");
-        console.log(chalk18.green("Recovered agents:"));
+        console.log(chalk19.green("Recovered agents:"));
         for (const agentId of results.recovered) {
           console.log(`  - ${agentId}`);
         }
@@ -2467,7 +3219,7 @@ async function healthCommand(action, arg, options = {}) {
     case "status": {
       const agents = listRunningAgents();
       if (agents.length === 0) {
-        console.log(chalk18.dim("No agents found."));
+        console.log(chalk19.dim("No agents found."));
         return;
       }
       const healthData = agents.map((agent) => {
@@ -2478,7 +3230,7 @@ async function healthCommand(action, arg, options = {}) {
         console.log(JSON.stringify(healthData.map((d) => d.health), null, 2));
         return;
       }
-      console.log(chalk18.bold("Agent Health Status:\n"));
+      console.log(chalk19.bold("Agent Health Status:\n"));
       for (const { health } of healthData) {
         console.log(formatHealthStatus(health));
         console.log("");
@@ -2487,12 +3239,12 @@ async function healthCommand(action, arg, options = {}) {
     }
     case "ping": {
       if (!arg) {
-        console.log(chalk18.red("Agent ID required"));
-        console.log(chalk18.dim("Usage: pan work health ping <agent-id>"));
+        console.log(chalk19.red("Agent ID required"));
+        console.log(chalk19.dim("Usage: pan work health ping <agent-id>"));
         return;
       }
       const agentId = arg.startsWith("agent-") ? arg : `agent-${arg.toLowerCase()}`;
-      console.log(chalk18.dim(`Pinging ${agentId}...`));
+      console.log(chalk19.dim(`Pinging ${agentId}...`));
       const health = pingAgent(agentId, config);
       if (options.json) {
         console.log(JSON.stringify(health, null, 2));
@@ -2504,12 +3256,12 @@ async function healthCommand(action, arg, options = {}) {
     }
     case "recover": {
       if (!arg) {
-        console.log(chalk18.red("Agent ID required"));
-        console.log(chalk18.dim("Usage: pan work health recover <agent-id>"));
+        console.log(chalk19.red("Agent ID required"));
+        console.log(chalk19.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}...`));
+      console.log(chalk19.dim(`Attempting recovery of ${agentId}...`));
       const forceConfig = { ...config, consecutiveFailures: 0 };
       const result = await handleStuckAgent(agentId, forceConfig);
       if (options.json) {
@@ -2517,21 +3269,21 @@ async function healthCommand(action, arg, options = {}) {
         return;
       }
       if (result.action === "recovered") {
-        console.log(chalk18.green(`\u2705 ${result.reason}`));
+        console.log(chalk19.green(`\u2705 ${result.reason}`));
       } else if (result.action === "cooldown") {
-        console.log(chalk18.yellow(`\u26A0\uFE0F ${result.reason}`));
+        console.log(chalk19.yellow(`\u26A0\uFE0F ${result.reason}`));
       } else {
-        console.log(chalk18.dim(result.reason));
+        console.log(chalk19.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(chalk19.bold("Starting Panopticon Health Daemon"));
+      console.log(chalk19.dim(`Check interval: ${config.checkIntervalMs / 1e3}s`));
+      console.log(chalk19.dim(`Failure threshold: ${config.consecutiveFailures}`));
+      console.log(chalk19.dim(`Cooldown: ${config.cooldownMs / (1e3 * 60)}m`));
       console.log("");
-      console.log(chalk18.dim("Press Ctrl+C to stop...\n"));
+      console.log(chalk19.dim("Press Ctrl+C to stop...\n"));
       const stop = startHealthDaemon(config, (results) => {
         const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
         const statusParts = [
@@ -2542,12 +3294,12 @@ async function healthCommand(action, arg, options = {}) {
           `\u274C${results.dead}`
         ];
         if (results.recovered.length > 0) {
-          statusParts.push(chalk18.green(`+${results.recovered.length} recovered`));
+          statusParts.push(chalk19.green(`+${results.recovered.length} recovered`));
         }
         console.log(statusParts.join(" "));
       });
       process.on("SIGINT", () => {
-        console.log("\n" + chalk18.dim("Stopping health daemon..."));
+        console.log("\n" + chalk19.dim("Stopping health daemon..."));
         stop();
         process.exit(0);
       });
@@ -2556,19 +3308,19 @@ async function healthCommand(action, arg, options = {}) {
       break;
     }
     default:
-      console.log(chalk18.bold("Health Monitoring Commands:"));
+      console.log(chalk19.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(`  ${chalk19.cyan("pan work health check")}         - Run single health check`);
+      console.log(`  ${chalk19.cyan("pan work health status")}        - Show all agent health`);
+      console.log(`  ${chalk19.cyan("pan work health ping <id>")}     - Ping specific agent`);
+      console.log(`  ${chalk19.cyan("pan work health recover <id>")}  - Force recover agent`);
+      console.log(`  ${chalk19.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(chalk19.bold("Options:"));
+      console.log(`  ${chalk19.dim("--json")}               Output as JSON`);
+      console.log(`  ${chalk19.dim("--interval <sec>")}     Check interval for daemon (default: 30)`);
       console.log("");
-      console.log(chalk18.bold("Deacon Pattern Defaults:"));
+      console.log(chalk19.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`);
@@ -2585,8 +3337,8 @@ function registerWorkCommands(program2) {
   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("plan <id>").description("Create execution plan before spawning").option("-o, --output <path>", "Output file path").option("--json", "Output as JSON").option("--skip-discovery", "Skip interactive discovery phase").option("--force", "Force planning even for simple issues").action(planCommand);
+  work.command("list").description("List issues from configured trackers").option("--all", "Include closed issues").option("--mine", "Show only my assigned issues").option("--json", "Output as JSON").option("--tracker <type>", "Query specific tracker (linear/github/gitlab)").option("--all-trackers", "Query all configured trackers").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);
@@ -2605,17 +3357,17 @@ function registerWorkCommands(program2) {
 }
 
 // src/cli/commands/workspace.ts
-import chalk19 from "chalk";
+import chalk20 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";
+import { existsSync as existsSync16, mkdirSync as mkdirSync11, writeFileSync as writeFileSync9 } from "fs";
+import { join as join15, 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";
+import { execSync as execSync6 } from "child_process";
+import { mkdirSync as mkdirSync9 } from "fs";
+import { dirname as dirname4 } from "path";
 function listWorktrees(repoPath) {
-  const output = execSync5("git worktree list --porcelain", {
+  const output = execSync6("git worktree list --porcelain", {
     cwd: repoPath,
     encoding: "utf8"
   });
@@ -2637,32 +3389,32 @@ function listWorktrees(repoPath) {
   return worktrees;
 }
 function createWorktree(repoPath, targetPath, branchName) {
-  mkdirSync7(dirname(targetPath), { recursive: true });
+  mkdirSync9(dirname4(targetPath), { recursive: true });
   try {
-    execSync5(`git show-ref --verify --quiet refs/heads/${branchName}`, {
+    execSync6(`git show-ref --verify --quiet refs/heads/${branchName}`, {
       cwd: repoPath
     });
-    execSync5(`git worktree add "${targetPath}" "${branchName}"`, {
+    execSync6(`git worktree add "${targetPath}" "${branchName}"`, {
       cwd: repoPath,
       stdio: "pipe"
     });
   } catch {
-    execSync5(`git worktree add -b "${branchName}" "${targetPath}"`, {
+    execSync6(`git worktree add -b "${branchName}" "${targetPath}"`, {
       cwd: repoPath,
       stdio: "pipe"
     });
   }
 }
 function removeWorktree(repoPath, worktreePath) {
-  execSync5(`git worktree remove "${worktreePath}" --force`, {
+  execSync6(`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";
+import { readFileSync as readFileSync13, existsSync as existsSync14, readdirSync as readdirSync9 } from "fs";
+import { join as join13 } from "path";
 function loadTemplate(templatePath) {
   if (!existsSync14(templatePath)) {
     throw new Error(`Template not found: ${templatePath}`);
@@ -2688,17 +3440,17 @@ function generateClaudeMd(projectPath, variables) {
     "warnings.md"
   ];
   for (const section of defaultOrder) {
-    const sectionPath = join12(CLAUDE_MD_TEMPLATES, section);
+    const sectionPath = join13(CLAUDE_MD_TEMPLATES, section);
     if (existsSync14(sectionPath)) {
       const content = loadTemplate(sectionPath);
       sections.push(substituteVariables(content, variables));
     }
   }
-  const projectSections = join12(projectPath, ".panopticon", "claude-md", "sections");
+  const projectSections = join13(projectPath, ".panopticon", "claude-md", "sections");
   if (existsSync14(projectSections)) {
-    const projectFiles = readdirSync7(projectSections).filter((f) => f.endsWith(".md")).sort();
+    const projectFiles = readdirSync9(projectSections).filter((f) => f.endsWith(".md")).sort();
     for (const file of projectFiles) {
-      const content = loadTemplate(join12(projectSections, file));
+      const content = loadTemplate(join13(projectSections, file));
       sections.push(substituteVariables(content, variables));
     }
   }
@@ -2720,15 +3472,15 @@ This workspace was created by Panopticon. Use \`bd\` commands to track your work
 // src/lib/skills-merge.ts
 import {
   existsSync as existsSync15,
-  readdirSync as readdirSync8,
+  readdirSync as readdirSync10,
   lstatSync,
   readlinkSync,
   symlinkSync,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync10,
   appendFileSync as appendFileSync2
 } from "fs";
-import { join as join13 } from "path";
-import { execSync as execSync6 } from "child_process";
+import { join as join14 } from "path";
+import { execSync as execSync7 } from "child_process";
 function detectContentOrigin(path, repoPath) {
   try {
     const stat = lstatSync(path);
@@ -2739,7 +3491,7 @@ function detectContentOrigin(path, repoPath) {
       }
     }
     try {
-      execSync6(`git ls-files --error-unmatch "${path}" 2>/dev/null`, {
+      execSync7(`git ls-files --error-unmatch "${path}" 2>/dev/null`, {
         cwd: repoPath,
         stdio: "pipe"
       });
@@ -2752,21 +3504,21 @@ function detectContentOrigin(path, repoPath) {
   }
 }
 function mergeSkillsIntoWorkspace(workspacePath) {
-  const skillsTarget = join13(workspacePath, ".claude", "skills");
+  const skillsTarget = join14(workspacePath, ".claude", "skills");
   const added = [];
   const skipped = [];
-  mkdirSync8(skillsTarget, { recursive: true });
+  mkdirSync10(skillsTarget, { recursive: true });
   const existingSkills = /* @__PURE__ */ new Set();
   if (existsSync15(skillsTarget)) {
-    for (const item of readdirSync8(skillsTarget)) {
+    for (const item of readdirSync10(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);
+  const panopticonSkills = readdirSync10(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);
+    const targetPath = join14(skillsTarget, skill);
+    const sourcePath = join14(SKILLS_DIR, skill);
     if (existingSkills.has(skill)) {
       const origin = detectContentOrigin(targetPath, workspacePath);
       if (origin === "git-tracked") {
@@ -2792,7 +3544,7 @@ function mergeSkillsIntoWorkspace(workspacePath) {
   return { added, skipped };
 }
 function updateGitignore(skillsDir, skills) {
-  const gitignorePath = join13(skillsDir, ".gitignore");
+  const gitignorePath = join14(skillsDir, ".gitignore");
   const content = `# Panopticon-managed symlinks (not committed)
 ${skills.join("\n")}
 `;
@@ -2816,17 +3568,17 @@ async function createCommand(issueId, options) {
     const branchName = `feature/${normalizedId}`;
     const folderName = `feature-${normalizedId}`;
     const projectRoot = process.cwd();
-    const workspacesDir = join14(projectRoot, "workspaces");
-    const workspacePath = join14(workspacesDir, folderName);
+    const workspacesDir = join15(projectRoot, "workspaces");
+    const workspacePath = join15(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"))}`);
+      console.log(chalk20.bold("Would create:"));
+      console.log(`  Workspace: ${chalk20.cyan(workspacePath)}`);
+      console.log(`  Branch:    ${chalk20.cyan(branchName)}`);
+      console.log(`  CLAUDE.md: ${chalk20.dim(join15(workspacePath, "CLAUDE.md"))}`);
       if (options.skills !== false) {
-        console.log(`  Skills:    ${chalk19.dim(join14(workspacePath, ".claude", "skills"))}`);
+        console.log(`  Skills:    ${chalk20.dim(join15(workspacePath, ".claude", "skills"))}`);
       }
       return;
     }
@@ -2834,7 +3586,7 @@ async function createCommand(issueId, options) {
       spinner.fail(`Workspace already exists: ${workspacePath}`);
       process.exit(1);
     }
-    if (!existsSync16(join14(projectRoot, ".git"))) {
+    if (!existsSync16(join15(projectRoot, ".git"))) {
       spinner.fail("Not a git repository. Run this from the project root.");
       process.exit(1);
     }
@@ -2850,28 +3602,28 @@ async function createCommand(issueId, options) {
       API_URL: `https://api-${folderName}.localhost:8080`
     };
     const claudeMd = generateClaudeMd(projectRoot, variables);
-    writeFileSync9(join14(workspacePath, "CLAUDE.md"), claudeMd);
+    writeFileSync9(join15(workspacePath, "CLAUDE.md"), claudeMd);
     let skillsResult = { added: [], skipped: [] };
     if (options.skills !== false) {
       spinner.text = "Merging skills...";
-      mkdirSync9(join14(workspacePath, ".claude", "skills"), { recursive: true });
+      mkdirSync11(join15(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(chalk20.bold("Workspace Details:"));
+    console.log(`  Path:   ${chalk20.cyan(workspacePath)}`);
+    console.log(`  Branch: ${chalk20.dim(branchName)}`);
     console.log("");
     if (options.skills !== false) {
-      console.log(chalk19.bold("Skills:"));
+      console.log(chalk20.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(`  Skipped: ${chalk20.dim(skillsResult.skipped.join(", "))}`);
       }
       console.log("");
     }
-    console.log(chalk19.dim(`Next: cd ${workspacePath}`));
+    console.log(chalk20.dim(`Next: cd ${workspacePath}`));
   } catch (error) {
     spinner.fail(error.message);
     process.exit(1);
@@ -2879,8 +3631,8 @@ async function createCommand(issueId, options) {
 }
 async function listCommand2(options) {
   const projectRoot = process.cwd();
-  if (!existsSync16(join14(projectRoot, ".git"))) {
-    console.error(chalk19.red("Not a git repository."));
+  if (!existsSync16(join15(projectRoot, ".git"))) {
+    console.error(chalk20.red("Not a git repository."));
     process.exit(1);
   }
   const worktrees = listWorktrees(projectRoot);
@@ -2892,17 +3644,17 @@ async function listCommand2(options) {
     return;
   }
   if (workspaces.length === 0) {
-    console.log(chalk19.dim("No workspaces found."));
-    console.log(chalk19.dim("Create one with: pan workspace create <issue-id>"));
+    console.log(chalk20.dim("No workspaces found."));
+    console.log(chalk20.dim("Create one with: pan workspace create <issue-id>"));
     return;
   }
-  console.log(chalk19.bold("\nWorkspaces\n"));
+  console.log(chalk20.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)}`);
+    const status = ws.prunable ? chalk20.yellow(" (prunable)") : "";
+    console.log(`${chalk20.cyan(name)}${status}`);
+    console.log(`  Branch: ${ws.branch || chalk20.dim("(detached)")}`);
+    console.log(`  Path:   ${chalk20.dim(ws.path)}`);
     console.log("");
   }
 }
@@ -2912,7 +3664,7 @@ async function destroyCommand(issueId, options) {
     const normalizedId = issueId.toLowerCase().replace(/[^a-z0-9-]/g, "-");
     const folderName = `feature-${normalizedId}`;
     const projectRoot = process.cwd();
-    const workspacePath = join14(projectRoot, "workspaces", folderName);
+    const workspacePath = join15(projectRoot, "workspaces", folderName);
     if (!existsSync16(workspacePath)) {
       spinner.fail(`Workspace not found: ${workspacePath}`);
       process.exit(1);
@@ -2923,19 +3675,19 @@ async function destroyCommand(issueId, options) {
   } catch (error) {
     spinner.fail(error.message);
     if (!options.force) {
-      console.log(chalk19.dim("Tip: Use --force to remove even with uncommitted changes"));
+      console.log(chalk20.dim("Tip: Use --force to remove even with uncommitted changes"));
     }
     process.exit(1);
   }
 }
 
 // src/cli/commands/install.ts
-import chalk20 from "chalk";
+import chalk21 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";
+import { execSync as execSync8 } from "child_process";
+import { existsSync as existsSync17, mkdirSync as mkdirSync12, writeFileSync as writeFileSync10, readFileSync as readFileSync14, copyFileSync, readdirSync as readdirSync11, statSync } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir4, 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);
 }
@@ -2953,9 +3705,26 @@ function detectPlatform() {
   }
   return os;
 }
+function copyDirectoryRecursive(source, dest) {
+  if (!existsSync17(source)) {
+    throw new Error(`Source directory not found: ${source}`);
+  }
+  mkdirSync12(dest, { recursive: true });
+  const entries = readdirSync11(source);
+  for (const entry of entries) {
+    const sourcePath = join16(source, entry);
+    const destPath = join16(dest, entry);
+    const stat = statSync(sourcePath);
+    if (stat.isDirectory()) {
+      copyDirectoryRecursive(sourcePath, destPath);
+    } else {
+      copyFileSync(sourcePath, destPath);
+    }
+  }
+}
 function checkCommand(cmd) {
   try {
-    execSync7(`which ${cmd}`, { stdio: "pipe" });
+    execSync8(`which ${cmd}`, { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -2982,7 +3751,7 @@ function checkPrerequisites() {
   let dockerRunning = false;
   if (hasDocker) {
     try {
-      execSync7("docker info", { stdio: "pipe" });
+      execSync8("docker info", { stdio: "pipe" });
       dockerRunning = true;
     } catch {
     }
@@ -3014,27 +3783,34 @@ function checkPrerequisites() {
     message: hasBeads ? "installed" : "not found",
     fix: "cargo install beads-cli"
   });
+  const hasTtyd = checkCommand("ttyd") || existsSync17(join16(homedir4(), "bin", "ttyd"));
+  results.push({
+    name: "ttyd",
+    passed: hasTtyd,
+    message: hasTtyd ? "installed" : "not found",
+    fix: "brew install ttyd / Download from https://github.com/tsl0922/ttyd/releases"
+  });
   return {
     results,
-    allPassed: results.filter((r) => r.name !== "mkcert").every((r) => r.passed)
+    allPassed: results.filter((r) => r.name !== "mkcert" && r.name !== "ttyd").every((r) => r.passed)
   };
 }
 function printPrereqStatus(prereqs) {
-  console.log(chalk20.bold("Prerequisites:\n"));
+  console.log(chalk21.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);
+    const icon = result.passed ? chalk21.green("\u2713") : chalk21.red("\u2717");
+    const msg = result.passed ? chalk21.dim(result.message) : chalk21.yellow(result.message);
     console.log(`  ${icon} ${result.name}: ${msg}`);
     if (!result.passed && result.fix) {
-      console.log(`    ${chalk20.dim("\u2192 " + result.fix)}`);
+      console.log(`    ${chalk21.dim("\u2192 " + result.fix)}`);
     }
   }
   console.log("");
 }
 async function installCommand(options) {
-  console.log(chalk20.bold("\nPanopticon Installation\n"));
+  console.log(chalk21.bold("\nPanopticon Installation\n"));
   const plat = detectPlatform();
-  console.log(`Platform: ${chalk20.cyan(plat)}
+  console.log(`Platform: ${chalk21.cyan(plat)}
 `);
   const prereqs = checkPrerequisites();
   if (options.check) {
@@ -3043,19 +3819,19 @@ async function installCommand(options) {
   }
   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"));
+    console.log(chalk21.red("Fix prerequisites above before continuing."));
+    console.log(chalk21.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 });
+    mkdirSync12(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" });
+      execSync8("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)");
@@ -3066,14 +3842,20 @@ async function installCommand(options) {
     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`,
+        execSync8("mkcert -install", { stdio: "pipe" });
+        spinner.succeed("mkcert CA installed");
+        spinner.start("Generating wildcard certificates...");
+        const traefikCertFile = join16(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost.pem");
+        const traefikKeyFile = join16(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost-key.pem");
+        execSync8(
+          `mkcert -cert-file "${traefikCertFile}" -key-file "${traefikKeyFile}" "*.pan.localhost" "*.localhost" localhost 127.0.0.1 ::1`,
           { stdio: "pipe" }
         );
-        spinner.succeed("mkcert certificates generated");
+        const legacyCertFile = join16(CERTS_DIR, "localhost.pem");
+        const legacyKeyFile = join16(CERTS_DIR, "localhost-key.pem");
+        copyFileSync(traefikCertFile, legacyCertFile);
+        copyFileSync(traefikKeyFile, legacyKeyFile);
+        spinner.succeed("Wildcard certificates generated (*.pan.localhost, *.localhost)");
       } catch (error) {
         spinner.warn("mkcert setup failed (HTTPS may not work)");
       }
@@ -3081,9 +3863,60 @@ async function installCommand(options) {
       spinner.info("Skipping mkcert (not installed)");
     }
   }
-  const configFile = join15(PANOPTICON_HOME, "config.toml");
+  const hasTtyd = checkCommand("ttyd") || existsSync17(join16(homedir4(), "bin", "ttyd"));
+  if (!hasTtyd) {
+    spinner.start("Installing ttyd (web terminal)...");
+    try {
+      const binDir = join16(homedir4(), "bin");
+      mkdirSync12(binDir, { recursive: true });
+      const ttydPath = join16(binDir, "ttyd");
+      const plat2 = detectPlatform();
+      let downloadUrl = "";
+      if (plat2 === "darwin") {
+        try {
+          execSync8("brew install ttyd", { stdio: "pipe" });
+          spinner.succeed("ttyd installed via Homebrew");
+        } catch {
+          spinner.warn("ttyd installation failed - install manually: brew install ttyd");
+        }
+      } else {
+        downloadUrl = "https://github.com/tsl0922/ttyd/releases/latest/download/ttyd.x86_64";
+        try {
+          execSync8(`curl -sL "${downloadUrl}" -o "${ttydPath}" && chmod +x "${ttydPath}"`, {
+            stdio: "pipe",
+            timeout: 6e4
+          });
+          spinner.succeed(`ttyd installed to ${ttydPath}`);
+        } catch (error) {
+          spinner.warn("ttyd download failed - install manually from https://github.com/tsl0922/ttyd/releases");
+        }
+      }
+    } catch (error) {
+      spinner.warn("ttyd installation failed (planning sessions will not work)");
+    }
+  } else {
+    spinner.info("ttyd already installed");
+  }
+  if (!options.minimal) {
+    spinner.start("Setting up Traefik configuration...");
+    try {
+      if (!existsSync17(join16(TRAEFIK_DIR, "docker-compose.yml"))) {
+        copyDirectoryRecursive(SOURCE_TRAEFIK_TEMPLATES, TRAEFIK_DIR);
+        spinner.succeed("Traefik configuration created from templates");
+      } else {
+        spinner.info("Traefik configuration already exists (skipping)");
+      }
+    } catch (error) {
+      spinner.fail(`Failed to set up Traefik configuration: ${error}`);
+      console.log(chalk21.yellow("You can set up Traefik manually later"));
+    }
+  }
+  const configFile = join16(PANOPTICON_HOME, "config.toml");
   if (!existsSync17(configFile)) {
     spinner.start("Creating default config...");
+    const traefikConfig = options.minimal ? "enabled = false" : `enabled = true
+dashboard_port = 8080
+domain = "pan.localhost"`;
     writeFileSync10(
       configFile,
       `# Panopticon configuration
@@ -3095,6 +3928,9 @@ default_runtime = "claude"
 port = 3001
 api_port = 3002
 
+[traefik]
+${traefikConfig}
+
 [sync]
 auto_sync = true
 strategy = "symlink"
@@ -3107,20 +3943,27 @@ consecutive_failures = 3
     spinner.succeed("Config created");
   }
   console.log("");
-  console.log(chalk20.green.bold("Installation complete!"));
+  console.log(chalk21.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(chalk21.bold("Next steps:"));
+  console.log(`  1. Run ${chalk21.cyan("pan sync")} to sync skills to ~/.claude/`);
+  if (!options.minimal) {
+    console.log(`  2. Add to ${chalk21.yellow("/etc/hosts")}: ${chalk21.cyan("127.0.0.1 pan.localhost")}`);
+    console.log(`  3. Run ${chalk21.cyan("pan up")} to start Traefik and dashboard`);
+    console.log(`  4. Access dashboard at ${chalk21.cyan("https://pan.localhost")}`);
+  } else {
+    console.log(`  2. Run ${chalk21.cyan("pan up")} to start the dashboard`);
+    console.log(`  3. Access dashboard at ${chalk21.cyan("http://localhost:3001")}`);
+  }
+  console.log(`  ${!options.minimal ? "5" : "4"}. Create a workspace with ${chalk21.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");
+import chalk22 from "chalk";
+import { existsSync as existsSync18, readFileSync as readFileSync15, writeFileSync as writeFileSync11, mkdirSync as mkdirSync13 } from "fs";
+import { join as join17, resolve } from "path";
+var PROJECTS_FILE = join17(PANOPTICON_HOME, "projects.json");
 function loadProjects() {
   if (!existsSync18(PROJECTS_FILE)) {
     return [];
@@ -3132,25 +3975,25 @@ function loadProjects() {
   }
 }
 function saveProjects(projects) {
-  mkdirSync11(PANOPTICON_HOME, { recursive: true });
+  mkdirSync13(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}`));
+    console.log(chalk22.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}`));
+    console.log(chalk22.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");
+    const projectToml = join17(fullPath, ".panopticon", "project.toml");
     if (existsSync18(projectToml)) {
       const content = readFileSync15(projectToml, "utf-8");
       const match = content.match(/team\s*=\s*"([^"]+)"/);
@@ -3166,33 +4009,33 @@ async function projectAddCommand(projectPath, options = {}) {
   };
   projects.push(project2);
   saveProjects(projects);
-  console.log(chalk21.green(`\u2713 Added project: ${name}`));
-  console.log(chalk21.dim(`  Path: ${fullPath}`));
+  console.log(chalk22.green(`\u2713 Added project: ${name}`));
+  console.log(chalk22.dim(`  Path: ${fullPath}`));
   if (linearTeam) {
-    console.log(chalk21.dim(`  Linear team: ${linearTeam}`));
+    console.log(chalk22.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>"));
+    console.log(chalk22.dim("No projects registered."));
+    console.log(chalk22.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"));
+  console.log(chalk22.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)}`);
+    const statusIcon = exists ? chalk22.green("\u2713") : chalk22.red("\u2717");
+    console.log(`${statusIcon} ${chalk22.bold(project2.name)}`);
+    console.log(`  ${chalk22.dim(project2.path)}`);
     if (project2.linearTeam) {
-      console.log(`  ${chalk21.cyan(`Linear: ${project2.linearTeam}`)}`);
+      console.log(`  ${chalk22.cyan(`Linear: ${project2.linearTeam}`)}`);
     }
-    console.log(`  ${chalk21.dim(`Type: ${project2.type}`)}`);
+    console.log(`  ${chalk22.dim(`Type: ${project2.type}`)}`);
     console.log("");
   }
 }
@@ -3202,23 +4045,23 @@ async function projectRemoveCommand(nameOrPath) {
     (p) => p.name === nameOrPath || p.path === resolve(nameOrPath)
   );
   if (index === -1) {
-    console.log(chalk21.red(`Project not found: ${nameOrPath}`));
+    console.log(chalk22.red(`Project not found: ${nameOrPath}`));
     return;
   }
   const removed = projects.splice(index, 1)[0];
   saveProjects(projects);
-  console.log(chalk21.green(`\u2713 Removed project: ${removed.name}`));
+  console.log(chalk22.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";
+import chalk23 from "chalk";
+import { existsSync as existsSync19, readdirSync as readdirSync12 } from "fs";
+import { execSync as execSync9 } from "child_process";
+import { homedir as homedir5 } from "os";
+import { join as join18 } from "path";
 function checkCommand2(cmd) {
   try {
-    execSync8(`which ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
+    execSync9(`which ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -3230,14 +4073,14 @@ function checkDirectory(path) {
 function countItems(path) {
   if (!existsSync19(path)) return 0;
   try {
-    return readdirSync9(path).length;
+    return readdirSync12(path).length;
   } catch {
     return 0;
   }
 }
 async function doctorCommand() {
-  console.log(chalk22.bold("\nPanopticon Doctor\n"));
-  console.log(chalk22.dim("Checking system health...\n"));
+  console.log(chalk23.bold("\nPanopticon Doctor\n"));
+  console.log(chalk23.dim("Checking system health...\n"));
   const checks = [];
   const requiredCommands = [
     { cmd: "git", name: "Git", fix: "Install git" },
@@ -3279,8 +4122,8 @@ async function doctorCommand() {
     }
   }
   if (checkDirectory(CLAUDE_DIR)) {
-    const skillsCount = countItems(join17(CLAUDE_DIR, "skills"));
-    const commandsCount = countItems(join17(CLAUDE_DIR, "commands"));
+    const skillsCount = countItems(join18(CLAUDE_DIR, "skills"));
+    const commandsCount = countItems(join18(CLAUDE_DIR, "commands"));
     checks.push({
       name: "Claude Code Skills",
       status: skillsCount > 0 ? "ok" : "warn",
@@ -3301,7 +4144,7 @@ async function doctorCommand() {
       fix: "Install Claude Code first"
     });
   }
-  const envFile = join17(homedir6(), ".panopticon.env");
+  const envFile = join18(homedir5(), ".panopticon.env");
   if (existsSync19(envFile)) {
     checks.push({ name: "Config File", status: "ok", message: "~/.panopticon.env exists" });
   } else {
@@ -3335,7 +4178,7 @@ async function doctorCommand() {
     });
   }
   try {
-    const sessions = execSync8("tmux list-sessions 2>/dev/null || true", { encoding: "utf-8" });
+    const sessions = execSync9("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",
@@ -3350,52 +4193,175 @@ async function doctorCommand() {
     });
   }
   const icons = {
-    ok: chalk22.green("\u2713"),
-    warn: chalk22.yellow("\u26A0"),
-    error: chalk22.red("\u2717")
+    ok: chalk23.green("\u2713"),
+    warn: chalk23.yellow("\u26A0"),
+    error: chalk23.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);
+    const message = check.status === "error" ? chalk23.red(check.message) : check.status === "warn" ? chalk23.yellow(check.message) : chalk23.dim(check.message);
     console.log(`${icon} ${check.name}: ${message}`);
     if (check.fix && check.status !== "ok") {
-      console.log(chalk22.dim(`  Fix: ${check.fix}`));
+      console.log(chalk23.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."));
+    console.log(chalk23.red("Some required components are missing."));
+    console.log(chalk23.dim("Fix the errors above before using Panopticon."));
   } else if (hasWarnings) {
-    console.log(chalk22.yellow("System is functional with some optional features missing."));
+    console.log(chalk23.yellow("System is functional with some optional features missing."));
   } else {
-    console.log(chalk22.green("All systems operational!"));
+    console.log(chalk23.green("All systems operational!"));
   }
   console.log("");
 }
 
+// src/cli/commands/update.ts
+import { execSync as execSync10 } from "child_process";
+import chalk24 from "chalk";
+function getCurrentVersion() {
+  try {
+    const pkg = require_package();
+    return pkg.version;
+  } catch {
+    return "unknown";
+  }
+}
+async function getLatestVersion() {
+  try {
+    const result = execSync10("npm view panopticon-cli version", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim();
+  } catch {
+    throw new Error("Failed to check npm for latest version");
+  }
+}
+function isNewer(latest, current) {
+  const parseVersion = (v) => {
+    const parts = v.replace(/^v/, "").split(".");
+    return {
+      major: parseInt(parts[0] || "0", 10),
+      minor: parseInt(parts[1] || "0", 10),
+      patch: parseInt(parts[2] || "0", 10)
+    };
+  };
+  const l = parseVersion(latest);
+  const c = parseVersion(current);
+  if (l.major !== c.major) return l.major > c.major;
+  if (l.minor !== c.minor) return l.minor > c.minor;
+  return l.patch > c.patch;
+}
+async function updateCommand(options) {
+  console.log(chalk24.bold("Panopticon Update\n"));
+  const currentVersion = getCurrentVersion();
+  console.log(`Current version: ${chalk24.cyan(currentVersion)}`);
+  let latestVersion;
+  try {
+    console.log(chalk24.dim("Checking npm for latest version..."));
+    latestVersion = await getLatestVersion();
+    console.log(`Latest version:  ${chalk24.cyan(latestVersion)}`);
+  } catch (error) {
+    console.error(chalk24.red("Failed to check for updates"));
+    console.error(chalk24.dim("Make sure you have internet connectivity"));
+    process.exit(1);
+  }
+  const needsUpdate = isNewer(latestVersion, currentVersion);
+  if (!needsUpdate) {
+    console.log(chalk24.green("\n\u2713 You are on the latest version"));
+    return;
+  }
+  console.log(
+    chalk24.yellow(`
+\u2191 Update available: ${currentVersion} \u2192 ${latestVersion}`)
+  );
+  if (options.check) {
+    console.log(chalk24.dim("\nRun `pan update` to install"));
+    return;
+  }
+  console.log(chalk24.dim("\nUpdating Panopticon..."));
+  try {
+    execSync10("npm install -g panopticon-cli@latest", {
+      stdio: "inherit"
+    });
+    console.log(chalk24.green(`
+\u2713 Updated to ${latestVersion}`));
+    const config = loadConfig();
+    if (config.sync.auto_sync) {
+      console.log(chalk24.dim("\nRunning auto-sync..."));
+      await syncCommand({});
+    }
+    console.log(chalk24.dim("\nRestart any running agents to use the new version."));
+  } catch (error) {
+    console.error(chalk24.red("\nUpdate failed"));
+    console.error(
+      chalk24.dim("Try running with sudo: sudo npm install -g panopticon-cli@latest")
+    );
+    process.exit(1);
+  }
+}
+
 // src/cli/index.ts
 var program = new Command();
-program.name("pan").description("Multi-agent orchestration for AI coding assistants").version("0.1.0");
+program.name("pan").description("Multi-agent orchestration for AI coding assistants").version("0.1.3");
 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);
+var backup = program.command("backup").description("Manage backups");
+backup.command("list").description("List all backups").option("--json", "Output as JSON").action(backupListCommand);
+backup.command("clean").description("Remove old backups").option("--keep <count>", "Number of backups to keep", "10").action(backupCleanCommand);
 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"));
+program.command("up").description("Start dashboard (and Traefik if enabled)").option("--detach", "Run in background").option("--skip-traefik", "Skip Traefik startup").action(async (options) => {
+  const { spawn, execSync: execSync11 } = await import("child_process");
+  const { join: join19, dirname: dirname5 } = await import("path");
+  const { fileURLToPath: fileURLToPath2 } = await import("url");
+  const { readFileSync: readFileSync16, existsSync: existsSync20 } = await import("fs");
+  const { parse } = await import("@iarna/toml");
+  const __dirname3 = dirname5(fileURLToPath2(import.meta.url));
+  const dashboardDir = join19(__dirname3, "..", "dashboard");
+  const configFile = join19(process.env.HOME || "", ".panopticon", "config.toml");
+  let traefikEnabled = false;
+  let traefikDomain = "pan.localhost";
+  if (existsSync20(configFile)) {
+    try {
+      const configContent = readFileSync16(configFile, "utf-8");
+      const config = parse(configContent);
+      traefikEnabled = config.traefik?.enabled === true;
+      traefikDomain = config.traefik?.domain || "pan.localhost";
+    } catch (error) {
+      console.log(chalk25.yellow("Warning: Could not read config.toml"));
+    }
+  }
+  console.log(chalk25.bold("Starting Panopticon...\n"));
+  if (traefikEnabled && !options.skipTraefik) {
+    const traefikDir = join19(process.env.HOME || "", ".panopticon", "traefik");
+    if (existsSync20(traefikDir)) {
+      try {
+        console.log(chalk25.dim("Starting Traefik..."));
+        execSync11("docker-compose up -d", {
+          cwd: traefikDir,
+          stdio: "pipe"
+        });
+        console.log(chalk25.green("\u2713 Traefik started"));
+        console.log(chalk25.dim(`  Dashboard: https://traefik.${traefikDomain}:8080
+`));
+      } catch (error) {
+        console.log(chalk25.yellow("\u26A0 Failed to start Traefik (continuing anyway)"));
+        console.log(chalk25.dim("  Run with --skip-traefik to suppress this message\n"));
+      }
+    }
+  }
+  console.log(chalk25.dim("Starting dashboard..."));
   if (options.detach) {
     const child = spawn("npm", ["run", "dev"], {
       cwd: dashboardDir,
@@ -3403,37 +4369,79 @@ program.command("up").description("Start dashboard").option("--detach", "Run in
       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")}`);
+    console.log(chalk25.green("\u2713 Dashboard started in background"));
+    if (traefikEnabled) {
+      console.log(`  Frontend: ${chalk25.cyan(`https://${traefikDomain}`)}`);
+      console.log(`  API:      ${chalk25.cyan(`https://${traefikDomain}/api`)}`);
+    } else {
+      console.log(`  Frontend: ${chalk25.cyan("http://localhost:3001")}`);
+      console.log(`  API:      ${chalk25.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"));
+    if (traefikEnabled) {
+      console.log(`  Frontend: ${chalk25.cyan(`https://${traefikDomain}`)}`);
+      console.log(`  API:      ${chalk25.cyan(`https://${traefikDomain}/api`)}`);
+    } else {
+      console.log(`  Frontend: ${chalk25.cyan("http://localhost:3001")}`);
+      console.log(`  API:      ${chalk25.cyan("http://localhost:3002")}`);
+    }
+    console.log(chalk25.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);
+      console.error(chalk25.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");
+program.command("down").description("Stop dashboard (and Traefik if enabled)").option("--skip-traefik", "Skip Traefik shutdown").action(async (options) => {
+  const { execSync: execSync11 } = await import("child_process");
+  const { join: join19 } = await import("path");
+  const { readFileSync: readFileSync16, existsSync: existsSync20 } = await import("fs");
+  const { parse } = await import("@iarna/toml");
+  console.log(chalk25.bold("Stopping Panopticon...\n"));
+  console.log(chalk25.dim("Stopping dashboard..."));
   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"));
+    execSync11("lsof -ti:3001 | xargs kill -9 2>/dev/null || true", { stdio: "pipe" });
+    execSync11("lsof -ti:3002 | xargs kill -9 2>/dev/null || true", { stdio: "pipe" });
+    console.log(chalk25.green("\u2713 Dashboard stopped"));
   } catch {
-    console.log(chalk23.dim("No dashboard processes found"));
+    console.log(chalk25.dim("  No dashboard processes found"));
+  }
+  const configFile = join19(process.env.HOME || "", ".panopticon", "config.toml");
+  let traefikEnabled = false;
+  if (existsSync20(configFile)) {
+    try {
+      const configContent = readFileSync16(configFile, "utf-8");
+      const config = parse(configContent);
+      traefikEnabled = config.traefik?.enabled === true;
+    } catch (error) {
+    }
   }
+  if (traefikEnabled && !options.skipTraefik) {
+    const traefikDir = join19(process.env.HOME || "", ".panopticon", "traefik");
+    if (existsSync20(traefikDir)) {
+      console.log(chalk25.dim("Stopping Traefik..."));
+      try {
+        execSync11("docker-compose down", {
+          cwd: traefikDir,
+          stdio: "pipe"
+        });
+        console.log(chalk25.green("\u2713 Traefik stopped"));
+      } catch (error) {
+        console.log(chalk25.yellow("\u26A0 Failed to stop Traefik"));
+      }
+    }
+  }
+  console.log("");
 });
 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.command("update").description("Update Panopticon to latest version").option("--check", "Only check for updates, don't install").option("--force", "Force update even if on latest").action(updateCommand);
 program.parse();
 //# sourceMappingURL=index.js.map