panopticon-cli 0.5.1 → 0.5.4

package/dist/cli/index.js

@@ -1,10 +1,19 @@
 #!/usr/bin/env node
 import {
+  checkBudget,
   checkSpecialistQueue,
   clearSessionId,
   completeSpecialistTask,
+  createBudget,
+  deleteBudget,
+  formatCost,
+  generateReport,
+  getAllBudgets,
+  getAllProjectSpecialistStatuses,
   getAllSpecialistStatus,
+  getDailySummary,
   getEnabledSpecialists,
+  getMonthlySummary,
   getNextSpecialistTask,
   getProjectDirs,
   getSessionFiles,
@@ -12,38 +21,47 @@ import {
   getSpecialistMetadata,
   getSpecialistStatus,
   getTmuxSessionName,
+  getWeeklySummary,
+  init_cost,
   init_jsonl_parser,
   init_specialists,
   initializeEnabledSpecialists,
   isRunning,
   parseClaudeSession,
+  readIssueCosts,
+  readTodayCosts,
   recordWake,
   setSessionId,
+  summarizeCosts,
   wakeSpecialist,
   wakeSpecialistOrQueue,
   wakeSpecialistWithTask
-} from "../chunk-OWHXCGVO.js";
+} from "../chunk-ID4OYXVH.js";
 import {
   cleanupTemplateFiles,
   ensureProjectCerts,
   generatePanopticonTraefikConfig,
   generateTlsConfig
-} from "../chunk-NLQRED36.js";
+} from "../chunk-KBHRXV5T.js";
 import {
   applyProjectTemplateOverlay,
   createWorkspace,
   init_skills_merge,
   init_workspace_manager,
   mergeSkillsIntoWorkspace,
-  removeWorkspace,
-  stopWorkspaceDocker
-} from "../chunk-F5555J3A.js";
-import "../chunk-7SN4L4PH.js";
+  removeWorkspace
+} from "../chunk-4HST45MO.js";
+import "../chunk-ZTYHZMEC.js";
+import "../chunk-HOGYHJ2G.js";
+import {
+  init_workspace_config,
+  replacePlaceholders
+} from "../chunk-MOPGR3CL.js";
 import {
   init_remote_agents,
   isRemoteAgentRunning,
   spawnRemoteAgent
-} from "../chunk-YLPSQAM2.js";
+} from "../chunk-565HZ6VV.js";
 import {
   autoRecoverAgents,
   detectCrashedAgents,
@@ -66,7 +84,7 @@ import {
   saveSessionId,
   spawnAgent,
   stopAgent
-} from "../chunk-VHKSS7QX.js";
+} from "../chunk-KY2E2Q3T.js";
 import {
   checkHook,
   clearHook,
@@ -83,7 +101,7 @@ import {
   sendKeysAsync,
   sendMail,
   sessionExists
-} from "../chunk-FTCPTHIJ.js";
+} from "../chunk-HRU7S4TA.js";
 import {
   createShadowState,
   getPendingSyncCount,
@@ -106,12 +124,15 @@ import {
 import {
   createExeProvider,
   init_exe_provider
-} from "../chunk-JM6V62LT.js";
+} from "../chunk-ZDNQFWR5.js";
 import {
+  closeDatabase,
+  getDatabase,
+  init_database,
   init_review_status,
   loadReviewStatuses,
   saveReviewStatuses
-} from "../chunk-YGJ54GW2.js";
+} from "../chunk-6N2KBSJA.js";
 import "../chunk-JQBV3Q2W.js";
 import {
   addAlias,
@@ -129,19 +150,17 @@ import {
   restoreBackup,
   syncHooks,
   syncStatusline
-} from "../chunk-4YSYJ4HM.js";
+} from "../chunk-DFNVHK3N.js";
 import "../chunk-AQXETQHW.js";
 import {
   createTracker,
   createTrackerFromConfig,
   init_factory
-} from "../chunk-76F6DSVS.js";
+} from "../chunk-T7BBPDEJ.js";
 import {
-  init_config_yaml,
   init_settings,
-  loadConfig as loadConfig2,
   loadSettings
-} from "../chunk-HJSM6E6U.js";
+} from "../chunk-USYP2SBE.js";
 import {
   getDashboardApiUrl,
   getDefaultConfig,
@@ -163,7 +182,11 @@ import {
   registerProject,
   resolveProjectFromIssue,
   unregisterProject
-} from "../chunk-2V4NF7J2.js";
+} from "../chunk-RLZQB7HS.js";
+import {
+  init_config_yaml,
+  loadConfig as loadConfig2
+} from "../chunk-ZP6EWSZV.js";
 import {
   NotImplementedError,
   init_interface
@@ -204,11 +227,6 @@ import {
   init_platform,
   syncDnsToWindows
 } from "../chunk-JT4O4YVM.js";
-import "../chunk-PELXV435.js";
-import {
-  init_workspace_config,
-  replacePlaceholders
-} from "../chunk-CWELWPWQ.js";
 import {
   __require,
   init_esm_shims
@@ -216,11 +234,11 @@ import {
 
 // src/cli/index.ts
 init_esm_shims();
-import { readFileSync as readFileSync48, existsSync as existsSync55 } from "fs";
-import { join as join55 } from "path";
-import { homedir as homedir26 } from "os";
-import { Command } from "commander";
-import chalk61 from "chalk";
+import { readFileSync as readFileSync49, existsSync as existsSync56 } from "fs";
+import { join as join56 } from "path";
+import { homedir as homedir27 } from "os";
+import { Command as Command2 } from "commander";
+import chalk62 from "chalk";
 
 // src/cli/commands/init.ts
 init_esm_shims();
@@ -933,9 +951,9 @@ init_agents();
 init_projects();
 import chalk6 from "chalk";
 import ora4 from "ora";
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { join as join8, dirname as dirname4 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join9, dirname as dirname4 } from "path";
+import { homedir as homedir4 } from "os";
 
 // src/lib/prd-draft.ts
 init_esm_shims();
@@ -949,6 +967,63 @@ function hasPRDDraft(issueId) {
   return existsSync5(getPRDDraftPath(issueId));
 }
 
+// src/lib/tracker-utils.ts
+init_esm_shims();
+init_projects();
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir3 } from "os";
+function parseGitHubRepos() {
+  const repos = [];
+  const envFile = join6(homedir3(), ".panopticon.env");
+  if (existsSync6(envFile)) {
+    const content = readFileSync4(envFile, "utf-8");
+    const reposMatch = content.match(/GITHUB_REPOS=(.+)/);
+    if (reposMatch) {
+      repos.push(...reposMatch[1].trim().split(",").map((r) => {
+        const [repoPath, prefix] = r.trim().split(":");
+        const [owner, repo] = (repoPath || "").split("/");
+        return { owner: owner || "", repo: repo || "", prefix: (prefix || "").toUpperCase() };
+      }).filter((r) => r.owner && r.repo && r.prefix));
+    }
+  }
+  if (repos.length === 0) {
+    try {
+      const { projects } = loadProjectsConfig();
+      for (const [, project2] of Object.entries(projects)) {
+        if (project2.github_repo) {
+          const [owner, repo] = project2.github_repo.split("/");
+          const prefix = project2.linear_team || "";
+          if (owner && repo && prefix) {
+            repos.push({ owner, repo, prefix: prefix.toUpperCase() });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return repos;
+}
+function extractIssuePrefix(issueId) {
+  return issueId.split("-")[0].toUpperCase();
+}
+function resolveGitHubIssue(issueId) {
+  const prefix = extractIssuePrefix(issueId);
+  const repos = parseGitHubRepos();
+  for (const repoConfig of repos) {
+    if (repoConfig.prefix === prefix) {
+      const number = parseInt(issueId.split("-")[1], 10);
+      if (!isNaN(number)) {
+        return { isGitHub: true, ...repoConfig, number };
+      }
+    }
+  }
+  return { isGitHub: false };
+}
+function isGitHubIssue(issueId) {
+  return resolveGitHubIssue(issueId).isGitHub;
+}
+
 // src/lib/shadow-mode.ts
 init_esm_shims();
 init_config_yaml();
@@ -1026,20 +1101,20 @@ async function isRemoteAvailable() {
 
 // src/lib/cloister/work-agent-prompt.ts
 init_esm_shims();
-import { existsSync as existsSync7, readFileSync as readFileSync5, readdirSync as readdirSync7, statSync as statSync3 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync7, statSync as statSync3 } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/template.ts
 init_esm_shims();
 init_paths();
-import { readFileSync as readFileSync4, existsSync as existsSync6, readdirSync as readdirSync6 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync7, readdirSync as readdirSync6 } from "fs";
+import { join as join7 } from "path";
 function loadTemplate(templatePath) {
-  if (!existsSync6(templatePath)) {
+  if (!existsSync7(templatePath)) {
     throw new Error(`Template not found: ${templatePath}`);
   }
-  return readFileSync4(templatePath, "utf8");
+  return readFileSync5(templatePath, "utf8");
 }
 function processEnvBlocks(template, env) {
   let result = template.replace(
@@ -1081,17 +1156,17 @@ function generateClaudeMd(projectPath, variables) {
     "warnings.md"
   ];
   for (const section of defaultOrder) {
-    const sectionPath = join6(CLAUDE_MD_TEMPLATES, section);
-    if (existsSync6(sectionPath)) {
+    const sectionPath = join7(CLAUDE_MD_TEMPLATES, section);
+    if (existsSync7(sectionPath)) {
       const content = loadTemplate(sectionPath);
       sections.push(substituteVariables(content, variables));
     }
   }
-  const projectSections = join6(projectPath, ".panopticon", "claude-md", "sections");
-  if (existsSync6(projectSections)) {
+  const projectSections = join7(projectPath, ".panopticon", "claude-md", "sections");
+  if (existsSync7(projectSections)) {
     const projectFiles = readdirSync6(projectSections).filter((f) => f.endsWith(".md")).sort();
     for (const file of projectFiles) {
-      const content = loadTemplate(join6(projectSections, file));
+      const content = loadTemplate(join7(projectSections, file));
       sections.push(substituteVariables(content, variables));
     }
   }
@@ -1118,28 +1193,28 @@ init_interface();
 var __filename4 = fileURLToPath3(import.meta.url);
 var __dirname4 = dirname3(__filename4);
 function resolvePromptsDir() {
-  const direct = join7(__dirname4, "prompts");
-  if (existsSync7(direct) && existsSync7(join7(direct, "work-agent.md"))) {
+  const direct = join8(__dirname4, "prompts");
+  if (existsSync8(direct) && existsSync8(join8(direct, "work-agent.md"))) {
     return direct;
   }
   let packageRoot = __dirname4;
   if (packageRoot.includes("/src/")) {
     packageRoot = packageRoot.replace(/\/src\/.*$/, "");
   } else {
-    packageRoot = join7(packageRoot, "..", "..");
+    packageRoot = join8(packageRoot, "..", "..");
   }
-  const fromRoot = join7(packageRoot, "src", "lib", "cloister", "prompts");
-  if (existsSync7(fromRoot)) {
+  const fromRoot = join8(packageRoot, "src", "lib", "cloister", "prompts");
+  if (existsSync8(fromRoot)) {
     return fromRoot;
   }
   return direct;
 }
 function buildWorkAgentPrompt(ctx) {
-  const templatePath = join7(resolvePromptsDir(), "work-agent.md");
-  if (!existsSync7(templatePath)) {
+  const templatePath = join8(resolvePromptsDir(), "work-agent.md");
+  if (!existsSync8(templatePath)) {
     throw new Error(`Work agent prompt template not found at ${templatePath}`);
   }
-  let template = readFileSync5(templatePath, "utf-8");
+  let template = readFileSync6(templatePath, "utf-8");
   let beadsTasksStr = "";
   let stitchDesignsStr = "";
   let polyrepoContextStr = "";
@@ -1184,8 +1259,8 @@ ${template}
 <!-- panopticon:orchestration-context-end -->`;
 }
 function readPendingFeedback(workspacePath) {
-  const feedbackDir = join7(workspacePath, ".planning", "feedback");
-  if (!existsSync7(feedbackDir)) return "";
+  const feedbackDir = join8(workspacePath, ".planning", "feedback");
+  if (!existsSync8(feedbackDir)) return "";
   try {
     const files = readdirSync7(feedbackDir).filter((f) => f.endsWith(".md")).sort();
     if (files.length === 0) return "";
@@ -1209,8 +1284,8 @@ var COMMENT_BODY_LIMIT = 500;
 var TOTAL_CONTEXT_LIMIT = 2e3;
 async function getTrackerContext(issueId, workspacePath) {
   let stateMtime = null;
-  const statePath = join7(workspacePath, ".planning", "STATE.md");
-  if (existsSync7(statePath)) {
+  const statePath = join8(workspacePath, ".planning", "STATE.md");
+  if (existsSync8(statePath)) {
     try {
       stateMtime = statSync3(statePath).mtime;
     } catch {
@@ -1305,9 +1380,9 @@ async function getTrackerContext(issueId, workspacePath) {
   return "";
 }
 function readPlanningContext(workspacePath) {
-  const statePath = join7(workspacePath, ".planning", "STATE.md");
-  if (existsSync7(statePath)) {
-    return readFileSync5(statePath, "utf-8");
+  const statePath = join8(workspacePath, ".planning", "STATE.md");
+  if (existsSync8(statePath)) {
+    return readFileSync6(statePath, "utf-8");
   }
   return null;
 }
@@ -1362,14 +1437,14 @@ function readBeadsTasks(workspacePath, projectRoot, issueId) {
   const stateContent = readPlanningContext(workspacePath);
   const beadsIds = stateContent ? extractBeadsIdsFromState(stateContent) : [];
   const beadsPaths = [
-    join7(workspacePath, ".beads", "issues.jsonl"),
-    join7(projectRoot, ".beads", "issues.jsonl")
+    join8(workspacePath, ".beads", "issues.jsonl"),
+    join8(projectRoot, ".beads", "issues.jsonl")
   ];
   const seenIds = /* @__PURE__ */ new Set();
   for (const beadsPath of beadsPaths) {
-    if (!existsSync7(beadsPath)) continue;
+    if (!existsSync8(beadsPath)) continue;
     try {
-      const content = readFileSync5(beadsPath, "utf-8");
+      const content = readFileSync6(beadsPath, "utf-8");
       const lines = content.split("\n").filter((line) => line.trim());
       for (const line of lines) {
         try {
@@ -1425,9 +1500,9 @@ function buildPolyrepoContext(issueId, workspacePath) {
 
 // src/cli/commands/work/issue.ts
 function getLinearApiKey() {
-  const envFile = join8(homedir3(), ".panopticon.env");
-  if (existsSync8(envFile)) {
-    const content = readFileSync6(envFile, "utf-8");
+  const envFile = join9(homedir4(), ".panopticon.env");
+  if (existsSync9(envFile)) {
+    const content = readFileSync7(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -1500,26 +1575,26 @@ function findLocalWorkspace(issueId, labels = []) {
   const resolved = resolveProjectFromIssue(issueId, labels);
   if (resolved) {
     const workspaceName = `feature-${normalizedId}`;
-    const workspacePath = join8(resolved.projectPath, "workspaces", workspaceName);
-    if (existsSync8(workspacePath)) {
+    const workspacePath = join9(resolved.projectPath, "workspaces", workspaceName);
+    if (existsSync9(workspacePath)) {
       return workspacePath;
     }
-    const altPath = join8(resolved.projectPath, "workspaces", normalizedId);
-    if (existsSync8(altPath)) {
+    const altPath = join9(resolved.projectPath, "workspaces", normalizedId);
+    if (existsSync9(altPath)) {
       return altPath;
     }
   }
   let dir = process.cwd();
   for (let i = 0; i < 10; i++) {
-    const workspacesDir = join8(dir, "workspaces");
-    if (existsSync8(workspacesDir)) {
+    const workspacesDir = join9(dir, "workspaces");
+    if (existsSync9(workspacesDir)) {
       const workspaceName = `feature-${normalizedId}`;
-      const workspacePath = join8(workspacesDir, workspaceName);
-      if (existsSync8(workspacePath)) {
+      const workspacePath = join9(workspacesDir, workspaceName);
+      if (existsSync9(workspacePath)) {
         return workspacePath;
       }
-      const altPath = join8(workspacesDir, normalizedId);
-      if (existsSync8(altPath)) {
+      const altPath = join9(workspacesDir, normalizedId);
+      if (existsSync9(altPath)) {
         return altPath;
       }
     }
@@ -1557,7 +1632,7 @@ async function handleRemoteWorkspace(issueId, options, spinner) {
   if (!remoteMetadata) {
     spinner.text = "Remote workspace not found, creating...";
     try {
-      const { createRemoteWorkspace: createRemoteWorkspace2 } = await import("../remote-workspace-7FPGF2RM.js");
+      const { createRemoteWorkspace: createRemoteWorkspace2 } = await import("../remote-workspace-XX6ARE6I.js");
       remoteMetadata = await createRemoteWorkspace2(issueId, { spinner });
     } catch (error) {
       spinner.fail(`Failed to create remote workspace: ${error.message}`);
@@ -1609,6 +1684,23 @@ async function handleRemoteWorkspace(issueId, options, spinner) {
       createShadowState(issueId, "open", "pan work issue");
       updateShadowState(issueId, "in_progress", "pan work issue");
       console.log(chalk6.cyan(`  \u{1F47B} Shadow mode: tracking status locally`));
+    } else if (isGitHubIssue(issueId)) {
+      const gh = resolveGitHubIssue(issueId);
+      if (gh.isGitHub) {
+        try {
+          const { loadConfig: loadYamlConfig } = await import("../config-yaml-OVZLKFMA.js");
+          const yamlConfig = loadYamlConfig();
+          const token = yamlConfig.config.trackerKeys?.github || process.env.GITHUB_TOKEN;
+          if (token) {
+            const { Octokit } = await import("@octokit/rest");
+            const octokit = new Octokit({ auth: token });
+            await octokit.issues.addLabels({ owner: gh.owner, repo: gh.repo, issue_number: gh.number, labels: ["in-progress"] });
+            console.log(chalk6.green(`  \u2713 Updated ${issueId.toUpperCase()} to In Progress`));
+          }
+        } catch (err) {
+          console.warn(chalk6.dim(`  \u26A0 Could not update GitHub label: ${err.message}`));
+        }
+      }
     } else if (isLinearIssue(issueId)) {
       const apiKey = getLinearApiKey();
       if (apiKey) {
@@ -1653,7 +1745,7 @@ function findProjectRoot(issueId, labels = []) {
   }
   let dir = process.cwd();
   for (let i = 0; i < 10; i++) {
-    if (existsSync8(join8(dir, "workspaces")) || existsSync8(join8(dir, ".git")) || existsSync8(join8(dir, "CLAUDE.md"))) {
+    if (existsSync9(join9(dir, "workspaces")) || existsSync9(join9(dir, ".git")) || existsSync9(join9(dir, "CLAUDE.md"))) {
       return dir;
     }
     const parent = dirname4(dir);
@@ -1662,13 +1754,16 @@ function findProjectRoot(issueId, labels = []) {
   }
   return process.cwd();
 }
+function hasBeadsTasks(workspacePath) {
+  return existsSync9(join9(workspacePath, ".beads", "issues.jsonl"));
+}
 function validateAndCleanStateFile(workspacePath, issueId) {
-  const statePath = join8(workspacePath, ".planning", "STATE.md");
-  if (!existsSync8(statePath)) {
+  const statePath = join9(workspacePath, ".planning", "STATE.md");
+  if (!existsSync9(statePath)) {
     return { valid: true, removed: false };
   }
   try {
-    const content = readFileSync6(statePath, "utf-8");
+    const content = readFileSync7(statePath, "utf-8");
     const firstLine = content.split("\n")[0] || "";
     const issueMatch = firstLine.match(/^#\s*([A-Z]+-\d+)/i);
     if (issueMatch) {
@@ -1762,6 +1857,16 @@ async function issueCommand(id, options) {
     if (stateValidation.removed) {
       spinner.warn(`Cleaned stale planning state from ${stateValidation.wrongIssue}`);
     }
+    if (!hasBeadsTasks(workspace)) {
+      spinner.fail(`No beads tasks found for ${id}`);
+      console.log("");
+      console.log(chalk6.red(`Planning must create a task breakdown before work begins.`));
+      console.log(chalk6.dim(`Run planning again and ensure it creates beads with "bd create".`));
+      console.log("");
+      console.log(chalk6.bold("To re-run planning:"));
+      console.log(`  ${chalk6.cyan(`pan work plan ${id}`)}`);
+      process.exit(1);
+    }
     spinner.text = "Building agent prompt with planning context...";
     const trackerContext = await getTrackerContext(id, workspace);
     const prompt = buildWorkAgentPrompt({ issueId: id, env: "LOCAL", workspacePath: workspace, projectRoot, trackerContext });
@@ -1779,14 +1884,6 @@ async function issueCommand(id, options) {
       createShadowState(id, "open", "pan work issue");
       updateShadowState(id, "in_progress", "pan work issue");
       console.log(chalk6.cyan(`  \u{1F47B} Shadow mode: tracking status locally`));
-    } else if (isLinearIssue(id)) {
-      const apiKey = getLinearApiKey();
-      if (apiKey) {
-        const updated = await updateLinearToInProgress(apiKey, id);
-        if (updated) {
-          console.log(chalk6.green(`  \u2713 Updated ${id.toUpperCase()} to In Progress`));
-        }
-      }
     }
     console.log("");
     console.log(chalk6.bold("Agent Details:"));
@@ -1816,14 +1913,14 @@ async function issueCommand(id, options) {
 init_esm_shims();
 init_agents();
 import chalk7 from "chalk";
-import { existsSync as existsSync9, readFileSync as readFileSync7, statSync as statSync4, readdirSync as readdirSync9 } from "fs";
-import { join as join9, basename as basename2 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8, statSync as statSync4, readdirSync as readdirSync9 } from "fs";
+import { join as join10, basename as basename2 } from "path";
 init_tldr_daemon();
 function readContextPercent(agentId) {
-  const ctxFile = join9(getAgentDir(agentId), "context-pct");
+  const ctxFile = join10(getAgentDir(agentId), "context-pct");
   try {
-    if (existsSync9(ctxFile)) {
-      const val = parseInt(readFileSync7(ctxFile, "utf8").trim(), 10);
+    if (existsSync10(ctxFile)) {
+      const val = parseInt(readFileSync8(ctxFile, "utf8").trim(), 10);
       return isNaN(val) ? null : val;
     }
   } catch {
@@ -1899,17 +1996,17 @@ async function statusCommand(options) {
   }
 }
 function readTldrIndexData(workspacePath) {
-  const tldrPath = join9(workspacePath, ".tldr");
-  if (!existsSync9(tldrPath)) {
+  const tldrPath = join10(workspacePath, ".tldr");
+  if (!existsSync10(tldrPath)) {
     return { fileCount: null, edgeCount: null, ageMs: null };
   }
   let fileCount = null;
   let edgeCount = null;
   let ageMs = null;
-  const cgPath = join9(tldrPath, "cache", "call_graph.json");
-  if (existsSync9(cgPath)) {
+  const cgPath = join10(tldrPath, "cache", "call_graph.json");
+  if (existsSync10(cgPath)) {
     try {
-      const cg = JSON.parse(readFileSync7(cgPath, "utf-8"));
+      const cg = JSON.parse(readFileSync8(cgPath, "utf-8"));
       if (Array.isArray(cg.edges)) {
         edgeCount = cg.edges.length;
         const files = /* @__PURE__ */ new Set();
@@ -1922,10 +2019,10 @@ function readTldrIndexData(workspacePath) {
     } catch {
     }
   }
-  const langPath = join9(tldrPath, "languages.json");
-  if (existsSync9(langPath)) {
+  const langPath = join10(tldrPath, "languages.json");
+  if (existsSync10(langPath)) {
     try {
-      const langData = JSON.parse(readFileSync7(langPath, "utf-8"));
+      const langData = JSON.parse(readFileSync8(langPath, "utf-8"));
       if (langData.timestamp) {
         ageMs = Date.now() - langData.timestamp * 1e3;
       }
@@ -1961,20 +2058,20 @@ async function tldrIndexStatusCommand(projectRoot = process.cwd()) {
   const projectName = basename2(projectRoot);
   const mainEntries = [];
   const workspaceEntries = [];
-  const mainVenvPath = join9(projectRoot, ".venv");
-  if (existsSync9(mainVenvPath)) {
+  const mainVenvPath = join10(projectRoot, ".venv");
+  if (existsSync10(mainVenvPath)) {
     const service = getTldrDaemonService(projectRoot, mainVenvPath);
     const status = await service.getStatus();
     const { fileCount, edgeCount, ageMs } = readTldrIndexData(projectRoot);
     mainEntries.push({ label: `Main (${projectName})`, running: status.running, fileCount, edgeCount, ageMs });
   }
-  const workspacesDir = join9(projectRoot, "workspaces");
-  if (existsSync9(workspacesDir)) {
+  const workspacesDir = join10(projectRoot, "workspaces");
+  if (existsSync10(workspacesDir)) {
     const dirs = readdirSync9(workspacesDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("feature-"));
     for (const ws of dirs) {
-      const wsPath = join9(workspacesDir, ws.name);
-      const wsVenvPath = join9(wsPath, ".venv");
-      if (existsSync9(wsVenvPath)) {
+      const wsPath = join10(workspacesDir, ws.name);
+      const wsVenvPath = join10(wsPath, ".venv");
+      if (existsSync10(wsVenvPath)) {
         const service = getTldrDaemonService(wsPath, wsVenvPath);
         const status = await service.getStatus();
         const { fileCount, edgeCount, ageMs } = readTldrIndexData(wsPath);
@@ -2082,8 +2179,8 @@ init_esm_shims();
 init_agents();
 init_paths();
 import chalk10 from "chalk";
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { join as join11 } from "path";
 async function pendingCommand() {
   const agents = listRunningAgents().filter((a) => !a.tmuxActive && a.status !== "error");
   if (agents.length === 0) {
@@ -2096,9 +2193,9 @@ async function pendingCommand() {
     console.log(`${chalk10.cyan(agent.issueId)}`);
     console.log(`  Agent:     ${agent.id}`);
     console.log(`  Workspace: ${chalk10.dim(agent.workspace)}`);
-    const completionFile = join10(AGENTS_DIR, agent.id, "completion.md");
-    if (existsSync10(completionFile)) {
-      const content = readFileSync8(completionFile, "utf8");
+    const completionFile = join11(AGENTS_DIR, agent.id, "completion.md");
+    if (existsSync11(completionFile)) {
+      const content = readFileSync9(completionFile, "utf8");
       const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"));
       if (firstLine) {
         console.log(`  Summary:   ${chalk10.dim(firstLine.trim())}`);
@@ -2115,14 +2212,14 @@ init_agents();
 init_paths();
 import chalk11 from "chalk";
 import ora5 from "ora";
-import { existsSync as existsSync11, writeFileSync as writeFileSync3, readFileSync as readFileSync9 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync12, writeFileSync as writeFileSync3, readFileSync as readFileSync10 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir5 } from "os";
 import { execSync as execSync2 } from "child_process";
 function getLinearApiKey2() {
-  const envFile = join11(homedir4(), ".panopticon.env");
-  if (existsSync11(envFile)) {
-    const content = readFileSync9(envFile, "utf-8");
+  const envFile = join12(homedir5(), ".panopticon.env");
+  if (existsSync12(envFile)) {
+    const content = readFileSync10(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -2259,7 +2356,7 @@ async function approveCommand(id, options = {}) {
     state.status = "stopped";
     state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
     saveAgentState(state);
-    const approvedFile = join11(AGENTS_DIR, agentId, "approved");
+    const approvedFile = join12(AGENTS_DIR, agentId, "approved");
     writeFileSync3(approvedFile, JSON.stringify({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       prMerged,
@@ -2425,40 +2522,6 @@ function cleanupWorkflowLabels(currentLabels, targetState) {
   return cleaned;
 }
 
-// src/lib/tracker-utils.ts
-init_esm_shims();
-import { readFileSync as readFileSync10, existsSync as existsSync12 } from "fs";
-import { join as join12 } from "path";
-import { homedir as homedir5 } from "os";
-function parseGitHubRepos() {
-  const envFile = join12(homedir5(), ".panopticon.env");
-  if (!existsSync12(envFile)) return [];
-  const content = readFileSync10(envFile, "utf-8");
-  const reposMatch = content.match(/GITHUB_REPOS=(.+)/);
-  if (!reposMatch) return [];
-  return reposMatch[1].trim().split(",").map((r) => {
-    const [repoPath, prefix] = r.trim().split(":");
-    const [owner, repo] = (repoPath || "").split("/");
-    return { owner: owner || "", repo: repo || "", prefix: (prefix || "").toUpperCase() };
-  }).filter((r) => r.owner && r.repo && r.prefix);
-}
-function extractIssuePrefix(issueId) {
-  return issueId.split("-")[0].toUpperCase();
-}
-function resolveGitHubIssue(issueId) {
-  const prefix = extractIssuePrefix(issueId);
-  const repos = parseGitHubRepos();
-  for (const repoConfig of repos) {
-    if (repoConfig.prefix === prefix) {
-      const number = parseInt(issueId.split("-")[1], 10);
-      if (!isNaN(number)) {
-        return { isGitHub: true, ...repoConfig, number };
-      }
-    }
-  }
-  return { isGitHub: false };
-}
-
 // src/cli/commands/work/done.ts
 var execAsync = promisify(exec);
 function getLinearApiKey3() {
@@ -2526,9 +2589,9 @@ async function updateGitHubToInReview(issueId, comment) {
   try {
     const ghConfig = getGitHubConfig();
     if (!ghConfig) return false;
-    const resolved = resolveGitHubIssue(issueId);
-    if (!resolved.isGitHub) return false;
-    const { owner, repo, number } = resolved;
+    const number = parseInt(issueId.split("-")[1], 10);
+    const repoConfig = ghConfig.repos.find((r) => r.prefix === "PAN") || ghConfig.repos[0];
+    const { owner, repo } = repoConfig;
     const token = ghConfig.token;
     const headers = {
       "Authorization": `token ${token}`,
@@ -2564,59 +2627,10 @@ async function doneCommand(id, options = {}) {
   const issueId = id.replace(/^agent-/i, "").toUpperCase();
   const agentId = `agent-${issueId.toLowerCase()}`;
   if (!options.force) {
-    const { getAgentState: getAgentState2 } = await import("../agents-5OPQKM5K.js");
+    const { getAgentState: getAgentState2 } = await import("../agents-HNMF52RM.js");
     const agentState = getAgentState2(agentId);
     const workspacePath = agentState?.workspace;
     if (workspacePath && existsSync13(workspacePath)) {
-      try {
-        const { getReviewStatus: getReviewStatus2 } = await import("../review-status-TDPSOU5J.js");
-        const { getWorkspaceCommitHashes } = await import("../git-utils-I2UDKNZH.js");
-        const { getDashboardApiUrl: getDashboardApiUrl2 } = await import("../config-4CJNUE3O.js");
-        const reviewStatus = getReviewStatus2(issueId);
-        if (reviewStatus) {
-          const isBlockedOrFailed = ["blocked", "failed"].includes(reviewStatus.reviewStatus);
-          if (isBlockedOrFailed) {
-            const dashboardUrl = getDashboardApiUrl2();
-            console.error(chalk12.red(`
-\u2716 Cannot mark work done \u2014 review is ${reviewStatus.reviewStatus} for ${issueId}
-`));
-            console.error("  The review agent found issues that must be addressed before this issue can be completed.");
-            console.error("  Fix the issues, commit your changes, then re-submit for review:\n");
-            console.error(chalk12.cyan(`  curl -X POST ${dashboardUrl}/api/workspaces/${issueId}/request-review \\`));
-            console.error(chalk12.cyan(`    -H "Content-Type: application/json" -d '{}'`));
-            console.error("");
-            console.error(chalk12.dim("  Use --force to skip this check."));
-            console.error("");
-            process.exit(1);
-          }
-          if (reviewStatus.lastReviewCommits) {
-            const currentHashes = await getWorkspaceCommitHashes(workspacePath);
-            const allKeys = /* @__PURE__ */ new Set([
-              ...Object.keys(currentHashes),
-              ...Object.keys(reviewStatus.lastReviewCommits)
-            ]);
-            const commitsChanged = [...allKeys].some(
-              (k) => currentHashes[k] !== reviewStatus.lastReviewCommits[k]
-            );
-            if (commitsChanged) {
-              const dashboardUrl = getDashboardApiUrl2();
-              console.error(chalk12.red(`
-\u2716 Cannot mark work done \u2014 commits changed since last review for ${issueId}
-`));
-              console.error("  New commits were added after the last review/test run. The specialists");
-              console.error("  must review and test your latest code before work can be marked done.");
-              console.error("  Re-submit for review:\n");
-              console.error(chalk12.cyan(`  curl -X POST ${dashboardUrl}/api/workspaces/${issueId}/request-review \\`));
-              console.error(chalk12.cyan(`    -H "Content-Type: application/json" -d '{}'`));
-              console.error("");
-              console.error(chalk12.dim("  Use --force to skip this check."));
-              console.error("");
-              process.exit(1);
-            }
-          }
-        }
-      } catch {
-      }
       const failures = [];
       try {
         const { stdout } = await execAsync("bd list --status open --limit 0 --json", { cwd: workspacePath });
@@ -2683,14 +2697,14 @@ async function doneCommand(id, options = {}) {
   try {
     let trackerUpdated = false;
     let shadowModeActive = false;
-    const ghResolution = resolveGitHubIssue(issueId);
+    const isGitHubIssue2 = issueId.startsWith("PAN-");
     const skipTrackerUpdate = shouldSkipTrackerUpdate(issueId, options.shadow);
     if (skipTrackerUpdate) {
       shadowModeActive = true;
       spinner.text = "Updating shadow state...";
       updateShadowState(issueId, "closed", "pan work done");
       console.log(chalk12.cyan(`  \u{1F47B} Shadow mode: status updated locally`));
-    } else if (ghResolution.isGitHub) {
+    } else if (isGitHubIssue2) {
       spinner.text = "Updating GitHub labels...";
       trackerUpdated = await updateGitHubToInReview(issueId, options.comment);
       if (trackerUpdated) {
@@ -2712,7 +2726,7 @@ async function doneCommand(id, options = {}) {
         console.log(chalk12.dim("  LINEAR_API_KEY not set - skipping status update"));
       }
     }
-    const { getAgentState: getAgentState2, saveAgentState: saveAgentState2 } = await import("../agents-5OPQKM5K.js");
+    const { getAgentState: getAgentState2, saveAgentState: saveAgentState2 } = await import("../agents-HNMF52RM.js");
     const existingState = getAgentState2(agentId);
     if (existingState) {
       existingState.status = "stopped";
@@ -3330,48 +3344,79 @@ async function runDiscoveryPhase(issue, complexity, prdContent) {
 async function planCommand(id, options = {}) {
   const spinner = ora7(`Creating execution plan for ${id}...`).start();
   try {
-    const apiKey = getLinearApiKey4();
-    if (!apiKey) {
-      spinner.fail("LINEAR_API_KEY not found");
-      console.log("");
-      console.log(chalk13.dim("Set it in ~/.panopticon.env:"));
-      console.log("  LINEAR_API_KEY=lin_api_xxxxx");
-      process.exit(1);
-    }
-    spinner.text = "Fetching issue from Linear...";
-    const { LinearClient: LinearClient2 } = await import("@linear/sdk");
-    const client = new LinearClient2({ apiKey });
-    const me = await client.viewer;
-    const teams = await me.teams();
-    const team = teams.nodes[0];
-    if (!team) {
-      spinner.fail("No Linear team found");
-      process.exit(1);
-    }
-    const searchResult = await team.issues({ first: 100 });
-    const issue = searchResult.nodes.find(
-      (i) => i.identifier.toUpperCase() === id.toUpperCase()
-    );
-    if (!issue) {
-      spinner.fail(`Issue not found: ${id}`);
-      process.exit(1);
+    const ghResolution = resolveGitHubIssue(id);
+    let issueData;
+    if (ghResolution.isGitHub) {
+      spinner.text = "Fetching issue from GitHub...";
+      const { loadConfig: loadYamlConfig } = await import("../config-yaml-OVZLKFMA.js");
+      const yamlConfig = loadYamlConfig();
+      const token = yamlConfig.config.trackerKeys?.github || process.env.GITHUB_TOKEN;
+      if (!token) {
+        spinner.fail("GitHub token not found");
+        process.exit(1);
+      }
+      const { Octokit } = await import("@octokit/rest");
+      const octokit = new Octokit({ auth: token });
+      const { data: ghIssue } = await octokit.issues.get({
+        owner: ghResolution.owner,
+        repo: ghResolution.repo,
+        issue_number: ghResolution.number
+      });
+      issueData = {
+        id: String(ghIssue.id),
+        identifier: id,
+        title: ghIssue.title,
+        description: ghIssue.body || void 0,
+        url: ghIssue.html_url,
+        state: { name: ghIssue.state === "open" ? "Todo" : "Done" },
+        priority: 0,
+        labels: (ghIssue.labels || []).map((l) => ({ name: typeof l === "string" ? l : l.name || "" })),
+        assignee: ghIssue.assignee ? { name: ghIssue.assignee.login } : void 0
+      };
+    } else {
+      const apiKey = getLinearApiKey4();
+      if (!apiKey) {
+        spinner.fail("LINEAR_API_KEY not found");
+        console.log("");
+        console.log(chalk13.dim("Set it in ~/.panopticon.env:"));
+        console.log("  LINEAR_API_KEY=lin_api_xxxxx");
+        process.exit(1);
+      }
+      spinner.text = "Fetching issue from Linear...";
+      const { LinearClient: LinearClient2 } = await import("@linear/sdk");
+      const client = new LinearClient2({ apiKey });
+      const me = await client.viewer;
+      const teams = await me.teams();
+      const team = teams.nodes[0];
+      if (!team) {
+        spinner.fail("No Linear team found");
+        process.exit(1);
+      }
+      const searchResult = await team.issues({ first: 100 });
+      const issue = searchResult.nodes.find(
+        (i) => i.identifier.toUpperCase() === id.toUpperCase()
+      );
+      if (!issue) {
+        spinner.fail(`Issue not found: ${id}`);
+        process.exit(1);
+      }
+      const state = await issue.state;
+      const assignee = await issue.assignee;
+      const project2 = await issue.project;
+      const labels = await issue.labels();
+      issueData = {
+        id: issue.id,
+        identifier: issue.identifier,
+        title: issue.title,
+        description: issue.description || void 0,
+        url: issue.url,
+        state: { name: state?.name || "Unknown" },
+        priority: issue.priority,
+        labels: labels.nodes.map((l) => ({ name: l.name })),
+        assignee: assignee ? { name: assignee.name } : void 0,
+        project: project2 ? { name: project2.name } : void 0
+      };
     }
-    const state = await issue.state;
-    const assignee = await issue.assignee;
-    const project2 = await issue.project;
-    const labels = await issue.labels();
-    const issueData = {
-      id: issue.id,
-      identifier: issue.identifier,
-      title: issue.title,
-      description: issue.description || void 0,
-      url: issue.url,
-      state: { name: state?.name || "Unknown" },
-      priority: issue.priority,
-      labels: labels.nodes.map((l) => ({ name: l.name })),
-      assignee: assignee ? { name: assignee.name } : void 0,
-      project: project2 ? { name: project2.name } : void 0
-    };
     spinner.text = "Searching for related PRDs...";
     const prdFiles = await findPRDFiles(id);
     spinner.text = "Analyzing complexity...";
@@ -3504,6 +3549,7 @@ init_esm_shims();
 init_config();
 import chalk14 from "chalk";
 import ora8 from "ora";
+init_projects();
 var PRIORITY_LABELS = {
   0: chalk14.dim("None"),
   1: chalk14.red("Urgent"),
@@ -3519,21 +3565,40 @@ var STATE_COLORS = {
 function getTrackerConfig(trackerType) {
   const config2 = loadConfig();
   const trackerConfig = config2.trackers[trackerType];
-  if (!trackerConfig) {
-    return null;
+  if (trackerConfig) {
+    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,
+      server: trackerConfig.server,
+      workspace: trackerConfig.workspace,
+      project: trackerConfig.project
+    };
   }
-  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,
-    server: trackerConfig.server,
-    workspace: trackerConfig.workspace,
-    project: trackerConfig.project
-  };
+  if (trackerType === "github") {
+    try {
+      const { projects } = loadProjectsConfig();
+      for (const [, project2] of Object.entries(projects)) {
+        if (project2.github_repo) {
+          const [owner, repo] = project2.github_repo.split("/");
+          if (owner && repo) {
+            return {
+              type: "github",
+              tokenEnv: "GITHUB_TOKEN",
+              owner,
+              repo
+            };
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
 }
 function getConfiguredTrackers() {
   const config2 = loadConfig();
@@ -3542,6 +3607,16 @@ function getConfiguredTrackers() {
   if (config2.trackers.github) trackers.push("github");
   if (config2.trackers.gitlab) trackers.push("gitlab");
   if (config2.trackers.rally) trackers.push("rally");
+  if (!trackers.includes("github") || !trackers.includes("gitlab")) {
+    try {
+      const { projects } = loadProjectsConfig();
+      for (const [, project2] of Object.entries(projects)) {
+        if (project2.github_repo && !trackers.includes("github")) trackers.push("github");
+        if (project2.gitlab_repo && !trackers.includes("gitlab")) trackers.push("gitlab");
+      }
+    } catch {
+    }
+  }
   return trackers;
 }
 function displayIssues(issues, trackerName) {
@@ -5196,10 +5271,10 @@ Previous state: ${issue.state}`
     console.log(chalk21.green(`\u2713 ${issue.identifier} reopened and ready for re-work`));
     console.log("");
     try {
-      const { getAgentState: getAgentState2 } = await import("../agents-5OPQKM5K.js");
+      const { getAgentState: getAgentState2 } = await import("../agents-HNMF52RM.js");
       const agentId = `agent-${id.toLowerCase()}`;
       const agentState = getAgentState2(agentId);
-      const agentRunning = agentState?.status === "active" || agentState?.status === "running";
+      const agentRunning = agentState?.status === "running" || agentState?.status === "starting";
       if (agentRunning) {
         console.log(chalk21.dim("Agent is still running. Send it context about the re-work:"));
         console.log(`  pan tell ${id} "Issue reopened. <describe what needs to change>"`);
@@ -5317,7 +5392,6 @@ import { join as join21 } from "path";
 import { existsSync as existsSync22, rmSync, readFileSync as readFileSync20 } from "fs";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
-init_workspace_manager();
 var execAsync4 = promisify4(exec4);
 async function wipeCommand(issueId, options) {
   const issueLower = issueId.toLowerCase();
@@ -5430,23 +5504,6 @@ async function wipeCommand(issueId, options) {
     } catch (e) {
     }
   }
-  if (projectPath) {
-    const workspacePath = join21(projectPath, "workspaces", `feature-${issueLower}`);
-    if (existsSync22(workspacePath)) {
-      try {
-        const projName = projectPath.split("/").pop() || "";
-        const dockerResult = await stopWorkspaceDocker(workspacePath, projName, issueLower);
-        if (dockerResult.steps.length > 0) {
-          for (const step of dockerResult.steps) {
-            cleanupLog.push(step);
-            console.log(chalk24.green(`  \u2713 ${step}`));
-          }
-        }
-      } catch (e) {
-        console.log(chalk24.yellow(`  \u26A0 Docker cleanup: ${e.message}`));
-      }
-    }
-  }
   if (options.workspace && projectPath) {
     const workspacePath = join21(projectPath, "workspaces", `feature-${issueLower}`);
     if (existsSync22(workspacePath)) {
@@ -6261,6 +6318,9 @@ async function syncMainCommand(id) {
 // src/cli/commands/work/close-out.ts
 init_esm_shims();
 import chalk31 from "chalk";
+import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
+import { join as join29 } from "path";
+import { homedir as homedir14 } from "os";
 
 // src/lib/lifecycle/index.ts
 init_esm_shims();
@@ -6412,11 +6472,17 @@ async function archivePlanning(ctx, opts = {}) {
   return results;
 }
 
-// src/lib/lifecycle/close-issue.ts
+// src/lib/lifecycle/clean-planning.ts
 init_esm_shims();
 import { exec as exec6 } from "child_process";
 import { promisify as promisify6 } from "util";
 var execAsync6 = promisify6(exec6);
+
+// src/lib/lifecycle/close-issue.ts
+init_esm_shims();
+import { exec as exec7 } from "child_process";
+import { promisify as promisify7 } from "util";
+var execAsync7 = promisify7(exec7);
 var CLOSED_OUT_LABEL = "closed-out";
 var CLOSED_OUT_COLOR = "1d4ed8";
 var WORKFLOW_LABELS2 = ["in-progress", "in-review", "needs-close-out"];
@@ -6477,7 +6543,7 @@ async function closeGitHubDirect(ctx, comment) {
   const { owner, repo, number } = ctx.github;
   try {
     const commentArg = comment ? ` --comment "${comment.replace(/"/g, '\\"')}"` : "";
-    await execAsync6(
+    await execAsync7(
       `gh issue close ${number} --repo ${owner}/${repo}${commentArg}`,
       { encoding: "utf-8" }
     );
@@ -6495,7 +6561,7 @@ async function closeGitHubPr(ctx) {
   const issueLower = ctx.issueId.toLowerCase();
   const branchName = `feature/${issueLower}`;
   try {
-    const { stdout: prListRaw } = await execAsync6(
+    const { stdout: prListRaw } = await execAsync7(
       `gh pr list --repo ${owner}/${repo} --head "${branchName}" --state open --json number --jq '.[0].number'`,
       { encoding: "utf-8" }
     );
@@ -6503,7 +6569,7 @@ async function closeGitHubPr(ctx) {
     if (!prNumber) {
       return stepSkipped(step, ["No open PR found for branch"]);
     }
-    await execAsync6(
+    await execAsync7(
       `gh pr close ${prNumber} --repo ${owner}/${repo} --comment "Merged via Panopticon lifecycle"`,
       { encoding: "utf-8" }
     );
@@ -6512,8 +6578,14 @@ async function closeGitHubPr(ctx) {
     return stepSkipped(step, [`PR close failed (non-fatal): ${err.message}`]);
   }
 }
+var _linearRateLimitUntil = 0;
+var LINEAR_RATE_LIMIT_COOLDOWN_MS = 60 * 60 * 1e3;
 async function closeLinearDirect(ctx, apiKey) {
   const step = "close-issue:transition";
+  if (Date.now() < _linearRateLimitUntil) {
+    const remainingMin = Math.ceil((_linearRateLimitUntil - Date.now()) / 6e4);
+    return stepFailed(step, `Linear rate limit cooldown active (${remainingMin}min remaining). Issue will be closed during close-out ceremony.`);
+  }
   try {
     const { LinearClient: LinearClient2 } = await import("@linear/sdk");
     const client = new LinearClient2({ apiKey });
@@ -6540,7 +6612,13 @@ async function closeLinearDirect(ctx, apiKey) {
     }
     return stepOk(step, [`Moved Linear issue ${ctx.issueId} to Done`]);
   } catch (err) {
-    return stepFailed(step, `Linear close failed: ${err.message}`);
+    const message = err.message;
+    if (message.includes("Rate limit") || message.includes("rate limit") || message.includes("429")) {
+      _linearRateLimitUntil = Date.now() + LINEAR_RATE_LIMIT_COOLDOWN_MS;
+      console.warn(`[close-issue] Linear rate limit hit \u2014 circuit breaker activated for 1 hour`);
+      return stepFailed(step, `Linear rate limit exceeded. Circuit breaker activated \u2014 no Linear API calls for 1 hour. Issue will be closed during close-out ceremony.`);
+    }
+    return stepFailed(step, `Linear close failed: ${message}`);
   }
 }
 async function closeRallyDirect(ctx) {
@@ -6595,16 +6673,16 @@ async function applyLabelGitHub(ctx) {
   if (!ctx.github) return stepSkipped(step);
   const { owner, repo, number } = ctx.github;
   try {
-    await execAsync6(
+    await execAsync7(
       `gh label create "${CLOSED_OUT_LABEL}" --repo ${owner}/${repo} --color "${CLOSED_OUT_COLOR}" --description "Verified and closed out" --force 2>/dev/null || true`,
       { encoding: "utf-8" }
     );
-    await execAsync6(
+    await execAsync7(
       `gh issue edit ${number} --repo ${owner}/${repo} --add-label "${CLOSED_OUT_LABEL}"`,
       { encoding: "utf-8" }
     );
     for (const label of WORKFLOW_LABELS2) {
-      await execAsync6(
+      await execAsync7(
         `gh issue edit ${number} --repo ${owner}/${repo} --remove-label "${label}" 2>/dev/null || true`,
         { encoding: "utf-8" }
       );
@@ -6661,9 +6739,9 @@ init_paths();
 init_tmux();
 import { existsSync as existsSync28, rmSync as rmSync3, unlinkSync as unlinkSync2 } from "fs";
 import { join as join27, basename as basename5 } from "path";
-import { exec as exec7 } from "child_process";
-import { promisify as promisify7 } from "util";
-var execAsync7 = promisify7(exec7);
+import { exec as exec8 } from "child_process";
+import { promisify as promisify8 } from "util";
+var execAsync8 = promisify8(exec8);
 async function killTmuxSessions(issueLower) {
   const step = "teardown:tmux-sessions";
   const patterns = [
@@ -6677,7 +6755,7 @@ async function killTmuxSessions(issueLower) {
   for (const session of patterns) {
     if (sessionExists(session)) {
       try {
-        await execAsync7(`tmux kill-session -t ${session}`);
+        await execAsync8(`tmux kill-session -t ${session}`);
         killed++;
       } catch {
       }
@@ -6706,8 +6784,8 @@ async function stopTldrDaemon(workspacePath) {
 async function stopDocker(workspacePath, projectName, issueLower) {
   const step = "teardown:docker";
   try {
-    const { stopWorkspaceDocker: stopWorkspaceDocker2 } = await import("../workspace-manager-E434Z45T.js");
-    await stopWorkspaceDocker2(workspacePath, projectName, issueLower);
+    const { stopWorkspaceDocker } = await import("../workspace-manager-ALBR62AS.js");
+    await stopWorkspaceDocker(workspacePath, projectName, issueLower);
     return stepOk(step, ["Stopped Docker containers"]);
   } catch {
     return stepSkipped(step, ["Docker cleanup skipped (not running or failed)"]);
@@ -6719,7 +6797,7 @@ async function removeWorktree(projectPath, workspacePath) {
     return stepSkipped(step, ["Workspace directory does not exist"]);
   }
   try {
-    await execAsync7(`git worktree remove "${workspacePath}" --force`, { cwd: projectPath });
+    await execAsync8(`git worktree remove "${workspacePath}" --force`, { cwd: projectPath });
     return stepOk(step, ["Removed git worktree"]);
   } catch {
     try {
@@ -6753,13 +6831,13 @@ async function deleteBranches(projectPath, issueLower) {
   const branchName = `feature/${issueLower}`;
   const details = [];
   try {
-    await execAsync7(`git branch -D "${branchName}"`, { cwd: projectPath, encoding: "utf-8" });
+    await execAsync8(`git branch -D "${branchName}"`, { cwd: projectPath, encoding: "utf-8" });
     details.push(`Deleted local branch ${branchName}`);
   } catch {
     details.push(`Local branch ${branchName} not found (already deleted)`);
   }
   try {
-    await execAsync7(`git push origin --delete "${branchName}"`, { cwd: projectPath, encoding: "utf-8" });
+    await execAsync8(`git push origin --delete "${branchName}"`, { cwd: projectPath, encoding: "utf-8" });
     details.push(`Deleted remote branch ${branchName}`);
   } catch {
     details.push(`Remote branch ${branchName} not found (already deleted)`);
@@ -6816,7 +6894,7 @@ function buildPlaceholders(ctx, opts, workspacePath) {
 async function removeTunnelConfig(tunnelConfig, placeholders) {
   const step = "teardown:tunnel";
   try {
-    const { removeTunnelIngress } = await import("../tunnel-W2GZBLEV.js");
+    const { removeTunnelIngress } = await import("../tunnel-BKC7KLBX.js");
     const result = await removeTunnelIngress(tunnelConfig, placeholders);
     return stepOk(step, result.steps || ["Removed tunnel ingress"]);
   } catch (err) {
@@ -6826,7 +6904,7 @@ async function removeTunnelConfig(tunnelConfig, placeholders) {
 async function removeHumeEviConfig(humeConfig, placeholders) {
   const step = "teardown:hume";
   try {
-    const { deleteHumeConfig } = await import("../hume-WMAUBBV2.js");
+    const { deleteHumeConfig } = await import("../hume-CKJJ3OUU.js");
     const result = await deleteHumeConfig(humeConfig, placeholders);
     return stepOk(step, result.steps || ["Removed Hume EVI config"]);
   } catch (err) {
@@ -6874,18 +6952,18 @@ async function teardownWorkspace(ctx, opts = {}) {
 
 // src/lib/lifecycle/compact-beads.ts
 init_esm_shims();
-import { exec as exec8 } from "child_process";
-import { promisify as promisify8 } from "util";
-var execAsync8 = promisify8(exec8);
+import { exec as exec9 } from "child_process";
+import { promisify as promisify9 } from "util";
+var execAsync9 = promisify9(exec9);
 
 // src/lib/lifecycle/workflows.ts
 init_esm_shims();
 init_paths();
 import { existsSync as existsSync29, readFileSync as readFileSync25 } from "fs";
 import { join as join28 } from "path";
-import { exec as exec9 } from "child_process";
-import { promisify as promisify9 } from "util";
-var execAsync9 = promisify9(exec9);
+import { exec as exec10 } from "child_process";
+import { promisify as promisify10 } from "util";
+var execAsync10 = promisify10(exec10);
 function buildResult(workflow, issueId, steps, startTime) {
   return {
     workflow,
@@ -6928,7 +7006,7 @@ async function verifyBranchMerged(ctx) {
   const branchName = `feature/${issueLower}`;
   try {
     try {
-      const { loadReviewStatuses: loadReviewStatuses3 } = await import("../review-status-TDPSOU5J.js");
+      const { loadReviewStatuses: loadReviewStatuses3 } = await import("../review-status-XKUKZF6J.js");
       const statuses = loadReviewStatuses3();
       const issueKey = ctx.issueId.toUpperCase();
       if (statuses[issueKey]?.mergeStatus === "merged") {
@@ -6936,19 +7014,19 @@ async function verifyBranchMerged(ctx) {
       }
     } catch {
     }
-    const { stdout: branchExists } = await execAsync9(
+    const { stdout: branchExists } = await execAsync10(
       `git branch --list "${branchName}" 2>/dev/null || true`,
       { cwd: ctx.projectPath, encoding: "utf-8" }
     );
     if (branchExists.trim()) {
       try {
-        await execAsync9(
+        await execAsync10(
           `git merge-base --is-ancestor ${branchName} main`,
           { cwd: ctx.projectPath, encoding: "utf-8" }
         );
         return stepOk(step, ["All commits merged to main"]);
       } catch {
-        const { stdout: unmerged } = await execAsync9(
+        const { stdout: unmerged } = await execAsync10(
           `git log main..${branchName} --oneline 2>/dev/null || true`,
           { cwd: ctx.projectPath, encoding: "utf-8" }
         );
@@ -6956,21 +7034,21 @@ async function verifyBranchMerged(ctx) {
         return stepFailed(step, `${count} unmerged commit(s) on ${branchName}. Merge before closing out.`);
       }
     }
-    const { stdout: remoteBranch } = await execAsync9(
+    const { stdout: remoteBranch } = await execAsync10(
       `git ls-remote --heads origin "${branchName}" 2>/dev/null || true`,
       { cwd: ctx.projectPath, encoding: "utf-8" }
     );
     if (remoteBranch.trim()) {
-      await execAsync9(`git fetch origin ${branchName}`, { cwd: ctx.projectPath }).catch(() => {
+      await execAsync10(`git fetch origin ${branchName}`, { cwd: ctx.projectPath }).catch(() => {
       });
       try {
-        await execAsync9(
+        await execAsync10(
           `git merge-base --is-ancestor origin/${branchName} main`,
           { cwd: ctx.projectPath, encoding: "utf-8" }
         );
         return stepOk(step, ["Remote branch fully merged"]);
       } catch {
-        const { stdout: remoteUnmerged } = await execAsync9(
+        const { stdout: remoteUnmerged } = await execAsync10(
           `git log main..origin/${branchName} --oneline 2>/dev/null || true`,
           { cwd: ctx.projectPath, encoding: "utf-8" }
         );
@@ -6986,7 +7064,7 @@ async function verifyBranchMerged(ctx) {
 async function clearReviewStatusStep(issueId) {
   const step = "clear-review-status";
   try {
-    const { clearReviewStatus: clearReviewStatus2 } = await import("../review-status-TDPSOU5J.js");
+    const { clearReviewStatus: clearReviewStatus2 } = await import("../review-status-XKUKZF6J.js");
     clearReviewStatus2(issueId.toUpperCase());
     return stepOk(step, ["Review status cleared"]);
   } catch {
@@ -7010,6 +7088,20 @@ async function clearReviewStatusStep(issueId) {
 
 // src/cli/commands/work/close-out.ts
 init_projects();
+function getGitHubConfig2() {
+  const envFile = join29(homedir14(), ".panopticon.env");
+  if (!existsSync30(envFile)) return null;
+  const content = readFileSync26(envFile, "utf-8");
+  const reposMatch = content.match(/GITHUB_REPOS=(.+)/);
+  if (!reposMatch) return null;
+  const repoStr = reposMatch[1].trim();
+  const parts = repoStr.split(",")[0];
+  if (!parts) return null;
+  const [ownerRepo, prefix] = parts.split(":");
+  const [owner, repo] = ownerRepo.split("/");
+  if (!owner || !repo) return null;
+  return { owner, repo, prefix: prefix || repo.toUpperCase().replace(/-CLI$/, "").replace(/-/g, "") };
+}
 async function closeOutCommand(issueId, options) {
   if (process.env.PANOPTICON_AGENT_ID) {
     console.error(chalk31.red("Close-out is a human-only operation. Agents cannot close out issues."));
@@ -7032,11 +7124,22 @@ async function closeOutCommand(issueId, options) {
     console.error(chalk31.red(`Could not resolve project for ${issueId}`));
     process.exit(1);
   }
-  const ghResolution = resolveGitHubIssue(issueId);
-  const isGitHub = ghResolution.isGitHub;
-  const owner = ghResolution.isGitHub ? ghResolution.owner : void 0;
-  const repo = ghResolution.isGitHub ? ghResolution.repo : void 0;
-  const number = ghResolution.isGitHub ? ghResolution.number : void 0;
+  const isGitHub = issueUpper.startsWith("PAN-");
+  let owner;
+  let repo;
+  let number;
+  if (isGitHub) {
+    const ghConfig = getGitHubConfig2();
+    if (ghConfig) {
+      owner = ghConfig.owner;
+      repo = ghConfig.repo;
+      number = parseInt(issueId.replace(/^PAN-/i, ""), 10);
+    } else {
+      owner = "eltmon";
+      repo = "panopticon-cli";
+      number = parseInt(issueId.replace(/^PAN-/i, ""), 10);
+    }
+  }
   if (!options.force) {
     console.log(chalk31.yellow(`
 Close-out ceremony for ${issueUpper}
@@ -7095,13 +7198,13 @@ Running close-out for ${issueUpper}...
 // src/cli/commands/work/linear-states.ts
 init_esm_shims();
 import chalk32 from "chalk";
-import { readFileSync as readFileSync26, existsSync as existsSync30 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join29 } from "path";
+import { readFileSync as readFileSync27, existsSync as existsSync31 } from "fs";
+import { homedir as homedir15 } from "os";
+import { join as join30 } from "path";
 function getLinearApiKey8() {
-  const envFile = join29(homedir14(), ".panopticon.env");
-  if (existsSync30(envFile)) {
-    const content = readFileSync26(envFile, "utf-8");
+  const envFile = join30(homedir15(), ".panopticon.env");
+  if (existsSync31(envFile)) {
+    const content = readFileSync27(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -7290,8 +7393,8 @@ function registerWorkCommands(program2) {
 init_esm_shims();
 import chalk33 from "chalk";
 import ora16 from "ora";
-import { existsSync as existsSync31, writeFileSync as writeFileSync10, rmSync as rmSync4, readFileSync as readFileSync27, realpathSync } from "fs";
-import { join as join30, basename as basename6 } from "path";
+import { existsSync as existsSync32, writeFileSync as writeFileSync10, rmSync as rmSync4, readFileSync as readFileSync28, realpathSync } from "fs";
+import { join as join31, basename as basename6 } from "path";
 
 // src/lib/worktree.ts
 init_esm_shims();
@@ -7354,13 +7457,13 @@ init_agents();
 init_projects();
 init_workspace_manager();
 init_config();
-import { exec as exec10 } from "child_process";
-import { promisify as promisify10 } from "util";
-import { homedir as homedir15 } from "os";
-var execAsync10 = promisify10(exec10);
+import { exec as exec11 } from "child_process";
+import { promisify as promisify11 } from "util";
+import { homedir as homedir16 } from "os";
+var execAsync11 = promisify11(exec11);
 async function getBeadsVersion() {
   try {
-    const { stdout } = await execAsync10("bd --version", { encoding: "utf-8" });
+    const { stdout } = await execAsync11("bd --version", { encoding: "utf-8" });
     const match = stdout.match(/(\d+)\.(\d+)\.(\d+)/);
     if (match) {
       const [, , minor, patch] = match.map(Number);
@@ -7386,21 +7489,21 @@ async function initializeWorkspaceBeads(workspacePath, issueId) {
     if (beadsVersion >= 4701) {
       const workspaceLabel = `workspace:${issueId.toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
       const title = `${issueId.toUpperCase()}: Implementation`;
-      const { stdout } = await execAsync10(
+      const { stdout } = await execAsync11(
         `bd create --title "${title}" --priority 1 --type task --labels "${workspaceLabel}" 2>&1`,
         { cwd: workspacePath, encoding: "utf-8" }
       );
       const match = stdout.match(/([a-z]+-[a-z0-9]+)/);
       return { success: true, beadId: match?.[1] };
     } else {
-      const beadsDir = join30(workspacePath, ".beads");
-      if (existsSync31(beadsDir)) {
+      const beadsDir = join31(workspacePath, ".beads");
+      if (existsSync32(beadsDir)) {
         rmSync4(beadsDir, { recursive: true, force: true });
       }
       const prefix = "workspace";
-      await execAsync10(`bd init --prefix ${prefix}`, { cwd: workspacePath, encoding: "utf-8" });
+      await execAsync11(`bd init --prefix ${prefix}`, { cwd: workspacePath, encoding: "utf-8" });
       const title = `${issueId.toUpperCase()}: Implementation`;
-      const { stdout } = await execAsync10(
+      const { stdout } = await execAsync11(
         `bd create --title "${title}" --priority 1 --type task --json`,
         { cwd: workspacePath, encoding: "utf-8" }
       );
@@ -7523,7 +7626,7 @@ async function createCommand(issueId, options) {
       const dockerFlag = options.docker ? " --docker" : "";
       const cmd = `${projectConfig.workspace_command} ${normalizedId}${dockerFlag}`;
       try {
-        const { stdout } = await execAsync10(cmd, {
+        const { stdout } = await execAsync11(cmd, {
           cwd: projectConfig.path,
           encoding: "utf-8",
           timeout: options.docker ? 3e5 : 12e4
@@ -7559,8 +7662,8 @@ async function createCommand(issueId, options) {
         projectRoot = process.cwd();
       }
     }
-    const workspacesDir = join30(projectRoot, "workspaces");
-    const workspacePath = join30(workspacesDir, folderName);
+    const workspacesDir = join31(projectRoot, "workspaces");
+    const workspacePath = join31(workspacesDir, folderName);
     if (options.dryRun) {
       spinner.info("Dry run mode");
       console.log("");
@@ -7573,11 +7676,11 @@ async function createCommand(issueId, options) {
       console.log(`  Branch:    ${chalk33.cyan(branchName)}`);
       return;
     }
-    if (existsSync31(workspacePath)) {
+    if (existsSync32(workspacePath)) {
       spinner.fail(`Workspace already exists: ${workspacePath}`);
       process.exit(1);
     }
-    if (!existsSync31(join30(projectRoot, ".git"))) {
+    if (!existsSync32(join31(projectRoot, ".git"))) {
       spinner.fail("Not a git repository. Run this from the project root.");
       process.exit(1);
     }
@@ -7601,7 +7704,7 @@ async function createCommand(issueId, options) {
       BEAD_ID: workspaceBeadId
     };
     const claudeMd = generateClaudeMd(projectRoot, variables);
-    writeFileSync10(join30(workspacePath, "CLAUDE.md"), claudeMd);
+    writeFileSync10(join31(workspacePath, "CLAUDE.md"), claudeMd);
     let skillsResult = { added: [], updated: [], skipped: [], overlayed: [] };
     if (options.skills !== false) {
       spinner.text = "Merging skills and agents...";
@@ -7611,20 +7714,20 @@ async function createCommand(issueId, options) {
     let dockerError;
     if (options.docker) {
       const composeLocations = [
-        join30(workspacePath, "docker-compose.yml"),
-        join30(workspacePath, "docker-compose.yaml"),
-        join30(workspacePath, ".devcontainer", "docker-compose.yml"),
-        join30(workspacePath, ".devcontainer", "docker-compose.yaml"),
-        join30(workspacePath, ".devcontainer", "docker-compose.devcontainer.yml"),
-        join30(workspacePath, ".devcontainer", "compose.yml"),
-        join30(workspacePath, ".devcontainer", "compose.yaml")
+        join31(workspacePath, "docker-compose.yml"),
+        join31(workspacePath, "docker-compose.yaml"),
+        join31(workspacePath, ".devcontainer", "docker-compose.yml"),
+        join31(workspacePath, ".devcontainer", "docker-compose.yaml"),
+        join31(workspacePath, ".devcontainer", "docker-compose.devcontainer.yml"),
+        join31(workspacePath, ".devcontainer", "compose.yml"),
+        join31(workspacePath, ".devcontainer", "compose.yaml")
       ];
-      const composeFile = composeLocations.find((f) => existsSync31(f));
+      const composeFile = composeLocations.find((f) => existsSync32(f));
       if (composeFile) {
         spinner.text = "Starting Docker containers...";
         try {
-          const composeDir = join30(composeFile, "..");
-          await execAsync10(`docker compose -f "${composeFile}" up -d --build`, {
+          const composeDir = join31(composeFile, "..");
+          await execAsync11(`docker compose -f "${composeFile}" up -d --build`, {
             cwd: composeDir,
             encoding: "utf-8",
             timeout: 3e5
@@ -7690,15 +7793,15 @@ async function listCommand2(options) {
       const workspaces2 = [];
       if (isPolyrepo && config2.workspace?.repos) {
         for (const repo of config2.workspace.repos) {
-          const repoPath = join30(config2.path, repo.path);
-          if (!existsSync31(join30(repoPath, ".git"))) continue;
+          const repoPath = join31(config2.path, repo.path);
+          if (!existsSync32(join31(repoPath, ".git"))) continue;
           const repoWorktrees = listWorktrees(repoPath);
           for (const wt of repoWorktrees) {
             if (wt.path.includes("/workspaces/") || wt.path.includes("\\workspaces\\")) {
               const parts = wt.path.split("/workspaces/");
               if (parts.length > 1) {
                 const workspaceDir = parts[1].split("/")[0];
-                const canonicalPath = join30(config2.path, "workspaces", workspaceDir);
+                const canonicalPath = join31(config2.path, "workspaces", workspaceDir);
                 if (!workspaces2.some((w) => w.path === canonicalPath)) {
                   workspaces2.push({ ...wt, path: canonicalPath });
                 }
@@ -7707,7 +7810,7 @@ async function listCommand2(options) {
           }
         }
       } else {
-        if (!existsSync31(join30(config2.path, ".git"))) continue;
+        if (!existsSync32(join31(config2.path, ".git"))) continue;
         const worktrees2 = listWorktrees(config2.path);
         for (const wt of worktrees2) {
           if (wt.path.includes("/workspaces/") || wt.path.includes("\\workspaces\\")) {
@@ -7747,7 +7850,7 @@ ${proj.projectName}
     return;
   }
   const projectRoot = process.cwd();
-  if (!existsSync31(join30(projectRoot, ".git"))) {
+  if (!existsSync32(join31(projectRoot, ".git"))) {
     console.error(chalk33.red("Not a git repository."));
     if (projects.length > 0) {
       console.log(chalk33.dim("Tip: Use --all to list workspaces across all registered projects."));
@@ -7817,7 +7920,7 @@ async function destroyCommand(issueId, options) {
       spinner.text = "Running custom remove command...";
       const cmd = `${projectConfig.workspace_remove_command} ${normalizedId}`;
       try {
-        const { stdout } = await execAsync10(cmd, {
+        const { stdout } = await execAsync11(cmd, {
           cwd: projectConfig.path,
           encoding: "utf-8",
           timeout: 12e4
@@ -7843,17 +7946,17 @@ async function destroyCommand(issueId, options) {
         projectRoot = process.cwd();
       }
     }
-    const workspacePath = join30(projectRoot, "workspaces", folderName);
-    if (!existsSync31(workspacePath)) {
-      const cwdPath = join30(process.cwd(), "workspaces", folderName);
-      if (projectRoot !== process.cwd() && existsSync31(cwdPath)) {
+    const workspacePath = join31(projectRoot, "workspaces", folderName);
+    if (!existsSync32(workspacePath)) {
+      const cwdPath = join31(process.cwd(), "workspaces", folderName);
+      if (projectRoot !== process.cwd() && existsSync32(cwdPath)) {
         projectRoot = process.cwd();
       } else {
         spinner.fail(`Workspace not found: ${workspacePath}`);
         process.exit(1);
       }
     }
-    const finalWorkspacePath = join30(projectRoot, "workspaces", folderName);
+    const finalWorkspacePath = join31(projectRoot, "workspaces", folderName);
     spinner.text = "Removing git worktree...";
     removeWorktree2(projectRoot, finalWorkspacePath);
     spinner.succeed(`Workspace destroyed: ${folderName}`);
@@ -7892,7 +7995,7 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
   }
   if (!projectId) {
     try {
-      const { stdout } = await execAsync10("git remote get-url origin", {
+      const { stdout } = await execAsync11("git remote get-url origin", {
         cwd: projectRoot,
         encoding: "utf-8"
       });
@@ -7918,7 +8021,7 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
     await exe.createVm(vmName);
     let repoUrl = "";
     try {
-      const { stdout } = await execAsync10("git remote get-url origin", {
+      const { stdout } = await execAsync11("git remote get-url origin", {
         cwd: projectRoot,
         encoding: "utf-8"
       });
@@ -7939,13 +8042,13 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
       await exe.ssh(vmName, `ssh-keyscan -t ed25519,rsa ${gitHost} >> ~/.ssh/known_hosts 2>/dev/null`);
     }
     const sshKeyPaths = [
-      join30(homedir15(), ".panopticon", "ssh", "exe-dev-key"),
-      join30(homedir15(), ".ssh", "id_ed25519"),
-      join30(homedir15(), ".ssh", "id_rsa")
+      join31(homedir16(), ".panopticon", "ssh", "exe-dev-key"),
+      join31(homedir16(), ".ssh", "id_ed25519"),
+      join31(homedir16(), ".ssh", "id_rsa")
     ];
-    const sshKeyPath = sshKeyPaths.find((p) => existsSync31(p));
+    const sshKeyPath = sshKeyPaths.find((p) => existsSync32(p));
     if (sshKeyPath) {
-      const sshKeyBase64 = Buffer.from(readFileSync27(sshKeyPath, "utf-8")).toString("base64");
+      const sshKeyBase64 = Buffer.from(readFileSync28(sshKeyPath, "utf-8")).toString("base64");
       const keyFilename = sshKeyPath.includes("id_rsa") ? "id_rsa" : "id_ed25519";
       await exe.ssh(vmName, `echo '${sshKeyBase64}' | base64 -d > ~/.ssh/${keyFilename} && chmod 600 ~/.ssh/${keyFilename}`);
     }
@@ -7961,11 +8064,11 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
       await exe.ssh(vmName, "mkdir -p ~/workspace");
       for (const repo of projectConfig.workspace.repos) {
         spinner.text = `Cloning ${repo.name}...`;
-        const rawRepoPath = join30(projectRoot, repo.path);
-        const actualRepoPath = existsSync31(rawRepoPath) ? realpathSync(rawRepoPath) : rawRepoPath;
+        const rawRepoPath = join31(projectRoot, repo.path);
+        const actualRepoPath = existsSync32(rawRepoPath) ? realpathSync(rawRepoPath) : rawRepoPath;
         let repoRemoteUrl;
         try {
-          const { stdout } = await execAsync10("git remote get-url origin", {
+          const { stdout } = await execAsync11("git remote get-url origin", {
             cwd: actualRepoPath,
             encoding: "utf-8"
           });
@@ -8001,7 +8104,7 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
     spinner.text = "Configuring Claude Code...";
     await exe.ssh(vmName, `mkdir -p ~/.claude`);
     try {
-      const { stdout: credentials } = await execAsync10(
+      const { stdout: credentials } = await execAsync11(
         'security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null',
         { encoding: "utf-8" }
       );
@@ -8153,8 +8256,8 @@ async function migrateCommand(issueId, options) {
     }
     spinner.text = "Syncing beads...";
     try {
-      await execAsync10("bd sync", { encoding: "utf-8" });
-      await execAsync10('git add .beads/ && git commit -m "Sync beads before migration" && git push', { encoding: "utf-8" });
+      await execAsync11("bd sync", { encoding: "utf-8" });
+      await execAsync11('git add .beads/ && git commit -m "Sync beads before migration" && git push', { encoding: "utf-8" });
     } catch {
     }
     const branchName = `feature/${normalizedId}`;
@@ -8295,8 +8398,8 @@ async function destroyRemoteWorkspace(issueId, normalizedId, metadata, spinner,
       } catch {
       }
     }
-    const metadataFile = join30(WORKSPACES_DIR, `${normalizedId}.yaml`);
-    if (existsSync31(metadataFile)) {
+    const metadataFile = join31(WORKSPACES_DIR, `${normalizedId}.yaml`);
+    if (existsSync32(metadataFile)) {
       rmSync4(metadataFile);
     }
     spinner.succeed(`Remote workspace ${issueId} destroyed`);
@@ -8322,9 +8425,9 @@ async function updateCommand(issueId, options) {
       process.exit(1);
     }
     const workspaceConfig = projectConfig.workspace;
-    const workspacesDir = join30(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
-    const workspacePath = join30(workspacesDir, folderName);
-    if (!existsSync31(workspacePath)) {
+    const workspacesDir = join31(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
+    const workspacePath = join31(workspacesDir, folderName);
+    if (!existsSync32(workspacePath)) {
       spinner.fail(`Workspace not found: ${workspacePath}`);
       process.exit(1);
     }
@@ -8344,7 +8447,7 @@ async function updateCommand(issueId, options) {
     const result = mergeSkillsIntoWorkspace(workspacePath);
     if (workspaceConfig?.agent?.template_dir && (workspaceConfig.agent.copy_dirs || workspaceConfig.agent.symlinks)) {
       spinner.text = "Applying project template overlay...";
-      const templateDir = join30(projectConfig.path, workspaceConfig.agent.template_dir);
+      const templateDir = join31(projectConfig.path, workspaceConfig.agent.template_dir);
       const overlayed = applyProjectTemplateOverlay(workspacePath, templateDir);
       result.overlayed = overlayed;
     }
@@ -8376,12 +8479,12 @@ import ora17 from "ora";
 // src/lib/test-runner.ts
 init_esm_shims();
 init_workspace_config();
-import { existsSync as existsSync32, mkdirSync as mkdirSync13, writeFileSync as writeFileSync11 } from "fs";
-import { join as join31, basename as basename7 } from "path";
-import { exec as exec11 } from "child_process";
-import { promisify as promisify11 } from "util";
-import { homedir as homedir16 } from "os";
-var execAsync11 = promisify11(exec11);
+import { existsSync as existsSync33, mkdirSync as mkdirSync13, writeFileSync as writeFileSync11 } from "fs";
+import { join as join32, basename as basename7 } from "path";
+import { exec as exec12 } from "child_process";
+import { promisify as promisify12 } from "util";
+import { homedir as homedir17 } from "os";
+var execAsync12 = promisify12(exec12);
 function formatDuration(seconds) {
   const minutes = Math.floor(seconds / 60);
   const secs = seconds % 60;
@@ -8431,8 +8534,8 @@ function parseTestOutput(output, type) {
   return { passed, failed };
 }
 async function runTestSuite(testName, testConfig, workspacePath, placeholders, reportsDir, timestamp) {
-  const testPath = join31(workspacePath, testConfig.path);
-  const logFile = join31(reportsDir, `${testName}-${timestamp}.log`);
+  const testPath = join32(workspacePath, testConfig.path);
+  const logFile = join32(reportsDir, `${testName}-${timestamp}.log`);
   const result = {
     name: testName,
     status: "pending",
@@ -8455,7 +8558,7 @@ async function runTestSuite(testName, testConfig, workspacePath, placeholders, r
   }
   const startTime = Date.now();
   try {
-    const { stdout, stderr } = await execAsync11(command, {
+    const { stdout, stderr } = await execAsync12(command, {
       cwd: testPath,
       env,
       timeout: 6e5,
@@ -8483,7 +8586,7 @@ async function runTestSuite(testName, testConfig, workspacePath, placeholders, r
   result.duration = formatDuration(Math.floor((endTime - startTime) / 1e3));
   return result;
 }
-function generateReport(result) {
+function generateReport2(result) {
   const lines = [
     `# Test Run Report - ${result.target}`,
     "",
@@ -8524,10 +8627,10 @@ function generateReport(result) {
 async function sendNotification(result) {
   const title = `Tests (${result.target}): ${result.overallStatus === "passed" ? "\u2705 All Passed" : "\u274C Failed"}`;
   const message = result.overallStatus === "passed" ? "All test suites passed" : `${result.totalFailures} suite(s) failed. Check report: ${result.reportFile}`;
-  const notifyScript = join31(homedir16(), ".panopticon", "bin", "notify-complete");
-  if (existsSync32(notifyScript)) {
+  const notifyScript = join32(homedir17(), ".panopticon", "bin", "notify-complete");
+  if (existsSync33(notifyScript)) {
     try {
-      await execAsync11(`"${notifyScript}" "${result.target}" "${message}"`);
+      await execAsync12(`"${notifyScript}" "${result.target}" "${message}"`);
     } catch {
     }
   }
@@ -8543,12 +8646,12 @@ async function runTests(options) {
   let target;
   let baseUrl;
   if (featureName) {
-    const workspacesDir = join31(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
+    const workspacesDir = join32(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
     const featureFolder2 = `feature-${featureName}`;
-    workspacePath = join31(workspacesDir, featureFolder2);
+    workspacePath = join32(workspacesDir, featureFolder2);
     target = featureFolder2;
     baseUrl = workspaceConfig?.dns?.domain ? `https://${featureFolder2}.${workspaceConfig.dns.domain}` : `http://localhost:3000`;
-    if (!existsSync32(workspacePath)) {
+    if (!existsSync33(workspacePath)) {
       throw new Error(`Workspace not found: ${workspacePath}`);
     }
   } else {
@@ -8565,12 +8668,13 @@ async function runTests(options) {
     DOMAIN: workspaceConfig?.dns?.domain || "localhost",
     PROJECT_NAME: basename7(projectConfig.path),
     PROJECT_PATH: projectConfig.path,
+    PROJECTS_DIR: join32(projectConfig.path, ".."),
     WORKSPACE_PATH: workspacePath
   };
-  const reportsDir = join31(projectConfig.path, "reports");
+  const reportsDir = join32(projectConfig.path, "reports");
   mkdirSync13(reportsDir, { recursive: true });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const reportFile = join31(reportsDir, `test-run-${target}-${timestamp}.md`);
+  const reportFile = join32(reportsDir, `test-run-${target}-${timestamp}.md`);
   const result = {
     target,
     baseUrl,
@@ -8608,7 +8712,7 @@ async function runTests(options) {
     console.log("");
   }
   result.overallStatus = result.totalFailures === 0 ? "passed" : "failed";
-  const report = generateReport(result);
+  const report = generateReport2(result);
   writeFileSync11(reportFile, report);
   console.log("==============================================");
   console.log(`COMPLETE: ${result.overallStatus === "passed" ? "\u2705 ALL PASSED" : "\u274C FAILED"}`);
@@ -8734,21 +8838,21 @@ import chalk35 from "chalk";
 import ora18 from "ora";
 import inquirer5 from "inquirer";
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync33, mkdirSync as mkdirSync14, writeFileSync as writeFileSync12, readFileSync as readFileSync28, copyFileSync, readdirSync as readdirSync15, statSync as statSync6 } from "fs";
-import { join as join32 } from "path";
-import { homedir as homedir17 } from "os";
+import { existsSync as existsSync34, mkdirSync as mkdirSync14, writeFileSync as writeFileSync12, readFileSync as readFileSync29, copyFileSync, readdirSync as readdirSync15, statSync as statSync6 } from "fs";
+import { join as join33 } from "path";
+import { homedir as homedir18 } 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").option("--skip-beads", "Skip beads CLI installation").option("--skip-router", "Skip claude-code-router installation").option("--skip-sageox", "Skip SageOx CLI installation").action(installCommand);
 }
 function copyDirectoryRecursive(source, dest) {
-  if (!existsSync33(source)) {
+  if (!existsSync34(source)) {
     throw new Error(`Source directory not found: ${source}`);
   }
   mkdirSync14(dest, { recursive: true });
   const entries = readdirSync15(source);
   for (const entry of entries) {
-    const sourcePath = join32(source, entry);
-    const destPath = join32(dest, entry);
+    const sourcePath = join33(source, entry);
+    const destPath = join33(dest, entry);
     const stat = statSync6(sourcePath);
     if (stat.isDirectory()) {
       copyDirectoryRecursive(sourcePath, destPath);
@@ -8848,7 +8952,7 @@ function checkPrerequisites() {
     message: hasJq ? "installed" : "not found",
     fix: "apt install jq / brew install jq"
   });
-  const hasTtyd = checkCommand2("ttyd") || existsSync33(join32(homedir17(), "bin", "ttyd"));
+  const hasTtyd = checkCommand2("ttyd") || existsSync34(join33(homedir18(), "bin", "ttyd"));
   results.push({
     name: "ttyd",
     passed: hasTtyd,
@@ -8924,9 +9028,9 @@ async function installCommand(options) {
           execSync4("brew install mkcert", { stdio: "pipe", timeout: 12e4 });
           spinner.succeed("mkcert installed via Homebrew");
         } else {
-          const binDir = join32(homedir17(), ".local", "bin");
+          const binDir = join33(homedir18(), ".local", "bin");
           mkdirSync14(binDir, { recursive: true });
-          const mkcertPath = join32(binDir, "mkcert");
+          const mkcertPath = join33(binDir, "mkcert");
           const arch = process.arch === "x64" ? "amd64" : process.arch;
           execSync4(`curl -sL "https://github.com/FiloSottile/mkcert/releases/latest/download/mkcert-v1.4.4-linux-${arch}" -o "${mkcertPath}" && chmod +x "${mkcertPath}"`, {
             stdio: "pipe",
@@ -8945,14 +9049,14 @@ async function installCommand(options) {
         execSync4("mkcert -install", { stdio: "pipe" });
         spinner.succeed("mkcert CA installed");
         spinner.start("Generating wildcard certificates...");
-        const traefikCertFile = join32(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost.pem");
-        const traefikKeyFile = join32(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost-key.pem");
+        const traefikCertFile = join33(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost.pem");
+        const traefikKeyFile = join33(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost-key.pem");
         execSync4(
           `mkcert -cert-file "${traefikCertFile}" -key-file "${traefikKeyFile}" "pan.localhost" "*.pan.localhost" "*.localhost" localhost 127.0.0.1 ::1`,
           { stdio: "pipe" }
         );
-        const legacyCertFile = join32(CERTS_DIR, "localhost.pem");
-        const legacyKeyFile = join32(CERTS_DIR, "localhost-key.pem");
+        const legacyCertFile = join33(CERTS_DIR, "localhost.pem");
+        const legacyKeyFile = join33(CERTS_DIR, "localhost-key.pem");
         copyFileSync(traefikCertFile, legacyCertFile);
         copyFileSync(traefikKeyFile, legacyKeyFile);
         spinner.succeed("Wildcard certificates generated (*.pan.localhost, *.localhost)");
@@ -8970,13 +9074,13 @@ async function installCommand(options) {
       spinner.info("Skipping mkcert (not installed)");
     }
   }
-  const hasTtyd = checkCommand2("ttyd") || existsSync33(join32(homedir17(), "bin", "ttyd"));
+  const hasTtyd = checkCommand2("ttyd") || existsSync34(join33(homedir18(), "bin", "ttyd"));
   if (!hasTtyd) {
     spinner.start("Installing ttyd (web terminal)...");
     try {
-      const binDir = join32(homedir17(), "bin");
+      const binDir = join33(homedir18(), "bin");
       mkdirSync14(binDir, { recursive: true });
-      const ttydPath = join32(binDir, "ttyd");
+      const ttydPath = join33(binDir, "ttyd");
       const plat2 = detectPlatform();
       let downloadUrl = "";
       if (plat2 === "darwin") {
@@ -9088,9 +9192,9 @@ async function installCommand(options) {
     if (!hasOxNow) {
       spinner.start("Installing SageOx CLI (ox)...");
       try {
-        const binDir = join32(homedir17(), ".local", "bin");
+        const binDir = join33(homedir18(), ".local", "bin");
         mkdirSync14(binDir, { recursive: true });
-        const oxPath = join32(binDir, "ox");
+        const oxPath = join33(binDir, "ox");
         const arch = process.arch === "x64" ? "amd64" : process.arch;
         const plat2 = detectPlatform();
         const platform2 = plat2 === "darwin" ? "darwin" : "linux";
@@ -9109,7 +9213,7 @@ async function installCommand(options) {
   if (!options.minimal) {
     spinner.start("Setting up Traefik configuration...");
     try {
-      if (!existsSync33(join32(TRAEFIK_DIR, "docker-compose.yml"))) {
+      if (!existsSync34(join33(TRAEFIK_DIR, "docker-compose.yml"))) {
         copyDirectoryRecursive(SOURCE_TRAEFIK_TEMPLATES, TRAEFIK_DIR);
         cleanupTemplateFiles();
         spinner.succeed("Traefik configuration created from templates");
@@ -9122,9 +9226,9 @@ async function installCommand(options) {
       if (generateTlsConfig()) {
         spinner.succeed("TLS config generated (tls.yml)");
       }
-      const existingCompose = join32(TRAEFIK_DIR, "docker-compose.yml");
-      if (existsSync33(existingCompose)) {
-        const content = readFileSync28(existingCompose, "utf-8");
+      const existingCompose = join33(TRAEFIK_DIR, "docker-compose.yml");
+      if (existsSync34(existingCompose)) {
+        const content = readFileSync29(existingCompose, "utf-8");
         if (content.includes("panopticon:") && !content.includes("external: true")) {
           const patched = content.replace(
             /networks:\s*\n\s*panopticon:\s*\n\s*name: panopticon\s*\n\s*driver: bridge/,
@@ -9139,8 +9243,8 @@ async function installCommand(options) {
       console.log(chalk35.yellow("You can set up Traefik manually later"));
     }
   }
-  const configFile = join32(PANOPTICON_HOME, "config.toml");
-  const configExists = existsSync33(configFile);
+  const configFile = join33(PANOPTICON_HOME, "config.toml");
+  const configExists = existsSync34(configFile);
   if (!configExists) {
     spinner.start("Creating default config...");
   } else {
@@ -9348,82 +9452,27 @@ function getHealthLabel(state) {
   }
 }
 
-// src/lib/cloister/database.ts
+// src/lib/database/health-events-db.ts
 init_esm_shims();
-init_paths();
-import Database from "better-sqlite3";
-import { join as join33 } from "path";
-import { existsSync as existsSync34, mkdirSync as mkdirSync15 } from "fs";
-var CLOISTER_DB_PATH = join33(PANOPTICON_HOME, "cloister.db");
-var RETENTION_DAYS = 7;
-var db = null;
-function initHealthDatabase() {
-  if (!existsSync34(PANOPTICON_HOME)) {
-    mkdirSync15(PANOPTICON_HOME, { recursive: true });
-  }
-  db = new Database(CLOISTER_DB_PATH);
-  db.pragma("journal_mode = WAL");
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS health_events (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      agent_id TEXT NOT NULL,
-      timestamp TEXT NOT NULL,
-      state TEXT NOT NULL,
-      previous_state TEXT,
-      source TEXT,
-      metadata TEXT
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_agent_timestamp
-      ON health_events(agent_id, timestamp);
-
-    CREATE INDEX IF NOT EXISTS idx_timestamp
-      ON health_events(timestamp);
-  `);
-  cleanupOldEvents(db);
-  return db;
-}
-function getHealthDatabase() {
-  if (!db) {
-    return initHealthDatabase();
-  }
-  return db;
-}
-function closeHealthDatabase() {
-  if (db) {
-    db.close();
-    db = null;
-  }
-}
+init_database();
 function writeHealthEvent(event) {
-  const database = getHealthDatabase();
-  const stmt = database.prepare(`
+  const db = getDatabase();
+  const result = db.prepare(`
     INSERT INTO health_events (agent_id, timestamp, state, previous_state, source, metadata)
     VALUES (?, ?, ?, ?, ?, ?)
-  `);
-  const result = stmt.run(
+  `).run(
     event.agentId,
     event.timestamp,
     event.state,
-    event.previousState || null,
-    event.source || null,
-    event.metadata || null
+    event.previousState ?? null,
+    event.source ?? null,
+    event.metadata ?? null
   );
   return result.lastInsertRowid;
 }
-function cleanupOldEvents(database = getHealthDatabase(), retentionDays = RETENTION_DAYS) {
-  const cutoffDate = /* @__PURE__ */ new Date();
-  cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
-  const cutoffTimestamp = cutoffDate.toISOString();
-  const stmt = database.prepare(`
-    DELETE FROM health_events
-    WHERE timestamp < ?
-  `);
-  const result = stmt.run(cutoffTimestamp);
-  return result.changes;
-}
 
 // src/lib/cloister/service.ts
+init_database();
 init_specialists();
 
 // src/lib/runtimes/index.ts
@@ -9437,10 +9486,10 @@ init_esm_shims();
 init_agents();
 init_tmux();
 init_jsonl_parser();
-import { existsSync as existsSync35, readFileSync as readFileSync29, statSync as statSync7, mkdirSync as mkdirSync16, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync30, statSync as statSync7, mkdirSync as mkdirSync15, writeFileSync as writeFileSync13 } from "fs";
 import { join as join34 } from "path";
-import { homedir as homedir18 } from "os";
-var CLAUDE_PROJECTS_DIR = join34(homedir18(), ".claude", "projects");
+import { homedir as homedir19 } from "os";
+var CLAUDE_PROJECTS_DIR = join34(homedir19(), ".claude", "projects");
 var ClaudeCodeRuntime = class {
   name = "claude-code";
   /**
@@ -9458,7 +9507,7 @@ var ClaudeCodeRuntime = class {
       const indexPath = join34(projectDir, "sessions-index.json");
       if (existsSync35(indexPath)) {
         try {
-          const indexContent = readFileSync29(indexPath, "utf-8");
+          const indexContent = readFileSync30(indexPath, "utf-8");
           if (indexContent.includes(workspace)) {
             return projectDir;
           }
@@ -9477,7 +9526,7 @@ var ClaudeCodeRuntime = class {
       return null;
     }
     try {
-      const indexContent = readFileSync29(indexPath, "utf-8");
+      const indexContent = readFileSync30(indexPath, "utf-8");
       const index = JSON.parse(indexContent);
       if (index.sessions && Array.isArray(index.sessions)) {
         const sessions = index.sessions;
@@ -9540,12 +9589,12 @@ var ClaudeCodeRuntime = class {
    * Read active heartbeat file if it exists
    */
   getActiveHeartbeat(agentId) {
-    const heartbeatPath = join34(homedir18(), ".panopticon", "heartbeats", `${agentId}.json`);
+    const heartbeatPath = join34(homedir19(), ".panopticon", "heartbeats", `${agentId}.json`);
     if (!existsSync35(heartbeatPath)) {
       return null;
     }
     try {
-      const content = readFileSync29(heartbeatPath, "utf-8");
+      const content = readFileSync30(heartbeatPath, "utf-8");
       const data = JSON.parse(content);
       const timestamp = new Date(data.timestamp);
       const now = /* @__PURE__ */ new Date();
@@ -9650,7 +9699,7 @@ var ClaudeCodeRuntime = class {
     }
     await sendKeysAsync(agentId, message);
     const mailDir = join34(getAgentDir(agentId), "mail");
-    mkdirSync16(mailDir, { recursive: true });
+    mkdirSync15(mailDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     writeFileSync13(
       join34(mailDir, `${timestamp}.md`),
@@ -9668,6 +9717,7 @@ ${message}
       throw new Error(`Agent ${agentId} is not running`);
     }
     killSession(agentId);
+    saveAgentRuntimeState(agentId, { state: "idle", lastActivity: (/* @__PURE__ */ new Date()).toISOString() });
     const state = getAgentState(agentId);
     if (state) {
       state.status = "stopped";
@@ -9810,9 +9860,9 @@ init_agents();
 // src/lib/cloister/triggers.ts
 init_esm_shims();
 init_config2();
-import { exec as exec12 } from "child_process";
-import { promisify as promisify12 } from "util";
-var execAsync12 = promisify12(exec12);
+import { exec as exec13 } from "child_process";
+import { promisify as promisify13 } from "util";
+var execAsync13 = promisify13(exec13);
 function checkStuckEscalation(health, currentModel, config2) {
   const conf = config2 || loadCloisterConfig();
   const stuckConfig = conf.handoffs?.auto_triggers?.stuck_escalation;
@@ -9936,7 +9986,7 @@ async function checkTaskCompletion(issueId, config2) {
     };
   }
   try {
-    const { stdout: output } = await execAsync12(`bd list --json -l ${issueId.toLowerCase()} --status closed`, {
+    const { stdout: output } = await execAsync13(`bd list --json -l ${issueId.toLowerCase()} --status closed`, {
       encoding: "utf-8"
     });
     const tasks = JSON.parse(output);
@@ -9944,7 +9994,7 @@ async function checkTaskCompletion(issueId, config2) {
       (t) => t.title.toLowerCase().includes("implement") || t.labels?.includes("implementation")
     );
     if (implementTask) {
-      const { stdout: openOutput } = await execAsync12(`bd list --json -l ${issueId.toLowerCase()} --status open`, {
+      const { stdout: openOutput } = await execAsync13(`bd list --json -l ${issueId.toLowerCase()} --status open`, {
         encoding: "utf-8"
       });
       const openTasks = JSON.parse(openOutput);
@@ -9988,16 +10038,16 @@ async function checkAllTriggers(agentId, workspace, issueId, currentModel, healt
 // src/lib/cloister/handoff.ts
 init_esm_shims();
 init_agents();
-import { writeFileSync as writeFileSync14, mkdirSync as mkdirSync17 } from "fs";
+import { writeFileSync as writeFileSync14, mkdirSync as mkdirSync16 } from "fs";
 import { join as join36 } from "path";
 
 // src/lib/cloister/handoff-context.ts
 init_esm_shims();
-import { existsSync as existsSync36, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync31 } from "fs";
 import { join as join35 } from "path";
-import { exec as exec13 } from "child_process";
-import { promisify as promisify13 } from "util";
-var execAsync13 = promisify13(exec13);
+import { exec as exec14 } from "child_process";
+import { promisify as promisify14 } from "util";
+var execAsync14 = promisify14(exec14);
 async function captureHandoffContext(agentState, targetModel, reason) {
   const context = {
     issueId: agentState.issueId,
@@ -10020,11 +10070,11 @@ async function captureFiles(context, workspace) {
   try {
     const stateFile = join35(workspace, ".planning/STATE.md");
     if (existsSync36(stateFile)) {
-      context.stateFile = readFileSync30(stateFile, "utf-8");
+      context.stateFile = readFileSync31(stateFile, "utf-8");
     }
     const claudeMd = join35(workspace, "CLAUDE.md");
     if (existsSync36(claudeMd)) {
-      context.claudeMd = readFileSync30(claudeMd, "utf-8");
+      context.claudeMd = readFileSync31(claudeMd, "utf-8");
     }
   } catch (error) {
     console.error("Error capturing files:", error);
@@ -10032,17 +10082,17 @@ async function captureFiles(context, workspace) {
 }
 async function captureGitState(context, workspace) {
   try {
-    const { stdout: branch } = await execAsync13("git branch --show-current", {
+    const { stdout: branch } = await execAsync14("git branch --show-current", {
       cwd: workspace,
       encoding: "utf-8"
     });
     context.gitBranch = branch.trim();
-    const { stdout: status } = await execAsync13("git status --porcelain", {
+    const { stdout: status } = await execAsync14("git status --porcelain", {
       cwd: workspace,
       encoding: "utf-8"
     });
     context.uncommittedFiles = status.split("\n").filter((line) => line.trim()).map((line) => line.substring(3));
-    const { stdout: lastCommit } = await execAsync13("git log -1 --oneline", {
+    const { stdout: lastCommit } = await execAsync14("git log -1 --oneline", {
       cwd: workspace,
       encoding: "utf-8"
     });
@@ -10054,7 +10104,7 @@ async function captureGitState(context, workspace) {
 async function captureBeadsTasks(context, issueId) {
   try {
     const label = issueId.toLowerCase();
-    const { stdout: output } = await execAsync13(`bd list --json -l ${label}`, {
+    const { stdout: output } = await execAsync14(`bd list --json -l ${label}`, {
       encoding: "utf-8"
     });
     const tasks = JSON.parse(output);
@@ -10216,7 +10266,7 @@ async function performKillAndSpawn(state, options) {
     stopAgent(state.id);
     const prompt = buildHandoffPrompt(context, options.additionalInstructions);
     const handoffDir = join36(getAgentDir(state.id), "handoffs");
-    mkdirSync17(handoffDir, { recursive: true });
+    mkdirSync16(handoffDir, { recursive: true });
     const handoffFile = join36(handoffDir, `handoff-${Date.now()}.md`);
     writeFileSync14(handoffFile, prompt);
     const newState = await spawnAgent({
@@ -10326,13 +10376,13 @@ function sleep(ms) {
 // src/lib/cloister/handoff-logger.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync38, mkdirSync as mkdirSync18, appendFileSync as appendFileSync3, readFileSync as readFileSync31, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync17, appendFileSync as appendFileSync3, readFileSync as readFileSync32, writeFileSync as writeFileSync15 } from "fs";
 import { join as join37 } from "path";
 var HANDOFF_LOG_FILE = join37(PANOPTICON_HOME, "logs", "handoffs.jsonl");
 function ensureLogDir() {
   const logDir = join37(PANOPTICON_HOME, "logs");
   if (!existsSync38(logDir)) {
-    mkdirSync18(logDir, { recursive: true });
+    mkdirSync17(logDir, { recursive: true });
   }
 }
 function logHandoffEvent(event) {
@@ -10375,7 +10425,7 @@ function createHandoffEvent(agentId, issueId, context, trigger, success, errorMe
 // src/lib/cloister/fpp-violations.ts
 init_esm_shims();
 init_hooks();
-import { readFileSync as readFileSync32, existsSync as existsSync39, writeFileSync as writeFileSync16, mkdirSync as mkdirSync19, unlinkSync as unlinkSync3 } from "fs";
+import { readFileSync as readFileSync33, existsSync as existsSync39, writeFileSync as writeFileSync16, mkdirSync as mkdirSync18, unlinkSync as unlinkSync3 } from "fs";
 import { join as join38, dirname as dirname11 } from "path";
 init_paths();
 var DEFAULT_FPP_CONFIG = {
@@ -10390,7 +10440,7 @@ function loadViolations() {
     return /* @__PURE__ */ new Map();
   }
   try {
-    const fileContent = readFileSync32(VIOLATIONS_DATA_FILE, "utf-8");
+    const fileContent = readFileSync33(VIOLATIONS_DATA_FILE, "utf-8");
     const persisted = JSON.parse(fileContent);
     return new Map(persisted.violations || []);
   } catch (error) {
@@ -10402,14 +10452,14 @@ function saveViolations(violations) {
   try {
     const dir = dirname11(VIOLATIONS_DATA_FILE);
     if (!existsSync39(dir)) {
-      mkdirSync19(dir, { recursive: true });
+      mkdirSync18(dir, { recursive: true });
     }
     const persisted = {
       violations: Array.from(violations.entries())
     };
     const tempFile = `${VIOLATIONS_DATA_FILE}.tmp`;
     writeFileSync16(tempFile, JSON.stringify(persisted, null, 2));
-    writeFileSync16(VIOLATIONS_DATA_FILE, readFileSync32(tempFile));
+    writeFileSync16(VIOLATIONS_DATA_FILE, readFileSync33(tempFile));
     try {
       unlinkSync3(tempFile);
     } catch (unlinkError) {
@@ -10499,7 +10549,7 @@ function clearOldViolations(hoursOld = 24) {
 init_esm_shims();
 init_paths();
 init_config2();
-import { readFileSync as readFileSync33, existsSync as existsSync40, writeFileSync as writeFileSync17, mkdirSync as mkdirSync20, unlinkSync as unlinkSync4 } from "fs";
+import { readFileSync as readFileSync34, existsSync as existsSync40, writeFileSync as writeFileSync17, mkdirSync as mkdirSync19, unlinkSync as unlinkSync4 } from "fs";
 import { join as join39, dirname as dirname12 } from "path";
 var COST_DATA_FILE = join39(PANOPTICON_HOME, "cost-data.json");
 function loadCostData() {
@@ -10512,7 +10562,7 @@ function loadCostData() {
     };
   }
   try {
-    const fileContent = readFileSync33(COST_DATA_FILE, "utf-8");
+    const fileContent = readFileSync34(COST_DATA_FILE, "utf-8");
     const persisted = JSON.parse(fileContent);
     return {
       perAgent: new Map(Object.entries(persisted.perAgent || {})),
@@ -10534,7 +10584,7 @@ function saveCostData(data) {
   try {
     const dir = dirname12(COST_DATA_FILE);
     if (!existsSync40(dir)) {
-      mkdirSync20(dir, { recursive: true });
+      mkdirSync19(dir, { recursive: true });
     }
     const persisted = {
       perAgent: Object.fromEntries(data.perAgent),
@@ -10544,7 +10594,7 @@ function saveCostData(data) {
     };
     const tempFile = `${COST_DATA_FILE}.tmp`;
     writeFileSync17(tempFile, JSON.stringify(persisted, null, 2));
-    writeFileSync17(COST_DATA_FILE, readFileSync33(tempFile));
+    writeFileSync17(COST_DATA_FILE, readFileSync34(tempFile));
     try {
       unlinkSync4(tempFile);
     } catch (unlinkError) {
@@ -10666,11 +10716,11 @@ init_esm_shims();
 init_paths();
 import { writeFileSync as writeFileSync18 } from "fs";
 import { join as join40 } from "path";
-import { exec as exec14 } from "child_process";
-import { promisify as promisify14 } from "util";
+import { exec as exec15 } from "child_process";
+import { promisify as promisify15 } from "util";
 init_agents();
 init_specialists();
-var execAsync14 = promisify14(exec14);
+var execAsync15 = promisify15(exec15);
 var SESSION_ROTATION_THRESHOLD = 1e5;
 var DEFAULT_MEMORY_TIERS = {
   recent_summary: 100,
@@ -10692,7 +10742,7 @@ async function buildMergeAgentMemory(workingDir, tiers = DEFAULT_MEMORY_TIERS) {
   const merges = [];
   try {
     const totalMerges = Math.max(tiers.recent_summary, tiers.recent_detailed, tiers.recent_full);
-    const { stdout: gitLog } = await execAsync14(
+    const { stdout: gitLog } = await execAsync15(
       `git log --merges --format="%H|%s|%an|%ad|%D" -n ${totalMerges}`,
       { cwd: workingDir, encoding: "utf-8" }
     );
@@ -10727,14 +10777,14 @@ async function buildMergeAgentMemory(workingDir, tiers = DEFAULT_MEMORY_TIERS) {
     if (merge.branch) memory += `- Branch: ${merge.branch}
 `;
     try {
-      const { stdout: filesOutput } = await execAsync14(`git show --name-only --format= ${merge.hash}`, {
+      const { stdout: filesOutput } = await execAsync15(`git show --name-only --format= ${merge.hash}`, {
         cwd: workingDir,
         encoding: "utf-8"
       });
       const files = filesOutput.trim().split("\n").filter((f) => f);
       memory += `- Files changed: ${files.length}
 `;
-      const { stdout: diff } = await execAsync14(`git show ${merge.hash} --stat`, {
+      const { stdout: diff } = await execAsync15(`git show ${merge.hash} --stat`, {
         cwd: workingDir,
         encoding: "utf-8",
         maxBuffer: 10 * 1024 * 1024
@@ -10811,7 +10861,7 @@ async function rotateSpecialistSession(specialistName, workingDir) {
     }
     const tmuxSession = getTmuxSessionName(specialistName);
     try {
-      await execAsync14(`tmux kill-session -t "${tmuxSession}"`);
+      await execAsync15(`tmux kill-session -t "${tmuxSession}"`);
       console.log(`Killed session: ${tmuxSession}`);
     } catch (error) {
       console.log(`Session ${tmuxSession} not found or already killed`);
@@ -10861,17 +10911,18 @@ init_config2();
 init_specialists();
 init_agents();
 init_tmux();
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync19, existsSync as existsSync42, mkdirSync as mkdirSync21, readdirSync as readdirSync17, statSync as statSync8, rmSync as rmSync5 } from "fs";
+import { readFileSync as readFileSync36, writeFileSync as writeFileSync19, existsSync as existsSync42, mkdirSync as mkdirSync20, readdirSync as readdirSync17, statSync as statSync8, rmSync as rmSync5 } from "fs";
 import { join as join41 } from "path";
-import { exec as exec15 } from "child_process";
-import { promisify as promisify15 } from "util";
-import { homedir as homedir19 } from "os";
-var execAsync15 = promisify15(exec15);
-var REVIEW_STATUS_FILE = join41(homedir19(), ".panopticon", "review-status.json");
+import { exec as exec16, execFile } from "child_process";
+import { promisify as promisify16 } from "util";
+import { homedir as homedir20 } from "os";
+var execAsync16 = promisify16(exec16);
+var execFileAsync = promisify16(execFile);
+var REVIEW_STATUS_FILE = join41(homedir20(), ".panopticon", "review-status.json");
 function updateTestStatusToTesting(issueId) {
   try {
     if (!existsSync42(REVIEW_STATUS_FILE)) return;
-    const data = JSON.parse(readFileSync35(REVIEW_STATUS_FILE, "utf-8"));
+    const data = JSON.parse(readFileSync36(REVIEW_STATUS_FILE, "utf-8"));
     const upper = issueId.toUpperCase();
     if (data[upper]) {
       data[upper].testStatus = "testing";
@@ -10905,7 +10956,7 @@ var config = { ...DEFAULT_CONFIG };
 function loadConfig3() {
   try {
     if (existsSync42(CONFIG_FILE2)) {
-      const content = readFileSync35(CONFIG_FILE2, "utf-8");
+      const content = readFileSync36(CONFIG_FILE2, "utf-8");
       const loaded = JSON.parse(content);
       config = { ...DEFAULT_CONFIG, ...loaded };
     }
@@ -10916,14 +10967,14 @@ function loadConfig3() {
 }
 function ensureDeaconDir() {
   if (!existsSync42(DEACON_DIR)) {
-    mkdirSync21(DEACON_DIR, { recursive: true });
+    mkdirSync20(DEACON_DIR, { recursive: true });
   }
 }
 function loadState() {
   ensureDeaconDir();
   try {
     if (existsSync42(STATE_FILE)) {
-      const content = readFileSync35(STATE_FILE, "utf-8");
+      const content = readFileSync36(STATE_FILE, "utf-8");
       return JSON.parse(content);
     }
   } catch (error) {
@@ -10977,7 +11028,7 @@ function checkHeartbeat(name) {
     if (!existsSync42(heartbeatFile)) {
       return { isResponsive: false };
     }
-    const content = readFileSync35(heartbeatFile, "utf-8");
+    const content = readFileSync36(heartbeatFile, "utf-8");
     const heartbeat = JSON.parse(content);
     const lastActivity = new Date(heartbeat.timestamp).getTime();
     const age = Date.now() - lastActivity;
@@ -11067,7 +11118,7 @@ async function forceKillSpecialist(name, sharedState) {
     };
   }
   try {
-    await execAsync15(`tmux kill-session -t "${tmuxSession}"`);
+    await execAsync16(`tmux kill-session -t "${tmuxSession}"`);
     healthState.lastForceKillTime = (/* @__PURE__ */ new Date()).toISOString();
     healthState.forceKillCount++;
     healthState.consecutiveFailures = 0;
@@ -11166,7 +11217,7 @@ async function checkAndSuspendIdleAgents() {
       try {
         const sessionId = runtimeState.sessionId || `session-${agent.id}`;
         saveSessionId(agent.id, sessionId);
-        await execAsync15(`tmux kill-session -t "${agent.id}" 2>/dev/null || true`);
+        await execAsync16(`tmux kill-session -t "${agent.id}" 2>/dev/null || true`);
         saveAgentRuntimeState(agent.id, {
           state: "suspended",
           suspendedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11209,7 +11260,7 @@ async function checkLazyAgent(sessionName) {
     if (Date.now() - lastSent < LAZY_COOLDOWN_MS) {
       return { isLazy: false };
     }
-    const { stdout } = await execAsync15(
+    const { stdout } = await execAsync16(
       `tmux capture-pane -t "${sessionName}" -p -S -20 2>/dev/null || echo ""`,
       { encoding: "utf-8" }
     );
@@ -11244,11 +11295,11 @@ async function checkLazyAgent(sessionName) {
 }
 async function sendAntiLazyMessage(sessionName) {
   try {
-    await execAsync15(
+    await execAsync16(
       `tmux send-keys -t "${sessionName}" "${ANTI_LAZY_MESSAGE.replace(/"/g, '\\"')}"`,
       { encoding: "utf-8" }
     );
-    await execAsync15(`tmux send-keys -t "${sessionName}" Enter`, { encoding: "utf-8" });
+    await execAsync16(`tmux send-keys -t "${sessionName}" Enter`, { encoding: "utf-8" });
     lazyMessageCooldowns.set(sessionName, Date.now());
     console.log(`[deacon] Sent anti-lazy message to ${sessionName}`);
     return true;
@@ -11266,7 +11317,7 @@ function isIssueCompletedOrInReview(agentId) {
     if (!existsSync42(REVIEW_STATUS_FILE)) {
       return false;
     }
-    const content = readFileSync35(REVIEW_STATUS_FILE, "utf-8");
+    const content = readFileSync36(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const status = statuses[issueId];
     if (!status) {
@@ -11318,7 +11369,7 @@ var ACTIVE_STATUS_PATTERNS = [
 ];
 async function isAgentActiveInTmux(sessionName) {
   try {
-    const { stdout } = await execAsync15(
+    const { stdout } = await execAsync16(
       `tmux capture-pane -t "${sessionName}" -p -S -5 2>/dev/null || echo ""`,
       { encoding: "utf-8" }
     );
@@ -11365,7 +11416,7 @@ async function checkStuckWorkAgents() {
     }
     let tmuxOutput;
     try {
-      const { stdout } = await execAsync15(
+      const { stdout } = await execAsync16(
         `tmux capture-pane -t "${agent.id}" -p -S -10 2>/dev/null || echo ""`,
         { encoding: "utf-8" }
       );
@@ -11386,10 +11437,10 @@ async function checkStuckWorkAgents() {
     console.log(`[deacon] Work agent ${agent.id} stuck thinking for ${thinkingMinutes}m (attempt ${attempts + 1})`);
     try {
       if (attempts === 0) {
-        await execAsync15(`tmux send-keys -t "${agent.id}" Escape 2>/dev/null || true`);
+        await execAsync16(`tmux send-keys -t "${agent.id}" Escape 2>/dev/null || true`);
         actions.push(`Stuck recovery: sent Escape to ${agent.id} (thinking ${thinkingMinutes}m)`);
       } else if (attempts === 1) {
-        await execAsync15(`tmux send-keys -t "${agent.id}" C-c 2>/dev/null || true`);
+        await execAsync16(`tmux send-keys -t "${agent.id}" C-c 2>/dev/null || true`);
         actions.push(`Stuck recovery: sent Ctrl+C to ${agent.id} (thinking ${thinkingMinutes}m)`);
       } else {
         const launcherPath = join41(AGENTS_DIR, agent.id, "launcher.sh");
@@ -11400,9 +11451,9 @@ async function checkStuckWorkAgents() {
           actions.push(`Stuck recovery failed for ${agent.id}: missing launcher or workspace`);
           continue;
         }
-        await execAsync15(`tmux kill-session -t "${agent.id}" 2>/dev/null || true`);
+        await execAsync16(`tmux kill-session -t "${agent.id}" 2>/dev/null || true`);
         await new Promise((r) => setTimeout(r, 1e3));
-        await execAsync15(
+        await execAsync16(
           `tmux new-session -d -s "${agent.id}" -c "${workspace}" "bash ${launcherPath}"`,
           { encoding: "utf-8" }
         );
@@ -11438,7 +11489,7 @@ async function cleanupStaleAgentState() {
       const agentDir = join41(AGENTS_DIR, dir.name);
       try {
         try {
-          await execAsync15(`tmux has-session -t "${dir.name}" 2>/dev/null`);
+          await execAsync16(`tmux has-session -t "${dir.name}" 2>/dev/null`);
           continue;
         } catch {
         }
@@ -11484,7 +11535,7 @@ async function checkOrphanedReviewStatuses() {
     if (!existsSync42(REVIEW_STATUS_FILE)) {
       return actions;
     }
-    const content = readFileSync35(REVIEW_STATUS_FILE, "utf-8");
+    const content = readFileSync36(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const reviewAgentSession = getTmuxSessionName("review-agent");
     const reviewAgentRunning = sessionExists(reviewAgentSession);
@@ -11524,6 +11575,61 @@ async function checkOrphanedReviewStatuses() {
   }
   return actions;
 }
+var MERGE_STUCK_STALENESS_MS = 2 * 60 * 1e3;
+var MERGE_STUCK_COOLDOWN_MS = 10 * 60 * 1e3;
+var MERGE_STUCK_MAX_ATTEMPTS = 3;
+var mergeStuckCooldowns = /* @__PURE__ */ new Map();
+var mergeReadyNotifier = null;
+async function checkReadyForMergeStuck() {
+  const actions = [];
+  try {
+    if (!existsSync42(REVIEW_STATUS_FILE)) {
+      return actions;
+    }
+    const content = readFileSync36(REVIEW_STATUS_FILE, "utf-8");
+    const statuses = JSON.parse(content);
+    const now = Date.now();
+    const state = loadState();
+    const attemptCounts = state.mergeStuckAttempts ?? {};
+    let stateModified = false;
+    for (const [key, status] of Object.entries(statuses)) {
+      if (!status.readyForMerge) continue;
+      if (status.mergeStatus === "merging" || status.mergeStatus === "merged" || status.mergeStatus === "failed") continue;
+      if (!status.updatedAt) continue;
+      const statusAge = now - new Date(status.updatedAt).getTime();
+      if (statusAge < MERGE_STUCK_STALENESS_MS) continue;
+      const lastAttempt = mergeStuckCooldowns.get(key);
+      if (lastAttempt && now - lastAttempt < MERGE_STUCK_COOLDOWN_MS) continue;
+      const attempts = attemptCounts[key] ?? 0;
+      if (attempts >= MERGE_STUCK_MAX_ATTEMPTS) {
+        console.log(`[deacon] Merge stuck circuit breaker active for ${key} (${attempts}/${MERGE_STUCK_MAX_ATTEMPTS} attempts)`);
+        continue;
+      }
+      const ageMin = Math.round((now - new Date(status.updatedAt).getTime()) / 6e4);
+      console.warn(`[deacon] readyForMerge stuck for ${key} (age: ${ageMin}m, attempts: ${attempts}) \u2014 merge requires manual action via MERGE button`);
+      mergeStuckCooldowns.set(key, now);
+      attemptCounts[key] = attempts + 1;
+      stateModified = true;
+      const msg = `Stuck-merge: ${key} has been readyForMerge for ${ageMin}m \u2014 click MERGE to proceed`;
+      if (mergeReadyNotifier) {
+        mergeReadyNotifier(status.issueId ?? key);
+        actions.push(msg);
+        console.log(`[deacon] merge:ready notification sent for ${key}`);
+      } else {
+        actions.push(msg);
+        console.warn(`[deacon] No mergeReadyNotifier registered \u2014 dashboard will not be notified for ${key}`);
+      }
+    }
+    if (stateModified) {
+      state.mergeStuckAttempts = attemptCounts;
+      saveState(state);
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error("[deacon] Error in checkReadyForMergeStuck:", msg);
+  }
+  return actions;
+}
 var deadEndCooldowns = /* @__PURE__ */ new Map();
 var DEAD_END_STALENESS_MS = 5 * 60 * 1e3;
 var DEAD_END_COOLDOWN_MS = 10 * 60 * 1e3;
@@ -11533,7 +11639,7 @@ async function checkDeadEndAgents() {
     if (!existsSync42(REVIEW_STATUS_FILE)) {
       return actions;
     }
-    const content = readFileSync35(REVIEW_STATUS_FILE, "utf-8");
+    const content = readFileSync36(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const now = Date.now();
     for (const [key, status] of Object.entries(statuses)) {
@@ -11601,7 +11707,7 @@ async function checkFirstCompletionAgents() {
       const idleMs = now - lastActivity.getTime();
       if (idleMs < FIRST_COMPLETION_IDLE_MS) continue;
       try {
-        const { stdout: lastLines } = await execAsync15(
+        const { stdout: lastLines } = await execAsync16(
           `tmux capture-pane -t "${agent.id}" -p -S -3 2>/dev/null || echo ""`,
           { encoding: "utf-8" }
         );
@@ -11618,7 +11724,7 @@ async function checkFirstCompletionAgents() {
       const issueKey = issueId.toLowerCase();
       if (existsSync42(REVIEW_STATUS_FILE)) {
         try {
-          const statuses = JSON.parse(readFileSync35(REVIEW_STATUS_FILE, "utf-8"));
+          const statuses = JSON.parse(readFileSync36(REVIEW_STATUS_FILE, "utf-8"));
           const hasStatus = statuses[issueKey] || statuses[issueId] || statuses[issueId.toUpperCase()];
           if (hasStatus) {
             console.log(`[deacon] First-completion gate: skipping ${agent.id} \u2014 has review status entry (readyForMerge=${hasStatus.readyForMerge ?? false})`);
@@ -11645,7 +11751,7 @@ async function checkFirstCompletionAgents() {
       if (!agentState?.workspace || !existsSync42(agentState.workspace)) continue;
       let hasCommits = false;
       try {
-        const { stdout: gitLog } = await execAsync15(
+        const { stdout: gitLog } = await execAsync16(
           "git log --oneline -3 2>/dev/null",
           { cwd: agentState.workspace }
         );
@@ -11655,7 +11761,7 @@ async function checkFirstCompletionAgents() {
           const subdirs = readdirSync17(agentState.workspace, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
           for (const sub of subdirs) {
             try {
-              const { stdout: subLog } = await execAsync15(
+              const { stdout: subLog } = await execAsync16(
                 "git log --oneline -3 2>/dev/null",
                 { cwd: join41(agentState.workspace, sub.name) }
               );
@@ -11692,6 +11798,58 @@ If you still have remaining tasks, continue working on them.`;
   }
   return actions;
 }
+async function patrolWorkAgentResolutions() {
+  const actions = [];
+  try {
+    const agents = listRunningAgents();
+    const specialists = getEnabledSpecialists();
+    const specialistNames = new Set(specialists.map((s) => getTmuxSessionName(s.name)));
+    for (const agent of agents) {
+      if (!agent.id.startsWith("agent-") || specialistNames.has(agent.id)) continue;
+      const runtimeState = getAgentRuntimeState(agent.id);
+      if (!runtimeState?.resolution || runtimeState.resolution === "working" || runtimeState.resolution === "completed") continue;
+      const resolution = runtimeState.resolution;
+      const count = runtimeState.resolutionCount || 0;
+      const issueId = (agent.issueId || agent.id.replace("agent-", "")).toUpperCase();
+      if (resolution === "done" && count >= 2) {
+        console.log(`[deacon] Auto-completing ${agent.id} (${issueId}): resolution=done, count=${count}`);
+        try {
+          const panBin = join41(PANOPTICON_HOME, "bin", "pan");
+          const binExists = existsSync42(panBin);
+          const bin = binExists ? panBin : "pan";
+          await execFileAsync(bin, ["work", "done", issueId, "-c", "Auto-completed by Deacon: evidence showed work complete after 2 nudges"], {
+            timeout: 3e4
+          });
+          saveAgentRuntimeState(agent.id, {
+            resolution: "completed",
+            resolutionCount: count + 1,
+            resolutionUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          actions.push(`Deacon auto-completed ${issueId} (${agent.id}) after ${count} failed nudges`);
+          addLog("action", `Auto-completed ${issueId}: evidence-complete, ${count} nudges exhausted`, void 0);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`[deacon] Failed to auto-complete ${agent.id}:`, msg);
+          actions.push(`Deacon auto-complete failed for ${agent.id}: ${msg}`);
+        }
+      } else if (resolution === "stuck" && count >= 3) {
+        console.log(`[deacon] Poking stuck agent ${agent.id} (${issueId}): count=${count}`);
+        try {
+          const pokeMsg = `Deacon health check: you appear stuck. Please check your current task status, review any errors, and continue working. If work is complete, run: pan work done ${issueId} -c "Implementation complete"`;
+          await sendKeysAsync(agent.id, pokeMsg);
+          actions.push(`Deacon poked stuck agent ${agent.id} (${issueId})`);
+          addLog("action", `Poked stuck agent ${issueId} (count=${count})`, void 0);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`[deacon] Failed to poke ${agent.id}:`, msg);
+        }
+      }
+    }
+  } catch (error) {
+    console.error("[deacon] Error in patrolWorkAgentResolutions:", error);
+  }
+  return actions;
+}
 async function runPatrol() {
   const state = loadState();
   state.patrolCycle++;
@@ -11712,6 +11870,8 @@ async function runPatrol() {
       if (killResult.success) {
         console.log(`[deacon] Auto-restarting ${specialist.name} with fresh session...`);
         clearSessionId(specialist.name);
+        const specialistSession2 = getTmuxSessionName(specialist.name);
+        saveAgentRuntimeState(specialistSession2, { state: "idle", lastActivity: (/* @__PURE__ */ new Date()).toISOString() });
         const wakeResult = await wakeSpecialist(specialist.name, "", {
           waitForReady: true,
           startIfNotRunning: true
@@ -11747,7 +11907,7 @@ async function runPatrol() {
       if (nextTask) {
         console.log(`[deacon] Auto-resuming suspended ${specialist.name} for queued task: ${nextTask.payload.issueId}`);
         try {
-          const { resumeAgent } = await import("../agents-5OPQKM5K.js");
+          const { resumeAgent } = await import("../agents-HNMF52RM.js");
           const message = `# Queued Work
 
 Processing queued task: ${nextTask.payload.issueId}`;
@@ -11801,9 +11961,15 @@ Processing queued task: ${nextTask.payload.issueId}`;
   const deadEndActions = await checkDeadEndAgents();
   actions.push(...deadEndActions);
   for (const a of deadEndActions) addLog("action", a, state.patrolCycle);
+  const mergeStuckActions = await checkReadyForMergeStuck();
+  actions.push(...mergeStuckActions);
+  for (const a of mergeStuckActions) addLog("action", a, state.patrolCycle);
   const firstCompletionActions = await checkFirstCompletionAgents();
   actions.push(...firstCompletionActions);
   for (const a of firstCompletionActions) addLog("action", a, state.patrolCycle);
+  const resolutionActions = await patrolWorkAgentResolutions();
+  actions.push(...resolutionActions);
+  for (const a of resolutionActions) addLog("action", a, state.patrolCycle);
   const lazyActions = await checkAndCorrectLazyAgents();
   actions.push(...lazyActions);
   for (const a of lazyActions) addLog("action", a, state.patrolCycle);
@@ -11821,6 +11987,38 @@ Processing queued task: ${nextTask.payload.issueId}`;
     actions.push(massDeathCheck.message);
     addLog("error", massDeathCheck.message, state.patrolCycle);
   }
+  try {
+    const projectSpecialists = await getAllProjectSpecialistStatuses();
+    for (const projSpec of projectSpecialists) {
+      if (!projSpec.isRunning) {
+        const runtimeState2 = getAgentRuntimeState(projSpec.tmuxSession);
+        if (runtimeState2?.state === "active") {
+          saveAgentRuntimeState(projSpec.tmuxSession, { state: "idle", lastActivity: (/* @__PURE__ */ new Date()).toISOString() });
+          const msg = `Dead-session reset: per-project ${projSpec.specialistType} (${projSpec.projectKey}) was active but session is gone`;
+          actions.push(msg);
+          addLog("action", msg, state.patrolCycle);
+          console.log(`[deacon] ${msg}`);
+        }
+        continue;
+      }
+      const runtimeState = getAgentRuntimeState(projSpec.tmuxSession);
+      const isStuck = runtimeState?.state === "active" && runtimeState.lastActivity ? Date.now() - new Date(runtimeState.lastActivity).getTime() > 15 * 60 * 1e3 : false;
+      if (isStuck) {
+        addLog("warn", `Per-project ${projSpec.specialistType} (${projSpec.projectKey}) stuck, force-killing`, state.patrolCycle);
+        console.log(`[deacon] Per-project ${projSpec.specialistType} (${projSpec.projectKey}) stuck, force-killing ${projSpec.tmuxSession}`);
+        try {
+          await execAsync16(`tmux kill-session -t "${projSpec.tmuxSession}"`);
+          clearSessionId(projSpec.specialistType, projSpec.projectKey);
+          saveAgentRuntimeState(projSpec.tmuxSession, { state: "idle", lastActivity: (/* @__PURE__ */ new Date()).toISOString() });
+          actions.push(`Force-killed stuck per-project ${projSpec.specialistType} (${projSpec.projectKey})`);
+        } catch {
+        }
+      }
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error("[deacon] Error during per-project specialist patrol:", msg);
+  }
   saveState(state);
   const result = {
     cycle: state.patrolCycle,
@@ -11885,7 +12083,7 @@ function getDeaconStatus() {
 // src/lib/cloister/service.ts
 init_paths();
 init_paths();
-import { existsSync as existsSync43, writeFileSync as writeFileSync20, unlinkSync as unlinkSync5, readFileSync as readFileSync36, readdirSync as readdirSync18, renameSync as renameSync3 } from "fs";
+import { existsSync as existsSync43, writeFileSync as writeFileSync20, unlinkSync as unlinkSync5, readFileSync as readFileSync37, readdirSync as readdirSync18, renameSync as renameSync3 } from "fs";
 import { join as join42 } from "path";
 var CLOISTER_STATE_FILE = join42(PANOPTICON_HOME, "cloister.state");
 function writeStateFile(running, pid) {
@@ -11908,7 +12106,7 @@ function writeStateFile(running, pid) {
 function readStateFile() {
   try {
     if (existsSync43(CLOISTER_STATE_FILE)) {
-      const data = JSON.parse(readFileSync36(CLOISTER_STATE_FILE, "utf-8"));
+      const data = JSON.parse(readFileSync37(CLOISTER_STATE_FILE, "utf-8"));
       if (data.pid) {
         try {
           process.kill(data.pid, 0);
@@ -11958,10 +12156,10 @@ var CloisterService = class {
     this.starting = true;
     console.log("\u{1F514} Starting Cloister agent watchdog...");
     try {
-      initHealthDatabase();
-      console.log("  \u2713 Health history database initialized");
+      getDatabase();
+      console.log("  \u2713 Panopticon database initialized");
     } catch (error) {
-      console.error("  \u2717 Failed to initialize health database:", error);
+      console.error("  \u2717 Failed to initialize panopticon database:", error);
     }
     try {
       console.log("  \u2192 Checking specialists...");
@@ -12014,9 +12212,9 @@ var CloisterService = class {
       console.error("Failed to stop deacon:", error);
     }
     try {
-      closeHealthDatabase();
+      closeDatabase();
     } catch (error) {
-      console.error("Failed to close health database:", error);
+      console.error("Failed to close panopticon database:", error);
     }
     this.emit({ type: "stopped" });
   }
@@ -12133,7 +12331,7 @@ var CloisterService = class {
         const processedFile = join42(AGENTS_DIR, dir.name, "completed.processed");
         if (!existsSync43(completedFile) || existsSync43(processedFile)) continue;
         try {
-          const content = JSON.parse(readFileSync36(completedFile, "utf-8"));
+          const content = JSON.parse(readFileSync37(completedFile, "utf-8"));
           const ageMs = Date.now() - new Date(content.timestamp).getTime();
           if (ageMs > 24 * 60 * 60 * 1e3) {
             console.log(`\u{1F514} Cloister: Skipping stale completion marker for ${dir.name} (${Math.floor(ageMs / 36e5)}h old)`);
@@ -12790,10 +12988,10 @@ init_esm_shims();
 // src/cli/commands/setup/hooks.ts
 init_esm_shims();
 import chalk39 from "chalk";
-import { readFileSync as readFileSync37, writeFileSync as writeFileSync21, existsSync as existsSync44, mkdirSync as mkdirSync22, copyFileSync as copyFileSync2, chmodSync } from "fs";
+import { readFileSync as readFileSync38, writeFileSync as writeFileSync21, existsSync as existsSync44, mkdirSync as mkdirSync21, copyFileSync as copyFileSync2, chmodSync } from "fs";
 import { join as join43 } from "path";
 import { execSync as execSync5 } from "child_process";
-import { homedir as homedir20 } from "os";
+import { homedir as homedir21 } from "os";
 function checkJqInstalled() {
   try {
     execSync5("which jq", { stdio: "pipe" });
@@ -12869,15 +13067,15 @@ async function setupHooksCommand() {
   } else {
     console.log(chalk39.green("\u2713 jq is installed"));
   }
-  const panopticonHome = join43(homedir20(), ".panopticon");
+  const panopticonHome = join43(homedir21(), ".panopticon");
   const binDir = join43(panopticonHome, "bin");
   const heartbeatsDir = join43(panopticonHome, "heartbeats");
   if (!existsSync44(binDir)) {
-    mkdirSync22(binDir, { recursive: true });
+    mkdirSync21(binDir, { recursive: true });
     console.log(chalk39.green("\u2713 Created ~/.panopticon/bin/"));
   }
   if (!existsSync44(heartbeatsDir)) {
-    mkdirSync22(heartbeatsDir, { recursive: true });
+    mkdirSync21(heartbeatsDir, { recursive: true });
     console.log(chalk39.green("\u2713 Created ~/.panopticon/heartbeats/"));
   }
   const hookScripts = ["pre-tool-hook", "heartbeat-hook", "stop-hook", "specialist-stop-hook", "record-cost-event.js"];
@@ -12904,12 +13102,12 @@ async function setupHooksCommand() {
     chmodSync(scriptDest, 493);
   }
   console.log(chalk39.green("\u2713 Installed hook scripts (pre-tool, post-tool, stop, specialist-stop)"));
-  const claudeDir = join43(homedir20(), ".claude");
+  const claudeDir = join43(homedir21(), ".claude");
   const settingsPath = join43(claudeDir, "settings.json");
   let settings = {};
   if (existsSync44(settingsPath)) {
     try {
-      const settingsContent = readFileSync37(settingsPath, "utf-8");
+      const settingsContent = readFileSync38(settingsPath, "utf-8");
       settings = JSON.parse(settingsContent);
       console.log(chalk39.green("\u2713 Read existing Claude Code settings"));
     } catch (error) {
@@ -12919,7 +13117,7 @@ async function setupHooksCommand() {
   } else {
     console.log(chalk39.dim("No existing settings.json found, creating new file"));
     if (!existsSync44(claudeDir)) {
-      mkdirSync22(claudeDir, { recursive: true });
+      mkdirSync21(claudeDir, { recursive: true });
     }
   }
   let python3Available = false;
@@ -12936,7 +13134,7 @@ async function setupHooksCommand() {
     let mcpConfig = {};
     try {
       if (existsSync44(mcpPath)) {
-        mcpConfig = JSON.parse(readFileSync37(mcpPath, "utf-8"));
+        mcpConfig = JSON.parse(readFileSync38(mcpPath, "utf-8"));
       }
     } catch {
       mcpConfig = {};
@@ -13127,18 +13325,18 @@ init_specialists();
 init_paths();
 init_tmux();
 import chalk41 from "chalk";
-import { exec as exec16 } from "child_process";
-import { promisify as promisify16 } from "util";
+import { exec as exec17 } from "child_process";
+import { promisify as promisify17 } from "util";
 import { setTimeout as sleep2 } from "timers/promises";
-import { existsSync as existsSync45, mkdirSync as mkdirSync23, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync45, mkdirSync as mkdirSync22, writeFileSync as writeFileSync22 } from "fs";
 import { join as join44 } from "path";
-var execAsync16 = promisify16(exec16);
+var execAsync17 = promisify17(exec17);
 var TASKS_DIR = join44(PANOPTICON_HOME, "specialists", "tasks");
 function sendTask(tmuxSession, specialistName, task) {
   const isLargeTask = task.length > 500 || task.includes("\n");
   if (isLargeTask) {
     if (!existsSync45(TASKS_DIR)) {
-      mkdirSync23(TASKS_DIR, { recursive: true });
+      mkdirSync22(TASKS_DIR, { recursive: true });
     }
     const taskFile = join44(TASKS_DIR, `${specialistName}-${Date.now()}.md`);
     writeFileSync22(taskFile, task, "utf-8");
@@ -13194,7 +13392,7 @@ Waking ${status.displayName}...
       console.log(chalk41.dim("Starting fresh session (no previous session found)"));
     }
     console.log(chalk41.dim(`Creating tmux session: ${tmuxSession}`));
-    await execAsync16(
+    await execAsync17(
       `tmux new-session -d -s "${tmuxSession}" -c "${cwd}" "${claudeCmd}"`,
       { encoding: "utf-8" }
     );
@@ -13318,10 +13516,10 @@ function getAge(date) {
 init_esm_shims();
 init_specialists();
 import chalk43 from "chalk";
-import { exec as exec17 } from "child_process";
-import { promisify as promisify17 } from "util";
+import { exec as exec18 } from "child_process";
+import { promisify as promisify18 } from "util";
 import * as readline from "readline";
-var execAsync17 = promisify17(exec17);
+var execAsync18 = promisify18(exec18);
 var ALL_SPECIALISTS = ["merge-agent", "review-agent", "test-agent"];
 async function resetCommand(name, options) {
   if (options.all) {
@@ -13371,7 +13569,7 @@ Resetting ${status.displayName}...
   if (status.isRunning) {
     console.log(chalk43.dim("Stopping tmux session..."));
     try {
-      await execAsync17(`tmux kill-session -t "${status.tmuxSession}"`, { encoding: "utf-8" });
+      await execAsync18(`tmux kill-session -t "${status.tmuxSession}"`, { encoding: "utf-8" });
       console.log(chalk43.green("\u2713 Tmux session stopped"));
     } catch (error) {
       console.log(chalk43.yellow("\u26A0 Failed to stop tmux session (may not be running)"));
@@ -13425,7 +13623,7 @@ async function resetAllSpecialists(options) {
     const tmuxSession = getTmuxSessionName(specialistName);
     if (status.isRunning) {
       try {
-        await execAsync17(`tmux kill-session -t "${tmuxSession}"`, { encoding: "utf-8" });
+        await execAsync18(`tmux kill-session -t "${tmuxSession}"`, { encoding: "utf-8" });
         console.log(chalk43.dim(`  Stopped ${specialistName} tmux session`));
       } catch {
       }
@@ -13448,7 +13646,7 @@ init_esm_shims();
 init_specialists();
 init_paths();
 import chalk44 from "chalk";
-import { existsSync as existsSync46, readFileSync as readFileSync38, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync39, writeFileSync as writeFileSync23 } from "fs";
 import { join as join45 } from "path";
 import * as readline2 from "readline";
 var ALL_SPECIALISTS2 = ["merge-agent", "review-agent", "test-agent"];
@@ -13505,7 +13703,7 @@ ${metadata.displayName} Queue:
   const hookFile = join45(PANOPTICON_HOME, "agents", specialistName, "hook.json");
   if (existsSync46(hookFile)) {
     try {
-      const hook = JSON.parse(readFileSync38(hookFile, "utf-8"));
+      const hook = JSON.parse(readFileSync39(hookFile, "utf-8"));
       hook.items = [];
       hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
       writeFileSync23(hookFile, JSON.stringify(hook, null, 2), "utf-8");
@@ -13518,7 +13716,7 @@ ${metadata.displayName} Queue:
   if (options.resetStatus && issueIds.length > 0) {
     if (existsSync46(REVIEW_STATUS_FILE2)) {
       try {
-        const statuses = JSON.parse(readFileSync38(REVIEW_STATUS_FILE2, "utf-8"));
+        const statuses = JSON.parse(readFileSync39(REVIEW_STATUS_FILE2, "utf-8"));
         let resetCount = 0;
         for (const issueId of issueIds) {
           const key = Object.keys(statuses).find((k) => k.toLowerCase() === issueId.toLowerCase());
@@ -13560,14 +13758,14 @@ function confirm2(question) {
 // src/cli/commands/specialists/done.ts
 init_esm_shims();
 import chalk45 from "chalk";
-import { existsSync as existsSync47, readFileSync as readFileSync39, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync47, readFileSync as readFileSync40, writeFileSync as writeFileSync24 } from "fs";
 import { join as join46 } from "path";
-import { homedir as homedir21 } from "os";
-var REVIEW_STATUS_FILE3 = join46(homedir21(), ".panopticon", "review-status.json");
+import { homedir as homedir22 } from "os";
+var REVIEW_STATUS_FILE3 = join46(homedir22(), ".panopticon", "review-status.json");
 function loadReviewStatuses2() {
   try {
     if (existsSync47(REVIEW_STATUS_FILE3)) {
-      return JSON.parse(readFileSync39(REVIEW_STATUS_FILE3, "utf-8"));
+      return JSON.parse(readFileSync40(REVIEW_STATUS_FILE3, "utf-8"));
     }
   } catch (error) {
     console.error(chalk45.yellow("Warning: Could not load review statuses"));
@@ -13677,12 +13875,12 @@ function formatStatus(status) {
 // src/cli/commands/specialists/logs.ts
 init_esm_shims();
 import { existsSync as existsSync48 } from "fs";
-import { exec as exec18 } from "child_process";
-import { promisify as promisify18 } from "util";
-var execAsync18 = promisify18(exec18);
+import { exec as exec19 } from "child_process";
+import { promisify as promisify19 } from "util";
+var execAsync19 = promisify19(exec19);
 async function listLogsCommand(project2, type, options) {
   try {
-    const { listRunLogs } = await import("../specialist-logs-XJB5TCKJ.js");
+    const { listRunLogs } = await import("../specialist-logs-CJKXM3SR.js");
     const limit = options.limit ? parseInt(options.limit) : 10;
     const runs = listRunLogs(project2, type, { limit });
     if (options.json) {
@@ -13727,7 +13925,7 @@ View a specific run: pan specialists logs ${project2} ${type} <runId>
 }
 async function viewLogCommand(project2, type, runId, options) {
   try {
-    const { getRunLog, parseLogMetadata, getRunLogPath } = await import("../specialist-logs-XJB5TCKJ.js");
+    const { getRunLog, parseLogMetadata, getRunLogPath } = await import("../specialist-logs-CJKXM3SR.js");
     const content = getRunLog(project2, type, runId);
     if (!content) {
       console.error(`\u274C Run log not found: ${runId}`);
@@ -13740,7 +13938,7 @@ async function viewLogCommand(project2, type, runId, options) {
     }
     const logPath = getRunLogPath(project2, type, runId);
     try {
-      await execAsync18(`less -R "${logPath}"`);
+      await execAsync19(`less -R "${logPath}"`);
     } catch {
       console.log(content);
     }
@@ -13751,8 +13949,8 @@ async function viewLogCommand(project2, type, runId, options) {
 }
 async function tailLogCommand(project2, type) {
   try {
-    const { getRunLogPath } = await import("../specialist-logs-XJB5TCKJ.js");
-    const { getProjectSpecialistMetadata } = await import("../specialists-5LBRHYFA.js");
+    const { getRunLogPath } = await import("../specialist-logs-CJKXM3SR.js");
+    const { getProjectSpecialistMetadata } = await import("../specialists-NXYD4Z62.js");
     const metadata = getProjectSpecialistMetadata(project2, type);
     if (!metadata.currentRun) {
       console.error(`\u274C No active run for ${project2}/${type}`);
@@ -13821,7 +14019,7 @@ async function cleanupLogsCommand(projectOrAll, type, options) {
         console.log("   Use --force to confirm.");
         process.exit(1);
       }
-      const { cleanupAllLogs } = await import("../specialist-logs-XJB5TCKJ.js");
+      const { cleanupAllLogs } = await import("../specialist-logs-CJKXM3SR.js");
       console.log("\u{1F9F9} Cleaning up old logs for all projects...\n");
       const results = cleanupAllLogs();
       console.log(`
@@ -13848,8 +14046,8 @@ async function cleanupLogsCommand(projectOrAll, type, options) {
       console.log("   Use --force to confirm.");
       process.exit(1);
     }
-    const { cleanupOldLogs } = await import("../specialist-logs-XJB5TCKJ.js");
-    const { getSpecialistRetention } = await import("../projects-CFX3RTDL.js");
+    const { cleanupOldLogs } = await import("../specialist-logs-CJKXM3SR.js");
+    const { getSpecialistRetention } = await import("../projects-KVM3MN3Y.js");
     const retention = getSpecialistRetention(projectOrAll);
     console.log(`\u{1F9F9} Cleaning up old logs for ${projectOrAll}/${type}...`);
     console.log(`   Retention: ${retention.max_days} days or ${retention.max_runs} runs
@@ -13887,11 +14085,11 @@ import ora19 from "ora";
 // src/lib/convoy.ts
 init_esm_shims();
 init_tmux();
-import { existsSync as existsSync49, mkdirSync as mkdirSync24, writeFileSync as writeFileSync25, readFileSync as readFileSync41, readdirSync as readdirSync19 } from "fs";
+import { existsSync as existsSync49, mkdirSync as mkdirSync23, writeFileSync as writeFileSync25, readFileSync as readFileSync42, readdirSync as readdirSync19 } from "fs";
 import { join as join47 } from "path";
-import { homedir as homedir22 } from "os";
-import { exec as exec19 } from "child_process";
-import { promisify as promisify19 } from "util";
+import { homedir as homedir23 } from "os";
+import { exec as exec20 } from "child_process";
+import { promisify as promisify20 } from "util";
 import { parse as parseYaml } from "yaml";
 
 // src/lib/convoy-templates.ts
@@ -13996,8 +14194,8 @@ function getExecutionOrder(template) {
 // src/lib/convoy.ts
 init_paths();
 init_work_type_router();
-var execAsync19 = promisify19(exec19);
-var CONVOY_DIR = join47(homedir22(), ".panopticon", "convoys");
+var execAsync20 = promisify20(exec20);
+var CONVOY_DIR = join47(homedir23(), ".panopticon", "convoys");
 function getConvoyStateFile(convoyId) {
   return join47(CONVOY_DIR, `${convoyId}.json`);
 }
@@ -14006,7 +14204,7 @@ function getConvoyOutputDir(convoyId, template) {
   return join47(process.cwd(), baseDir, convoyId);
 }
 function saveConvoyState(state) {
-  mkdirSync24(CONVOY_DIR, { recursive: true });
+  mkdirSync23(CONVOY_DIR, { recursive: true });
   writeFileSync25(getConvoyStateFile(state.id), JSON.stringify(state, null, 2));
 }
 function loadConvoyState(convoyId) {
@@ -14015,7 +14213,7 @@ function loadConvoyState(convoyId) {
     return void 0;
   }
   try {
-    const content = readFileSync41(stateFile, "utf-8");
+    const content = readFileSync42(stateFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -14047,7 +14245,7 @@ function parseAgentTemplate(templatePath) {
   if (!existsSync49(templatePath)) {
     throw new Error(`Agent template not found: ${templatePath}`);
   }
-  const content = readFileSync41(templatePath, "utf-8");
+  const content = readFileSync42(templatePath, "utf-8");
   const frontmatterMatch = content.match(/^---\n([\s\S]+?)\n---\n([\s\S]*)$/);
   if (!frontmatterMatch) {
     throw new Error(`Invalid agent template format (missing frontmatter): ${templatePath}`);
@@ -14111,7 +14309,7 @@ ${context.issueId ? `**Issue ID**: ${context.issueId}` : ""}
 
 `;
   prompt = contextInstructions + prompt;
-  mkdirSync24(convoy.outputDir, { recursive: true });
+  mkdirSync23(convoy.outputDir, { recursive: true });
   const promptFile = join47(convoy.outputDir, `${role}-prompt.md`);
   writeFileSync25(promptFile, prompt);
   const claudeCmd = `claude --dangerously-skip-permissions --model ${model}`;
@@ -14123,10 +14321,10 @@ ${context.issueId ? `**Issue ID**: ${context.issueId}` : ""}
     }
   });
   await new Promise((resolve2) => setTimeout(resolve2, 1500));
-  await execAsync19(`tmux load-buffer "${promptFile}"`);
-  await execAsync19(`tmux paste-buffer -t ${agentState.tmuxSession}`);
+  await execAsync20(`tmux load-buffer "${promptFile}"`);
+  await execAsync20(`tmux paste-buffer -t ${agentState.tmuxSession}`);
   await new Promise((resolve2) => setTimeout(resolve2, 500));
-  await execAsync19(`tmux send-keys -t ${agentState.tmuxSession} Enter`);
+  await execAsync20(`tmux send-keys -t ${agentState.tmuxSession} Enter`);
   agentState.status = "running";
   agentState.startedAt = (/* @__PURE__ */ new Date()).toISOString();
   saveConvoyState(convoy);
@@ -14139,7 +14337,7 @@ async function startConvoy(templateName, context) {
   const timestamp = Date.now();
   const convoyId = `convoy-${templateName}-${timestamp}`;
   const outputDir = getConvoyOutputDir(convoyId, template);
-  mkdirSync24(outputDir, { recursive: true });
+  mkdirSync23(outputDir, { recursive: true });
   const state = {
     id: convoyId,
     template: templateName,
@@ -14187,7 +14385,7 @@ async function executePhase(convoy, template, phaseAgents, context) {
     for (const depRole of deps) {
       const depAgent = convoy.agents.find((a) => a.role === depRole);
       if (depAgent?.outputFile && existsSync49(depAgent.outputFile)) {
-        agentContext[`${depRole}_output`] = readFileSync41(depAgent.outputFile, "utf-8");
+        agentContext[`${depRole}_output`] = readFileSync42(depAgent.outputFile, "utf-8");
       }
     }
     spawnPromises.push(spawnConvoyAgent(convoy, agent, agentState, agentContext));
@@ -14496,7 +14694,7 @@ function registerConvoyCommands(program2) {
 init_esm_shims();
 init_projects();
 import chalk50 from "chalk";
-import { existsSync as existsSync50, readFileSync as readFileSync42, symlinkSync as symlinkSync2, mkdirSync as mkdirSync25, readdirSync as readdirSync20, statSync as statSync10 } from "fs";
+import { existsSync as existsSync50, readFileSync as readFileSync43, symlinkSync as symlinkSync2, mkdirSync as mkdirSync24, readdirSync as readdirSync20, statSync as statSync10 } from "fs";
 import { join as join48, resolve, dirname as dirname14 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __filename5 = fileURLToPath4(import.meta.url);
@@ -14506,7 +14704,7 @@ function installGitHooks(gitDir) {
   const hooksTarget = join48(gitDir, "hooks");
   let installed = 0;
   if (!existsSync50(hooksTarget)) {
-    mkdirSync25(hooksTarget, { recursive: true });
+    mkdirSync24(hooksTarget, { recursive: true });
   }
   if (!existsSync50(BUNDLED_HOOKS_DIR)) {
     return 0;
@@ -14558,7 +14756,7 @@ async function projectAddCommand(projectPath, options = {}) {
   if (!linearTeam) {
     const projectToml = join48(fullPath, ".panopticon", "project.toml");
     if (existsSync50(projectToml)) {
-      const content = readFileSync42(projectToml, "utf-8");
+      const content = readFileSync43(projectToml, "utf-8");
       const match = content.match(/team\s*=\s*"([^"]+)"/);
       if (match) linearTeam = match[1];
     }
@@ -14607,7 +14805,7 @@ async function projectAddCommand(projectPath, options = {}) {
   }
   const isPolyrepo = !hasRootGit && subRepos.length > 0;
   try {
-    const { preTrustDirectory } = await import("../workspace-manager-E434Z45T.js");
+    const { preTrustDirectory } = await import("../workspace-manager-ALBR62AS.js");
     preTrustDirectory(fullPath);
   } catch {
   }
@@ -14791,9 +14989,9 @@ Project: ${foundKey}
 init_esm_shims();
 init_paths();
 import chalk51 from "chalk";
-import { existsSync as existsSync51, readdirSync as readdirSync21, readFileSync as readFileSync43 } from "fs";
+import { existsSync as existsSync51, readdirSync as readdirSync21, readFileSync as readFileSync44 } from "fs";
 import { execSync as execSync6 } from "child_process";
-import { homedir as homedir23 } from "os";
+import { homedir as homedir24 } from "os";
 import { join as join49 } from "path";
 function checkCommand3(cmd) {
   try {
@@ -14880,7 +15078,7 @@ async function doctorCommand() {
       fix: "Install Claude Code first"
     });
   }
-  const envFile = join49(homedir23(), ".panopticon.env");
+  const envFile = join49(homedir24(), ".panopticon.env");
   if (existsSync51(envFile)) {
     checks.push({ name: "Config File", status: "ok", message: "~/.panopticon.env exists" });
   } else {
@@ -14894,7 +15092,7 @@ async function doctorCommand() {
   if (process.env.LINEAR_API_KEY) {
     checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in environment" });
   } else if (existsSync51(envFile)) {
-    const content = readFileSync43(envFile, "utf-8");
+    const content = readFileSync44(envFile, "utf-8");
     if (content.includes("LINEAR_API_KEY")) {
       checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in config file" });
     } else {
@@ -14962,7 +15160,7 @@ init_esm_shims();
 init_config();
 import { execSync as execSync7 } from "child_process";
 import chalk52 from "chalk";
-import { readFileSync as readFileSync44 } from "fs";
+import { readFileSync as readFileSync45 } from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { dirname as dirname15, join as join50 } from "path";
 function getCurrentVersion() {
@@ -14970,7 +15168,7 @@ function getCurrentVersion() {
     const __filename6 = fileURLToPath5(import.meta.url);
     const __dirname6 = dirname15(__filename6);
     const pkgPath = join50(__dirname6, "..", "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync44(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync45(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "unknown";
@@ -15056,11 +15254,11 @@ init_esm_shims();
 init_projects();
 import chalk53 from "chalk";
 import ora21 from "ora";
-import { existsSync as existsSync52, readFileSync as readFileSync45, writeFileSync as writeFileSync26, mkdirSync as mkdirSync26, statSync as statSync11 } from "fs";
+import { existsSync as existsSync52, readFileSync as readFileSync46, writeFileSync as writeFileSync26, mkdirSync as mkdirSync25, statSync as statSync11 } from "fs";
 import { join as join51, dirname as dirname16 } from "path";
-import { exec as exec20 } from "child_process";
-import { promisify as promisify20 } from "util";
-var execAsync20 = promisify20(exec20);
+import { exec as exec21 } from "child_process";
+import { promisify as promisify21 } from "util";
+var execAsync21 = promisify21(exec21);
 function loadFullProjects() {
   const config2 = loadProjectsConfig();
   const projects = config2.projects;
@@ -15076,12 +15274,12 @@ function findFullProjectByTeam(teamPrefix) {
   ) || null;
 }
 function registerDbCommands(program2) {
-  const db2 = program2.command("db").description("Database seeding and management");
-  db2.command("snapshot").description("Create a database snapshot from an external source").option("--project <key>", "Project key (e.g., myn)").option("--output <path>", "Output file path").option("--sanitize", "Run sanitization script after snapshot").action(snapshotCommand);
-  db2.command("seed <workspaceOrIssue>").description("Seed a workspace database with the configured seed file").option("--force", "Force reseed even if already initialized").option("--file <path>", "Override seed file path").action(seedCommand);
-  db2.command("status").description("Check database status for a workspace").argument("[workspaceOrIssue]", "Workspace folder or issue ID").action(statusCommand5);
-  db2.command("clean <file>").description("Clean kubectl/stderr garbage from a pg_dump file").option("--output <path>", "Output file (default: overwrite input)").option("--dry-run", "Show what would be cleaned without modifying").action(cleanCommand);
-  db2.command("config").description("Show database configuration for a project").argument("[project]", "Project key").action(configCommand);
+  const db = program2.command("db").description("Database seeding and management");
+  db.command("snapshot").description("Create a database snapshot from an external source").option("--project <key>", "Project key (e.g., myn)").option("--output <path>", "Output file path").option("--sanitize", "Run sanitization script after snapshot").action(snapshotCommand);
+  db.command("seed <workspaceOrIssue>").description("Seed a workspace database with the configured seed file").option("--force", "Force reseed even if already initialized").option("--file <path>", "Override seed file path").action(seedCommand);
+  db.command("status").description("Check database status for a workspace").argument("[workspaceOrIssue]", "Workspace folder or issue ID").action(statusCommand5);
+  db.command("clean <file>").description("Clean kubectl/stderr garbage from a pg_dump file").option("--output <path>", "Output file (default: overwrite input)").option("--dry-run", "Show what would be cleaned without modifying").action(cleanCommand);
+  db.command("config").description("Show database configuration for a project").argument("[project]", "Project key").action(configCommand);
 }
 async function snapshotCommand(options) {
   const spinner = ora21("Creating database snapshot...").start();
@@ -15122,7 +15320,7 @@ async function snapshotCommand(options) {
     const outputPath = options.output || dbConfig.seed_file || join51(projectConfig.path, "infra", "seed", "seed.sql");
     const outputDir = dirname16(outputPath);
     if (!existsSync52(outputDir)) {
-      mkdirSync26(outputDir, { recursive: true });
+      mkdirSync25(outputDir, { recursive: true });
     }
     spinner.text = "Running snapshot command...";
     let snapshotCmd;
@@ -15142,10 +15340,10 @@ async function snapshotCommand(options) {
     }
     const fullCmd = `${snapshotCmd} > "${outputPath}" 2>&1`;
     try {
-      await execAsync20(fullCmd, { timeout: 3e5 });
+      await execAsync21(fullCmd, { timeout: 3e5 });
     } catch (error) {
       if (existsSync52(outputPath)) {
-        const content2 = readFileSync45(outputPath, "utf-8");
+        const content2 = readFileSync46(outputPath, "utf-8");
         if (content2.includes("PostgreSQL database dump")) {
           spinner.warn("Snapshot completed with warnings (stderr captured)");
           console.log(chalk53.dim("  Run `pan db clean` to remove stderr noise from the file"));
@@ -15158,7 +15356,7 @@ async function snapshotCommand(options) {
         return;
       }
     }
-    const content = readFileSync45(outputPath, "utf-8");
+    const content = readFileSync46(outputPath, "utf-8");
     if (content.includes("Defaulted container") || content.includes("Unable to use a TTY")) {
       spinner.text = "Cleaning kubectl output from snapshot...";
       await cleanFile(outputPath);
@@ -15166,7 +15364,7 @@ async function snapshotCommand(options) {
     if (options.sanitize && dbConfig.seed_command) {
       spinner.text = "Running sanitization...";
       try {
-        await execAsync20(dbConfig.seed_command, { cwd: projectConfig.path });
+        await execAsync21(dbConfig.seed_command, { cwd: projectConfig.path });
       } catch (error) {
         spinner.warn(`Sanitization warning: ${error.message}`);
       }
@@ -15206,7 +15404,7 @@ async function seedCommand(workspaceOrIssue, options) {
     const containerName = dbConfig?.container_name?.replace("{{PROJECT}}", projectName) || `${projectName}-postgres-1`;
     spinner.text = `Finding database container ${containerName}...`;
     try {
-      const { stdout } = await execAsync20(`docker ps --filter "name=${containerName}" --format "{{.Names}}"`);
+      const { stdout } = await execAsync21(`docker ps --filter "name=${containerName}" --format "{{.Names}}"`);
       if (!stdout.trim()) {
         spinner.fail(`Database container not running: ${containerName}`);
         console.log(chalk53.dim("\nStart the workspace containers first:"));
@@ -15219,7 +15417,7 @@ async function seedCommand(workspaceOrIssue, options) {
     }
     if (!options.force) {
       try {
-        const { stdout } = await execAsync20(
+        const { stdout } = await execAsync21(
           `docker exec ${containerName} psql -U postgres -d myn -c "SELECT count(*) FROM flyway_schema_history" -t 2>/dev/null`
         );
         const count = parseInt(stdout.trim(), 10);
@@ -15233,7 +15431,7 @@ async function seedCommand(workspaceOrIssue, options) {
     if (options.force) {
       spinner.text = "Dropping existing database...";
       try {
-        await execAsync20(
+        await execAsync21(
           `docker exec ${containerName} psql -U postgres -c "DROP DATABASE IF EXISTS myn; CREATE DATABASE myn;"`
         );
       } catch (error) {
@@ -15241,10 +15439,10 @@ async function seedCommand(workspaceOrIssue, options) {
       }
     }
     spinner.text = "Copying seed file to container...";
-    await execAsync20(`docker cp "${seedFile}" ${containerName}:/tmp/seed.sql`);
+    await execAsync21(`docker cp "${seedFile}" ${containerName}:/tmp/seed.sql`);
     spinner.text = "Executing seed...";
     try {
-      await execAsync20(`docker exec ${containerName} psql -U postgres -d myn -f /tmp/seed.sql`, {
+      await execAsync21(`docker exec ${containerName} psql -U postgres -d myn -f /tmp/seed.sql`, {
         timeout: 6e5
         // 10 minute timeout for large seeds
       });
@@ -15254,10 +15452,10 @@ async function seedCommand(workspaceOrIssue, options) {
         return;
       }
     }
-    await execAsync20(`docker exec ${containerName} rm /tmp/seed.sql`);
+    await execAsync21(`docker exec ${containerName} rm /tmp/seed.sql`);
     spinner.succeed("Database seeded successfully");
     try {
-      const { stdout } = await execAsync20(
+      const { stdout } = await execAsync21(
         `docker exec ${containerName} psql -U postgres -d myn -c "SELECT version, description FROM flyway_schema_history ORDER BY installed_rank DESC LIMIT 3" -t`
       );
       console.log(chalk53.dim("\nRecent migrations:"));
@@ -15287,7 +15485,7 @@ async function statusCommand5(workspaceOrIssue) {
       const projects = loadFullProjects();
       projectConfig = projects.find((p) => cwd.startsWith(p.path));
       if (projectConfig) {
-        const { stdout } = await execAsync20(
+        const { stdout } = await execAsync21(
           `docker ps --filter "name=${projectConfig.name?.toLowerCase().replace(/\s+/g, "-")}" --filter "name=postgres" --format "{{.Names}}" | head -1`
         );
         containerName = stdout.trim();
@@ -15300,7 +15498,7 @@ async function statusCommand5(workspaceOrIssue) {
       return;
     }
     spinner.text = `Checking container ${containerName}...`;
-    const { stdout: containerStatus } = await execAsync20(
+    const { stdout: containerStatus } = await execAsync21(
       `docker ps --filter "name=${containerName}" --format "{{.Status}}"`
     );
     if (!containerStatus.trim()) {
@@ -15310,7 +15508,7 @@ async function statusCommand5(workspaceOrIssue) {
     spinner.succeed(`Container: ${containerName}`);
     console.log(chalk53.dim(`  Status: ${containerStatus.trim()}`));
     try {
-      const { stdout: version } = await execAsync20(
+      const { stdout: version } = await execAsync21(
         `docker exec ${containerName} psql -U postgres -d myn -c "SELECT version, description FROM flyway_schema_history ORDER BY installed_rank DESC LIMIT 1" -t`
       );
       const [ver, desc] = version.trim().split("|").map((s) => s.trim());
@@ -15319,14 +15517,14 @@ async function statusCommand5(workspaceOrIssue) {
       console.log(chalk53.yellow("  Flyway: Not initialized"));
     }
     try {
-      const { stdout: tableCount } = await execAsync20(
+      const { stdout: tableCount } = await execAsync21(
         `docker exec ${containerName} psql -U postgres -d myn -c "SELECT count(*) FROM information_schema.tables WHERE table_schema = 'public'" -t`
       );
       console.log(chalk53.dim(`  Tables: ${tableCount.trim()}`));
     } catch {
     }
     try {
-      const { stdout: dbSize } = await execAsync20(
+      const { stdout: dbSize } = await execAsync21(
         `docker exec ${containerName} psql -U postgres -d myn -c "SELECT pg_size_pretty(pg_database_size('myn'))" -t`
       );
       console.log(chalk53.dim(`  Size: ${dbSize.trim()}`));
@@ -15343,7 +15541,7 @@ async function cleanCommand(file, options) {
       spinner.fail(`File not found: ${file}`);
       return;
     }
-    const content = readFileSync45(file, "utf-8");
+    const content = readFileSync46(file, "utf-8");
     const lines = content.split("\n");
     const patternsToRemove = [
       /^Defaulted container/,
@@ -15413,7 +15611,7 @@ async function cleanCommand(file, options) {
   }
 }
 async function cleanFile(filePath) {
-  const content = readFileSync45(filePath, "utf-8");
+  const content = readFileSync46(filePath, "utf-8");
   const lines = content.split("\n");
   let startIndex = 0;
   for (let i = 0; i < lines.length; i++) {
@@ -15496,17 +15694,17 @@ async function configCommand(project2) {
 init_esm_shims();
 import chalk54 from "chalk";
 import ora22 from "ora";
-import { existsSync as existsSync53, readFileSync as readFileSync46 } from "fs";
+import { existsSync as existsSync53, readFileSync as readFileSync47 } from "fs";
 import { join as join52 } from "path";
-import { exec as exec21, execSync as execSync8 } from "child_process";
-import { promisify as promisify21 } from "util";
+import { exec as exec22, execSync as execSync8 } from "child_process";
+import { promisify as promisify22 } from "util";
 import { platform } from "os";
-var execAsync21 = promisify21(exec21);
+var execAsync22 = promisify22(exec22);
 function detectPlatform2() {
   const os = platform();
   if (os === "linux") {
     try {
-      const release = readFileSync46("/proc/version", "utf8").toLowerCase();
+      const release = readFileSync47("/proc/version", "utf8").toLowerCase();
       if (release.includes("microsoft") || release.includes("wsl")) {
         return "wsl";
       }
@@ -15518,7 +15716,7 @@ function detectPlatform2() {
 }
 async function isBdAvailable() {
   try {
-    await execAsync21("which bd", { encoding: "utf-8" });
+    await execAsync22("which bd", { encoding: "utf-8" });
     return true;
   } catch {
     return false;
@@ -15527,7 +15725,7 @@ async function isBdAvailable() {
 async function getOldClosedCount(cwd, days) {
   try {
     const seconds = days * 24 * 60 * 60;
-    const { stdout } = await execAsync21(
+    const { stdout } = await execAsync22(
       `bd list --status closed --json 2>/dev/null | jq '[.[] | select(.closed_at != null) | select((now - (.closed_at | fromdateiso8601)) > ${seconds})] | length' 2>/dev/null || echo "0"`,
       { cwd, encoding: "utf-8" }
     );
@@ -15563,7 +15761,7 @@ async function compactCommand(options) {
       console.log("");
       console.log(chalk54.bold("Beads that would be compacted:"));
       try {
-        const { stdout: beadsList } = await execAsync21(
+        const { stdout: beadsList } = await execAsync22(
           `bd list --status closed --json 2>/dev/null | jq -r '.[] | select(.closed_at != null) | select((now - (.closed_at | fromdateiso8601)) > ${days * 24 * 60 * 60}) | "  - \\(.id): \\(.title)"' 2>/dev/null`,
           { cwd, encoding: "utf-8" }
         );
@@ -15574,10 +15772,10 @@ async function compactCommand(options) {
       return;
     }
     spinner.text = "Running compaction...";
-    await execAsync21(`bd admin compact --days ${days}`, { cwd, encoding: "utf-8" });
+    await execAsync22(`bd admin compact --days ${days}`, { cwd, encoding: "utf-8" });
     spinner.succeed(`Compacted ${count} beads older than ${days} days`);
     try {
-      await execAsync21(`git diff --quiet .beads/`, { cwd, encoding: "utf-8" });
+      await execAsync22(`git diff --quiet .beads/`, { cwd, encoding: "utf-8" });
       console.log(chalk54.dim("No changes to commit (beads already up to date)"));
     } catch {
       console.log("");
@@ -15611,17 +15809,17 @@ async function statsCommand() {
   }
   const spinner = ora22("Gathering beads statistics...").start();
   try {
-    const { stdout: totalRaw } = await execAsync21(`bd list --limit 0 --json 2>/dev/null | jq 'length'`, {
+    const { stdout: totalRaw } = await execAsync22(`bd list --limit 0 --json 2>/dev/null | jq 'length'`, {
       cwd,
       encoding: "utf-8"
     });
     const total = parseInt(totalRaw.trim(), 10) || 0;
-    const { stdout: openRaw } = await execAsync21(`bd list --status open --limit 0 --json 2>/dev/null | jq 'length'`, {
+    const { stdout: openRaw } = await execAsync22(`bd list --status open --limit 0 --json 2>/dev/null | jq 'length'`, {
       cwd,
       encoding: "utf-8"
     });
     const open = parseInt(openRaw.trim(), 10) || 0;
-    const { stdout: closedRaw } = await execAsync21(`bd list --status closed --limit 0 --json 2>/dev/null | jq 'length'`, {
+    const { stdout: closedRaw } = await execAsync22(`bd list --status closed --limit 0 --json 2>/dev/null | jq 'length'`, {
       cwd,
       encoding: "utf-8"
     });
@@ -15666,7 +15864,7 @@ async function upgradeCommand(checkOnly = false) {
   console.log(chalk54.dim("Checking beads version..."));
   let currentVersion = "not installed";
   try {
-    const { stdout } = await execAsync21("bd --version", { encoding: "utf-8" });
+    const { stdout } = await execAsync22("bd --version", { encoding: "utf-8" });
     const match = stdout.match(/(\d+\.\d+\.\d+)/);
     if (match) {
       currentVersion = match[1];
@@ -15675,7 +15873,7 @@ async function upgradeCommand(checkOnly = false) {
   }
   let latestVersion = "unknown";
   try {
-    const { stdout } = await execAsync21(
+    const { stdout } = await execAsync22(
       "curl -sL https://api.github.com/repos/steveyegge/beads/releases/latest | jq -r .tag_name",
       { encoding: "utf-8" }
     );
@@ -15724,7 +15922,7 @@ async function upgradeCommand(checkOnly = false) {
       spinner.succeed("beads upgraded via install script");
     }
     try {
-      const { stdout } = await execAsync21("bd --version", { encoding: "utf-8" });
+      const { stdout } = await execAsync22("bd --version", { encoding: "utf-8" });
       const match = stdout.match(/(\d+\.\d+\.\d+)/);
       if (match) {
         console.log(chalk54.green(`
@@ -16231,12 +16429,12 @@ init_esm_shims();
 init_config();
 import chalk59 from "chalk";
 import ora27 from "ora";
-import { exec as exec22 } from "child_process";
-import { promisify as promisify22 } from "util";
-import { existsSync as existsSync54, readFileSync as readFileSync47 } from "fs";
+import { exec as exec23 } from "child_process";
+import { promisify as promisify23 } from "util";
+import { existsSync as existsSync54, readFileSync as readFileSync48 } from "fs";
 import { join as join53 } from "path";
-import { homedir as homedir24 } from "os";
-var execAsync22 = promisify22(exec22);
+import { homedir as homedir25 } from "os";
+var execAsync23 = promisify23(exec23);
 async function setupCommand() {
   console.log("");
   console.log(chalk59.bold("\u{1F680} Remote Workspace Setup"));
@@ -16247,7 +16445,7 @@ async function setupCommand() {
   console.log("");
   console.log(chalk59.bold("  Step 2: SSH Key Configuration"));
   console.log("");
-  const sshDir = join53(homedir24(), ".ssh");
+  const sshDir = join53(homedir25(), ".ssh");
   const defaultKeyPath = join53(sshDir, "id_ed25519");
   const rsaKeyPath = join53(sshDir, "id_rsa");
   let sshKeyExists = false;
@@ -16271,7 +16469,7 @@ async function setupCommand() {
   if (sshKeyExists) {
     const pubKeyPath = `${keyPath}.pub`;
     if (existsSync54(pubKeyPath)) {
-      const pubKey = readFileSync47(pubKeyPath, "utf8").trim();
+      const pubKey = readFileSync48(pubKeyPath, "utf8").trim();
       console.log("");
       console.log("  Your public key (add this to exe.dev if not already):");
       console.log("");
@@ -16299,7 +16497,7 @@ async function setupCommand() {
     if (sshKeyExists) {
       const pubKeyPath = `${keyPath}.pub`;
       if (existsSync54(pubKeyPath)) {
-        const pubKey = readFileSync47(pubKeyPath, "utf8").trim();
+        const pubKey = readFileSync48(pubKeyPath, "utf8").trim();
         console.log(chalk59.dim(`    ${pubKey}`));
       }
     } else {
@@ -16385,8 +16583,8 @@ import chalk60 from "chalk";
 // src/lib/env-loader.ts
 init_esm_shims();
 import { join as join54 } from "path";
-import { homedir as homedir25 } from "os";
-var ENV_FILE_PATH = join54(homedir25(), ".panopticon.env");
+import { homedir as homedir26 } from "os";
+var ENV_FILE_PATH = join54(homedir26(), ".panopticon.env");
 function getShadowModeFromEnv() {
   const value = process.env.SHADOW_MODE;
   if (!value) return false;
@@ -16480,11 +16678,422 @@ Shadowed issues: ${shadowedIssues.length}`));
   }
 }
 
+// src/cli/commands/cost.ts
+init_esm_shims();
+init_cost();
+import { Command } from "commander";
+import chalk61 from "chalk";
+
+// src/lib/costs/sync-wal.ts
+init_esm_shims();
+init_projects();
+import { existsSync as existsSync55 } from "fs";
+import { readdir, readFile } from "fs/promises";
+import { join as join55 } from "path";
+
+// src/lib/database/cost-events-db.ts
+init_esm_shims();
+init_database();
+function insertCostEvents(events, sourceFile) {
+  const db = getDatabase();
+  let inserted = 0;
+  let duplicates = 0;
+  const insert = db.prepare(`
+    INSERT OR IGNORE INTO cost_events (
+      ts, agent_id, issue_id, session_type, provider, model,
+      input, output, cache_read, cache_write, cost, request_id,
+      tldr_interceptions, tldr_bypasses, tldr_tokens_saved, tldr_bypass_reasons,
+      source_file
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertMany = db.transaction((evs) => {
+    for (const ev of evs) {
+      const result = insert.run(
+        ev.ts,
+        ev.agentId,
+        ev.issueId,
+        ev.sessionType || "unknown",
+        ev.provider || "anthropic",
+        ev.model,
+        ev.input,
+        ev.output,
+        ev.cacheRead,
+        ev.cacheWrite,
+        ev.cost,
+        ev.requestId ?? null,
+        ev.tldrInterceptions ?? null,
+        ev.tldrBypasses ?? null,
+        ev.tldrTokensSaved ?? null,
+        ev.tldrBypassReasons ? JSON.stringify(ev.tldrBypassReasons) : null,
+        sourceFile ?? null
+      );
+      if (result.changes > 0) {
+        inserted++;
+      } else {
+        duplicates++;
+      }
+    }
+  });
+  insertMany(events);
+  return { inserted, duplicates };
+}
+
+// src/lib/costs/sync-wal.ts
+var DEFAULT_EVENTS_SUBDIR = ".panopticon/events";
+async function syncWalFromAllProjects() {
+  const result = {
+    imported: 0,
+    duplicates: 0,
+    filesScanned: 0,
+    byProject: {},
+    errors: []
+  };
+  const projects = listProjects();
+  for (const { key, config: config2 } of projects) {
+    const repoPath = config2.events_repo ?? config2.path;
+    const eventsSubdir = config2.events_path ?? DEFAULT_EVENTS_SUBDIR;
+    const eventsDir = join55(repoPath, eventsSubdir);
+    if (!existsSync55(eventsDir)) continue;
+    const projectStats = { imported: 0, duplicates: 0, files: 0 };
+    let files;
+    try {
+      files = (await readdir(eventsDir)).filter((f) => f.endsWith(".jsonl"));
+    } catch (err) {
+      result.errors.push(`${key}: failed to read events dir: ${err}`);
+      continue;
+    }
+    for (const file of files) {
+      const filePath = join55(eventsDir, file);
+      const events = await parseWalFile(filePath, result.errors);
+      if (events.length === 0) continue;
+      try {
+        const { inserted, duplicates } = insertCostEvents(events, filePath);
+        projectStats.imported += inserted;
+        projectStats.duplicates += duplicates;
+        projectStats.files++;
+        result.filesScanned++;
+      } catch (err) {
+        result.errors.push(`${key}/${file}: import failed: ${err}`);
+      }
+    }
+    if (projectStats.files > 0 || projectStats.imported > 0) {
+      result.byProject[key] = projectStats;
+      result.imported += projectStats.imported;
+      result.duplicates += projectStats.duplicates;
+    }
+  }
+  return result;
+}
+async function parseWalFile(filePath, errors) {
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch (err) {
+    errors.push(`Failed to read ${filePath}: ${err}`);
+    return [];
+  }
+  const events = [];
+  const lines = content.split("\n").filter((l) => l.trim());
+  for (const line of lines) {
+    try {
+      const event = JSON.parse(line);
+      if (event.ts && event.agentId && event.issueId && event.model) {
+        events.push(event);
+      }
+    } catch {
+    }
+  }
+  return events;
+}
+
+// src/cli/commands/cost.ts
+async function runCostSync() {
+  try {
+    console.log(chalk61.bold("Syncing cost events from project WAL files..."));
+    const result = await syncWalFromAllProjects();
+    if (result.filesScanned === 0) {
+      console.log(chalk61.yellow("No WAL files found. Make sure projects are registered and have cost events."));
+      return;
+    }
+    console.log();
+    console.log(`Files scanned: ${result.filesScanned}`);
+    console.log(`Imported:     ${chalk61.green(result.imported)} new events`);
+    console.log(`Duplicates:   ${chalk61.dim(result.duplicates)} skipped`);
+    if (Object.keys(result.byProject).length > 0) {
+      console.log();
+      console.log(chalk61.bold("By Project:"));
+      for (const [project2, stats] of Object.entries(result.byProject)) {
+        console.log(`  ${project2}: ${chalk61.green(stats.imported)} imported, ${stats.files} file(s)`);
+      }
+    }
+    if (result.errors.length > 0) {
+      console.log();
+      console.log(chalk61.yellow(`Warnings (${result.errors.length}):`));
+      for (const err of result.errors) {
+        console.log(`  ${chalk61.dim(err)}`);
+      }
+    }
+  } catch (error) {
+    console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createCostCommand() {
+  const cost = new Command("cost").description("Track and report AI usage costs");
+  cost.command("today").description("Show today's cost summary").option("-d, --detail", "Show individual entries").action((options) => {
+    try {
+      const summary = getDailySummary();
+      console.log(chalk61.bold("Today's Cost Summary"));
+      console.log();
+      console.log(`Total Cost: ${chalk61.green(formatCost(summary.totalCost))}`);
+      console.log(`API Calls: ${summary.entryCount}`);
+      console.log(`Tokens: ${summary.totalTokens.total.toLocaleString()}`);
+      console.log(`  Input: ${summary.totalTokens.input.toLocaleString()}`);
+      console.log(`  Output: ${summary.totalTokens.output.toLocaleString()}`);
+      console.log();
+      if (Object.keys(summary.byProvider).length > 0) {
+        console.log(chalk61.bold("By Provider"));
+        for (const [provider, cost2] of Object.entries(summary.byProvider)) {
+          console.log(`  ${provider}: ${formatCost(cost2)}`);
+        }
+        console.log();
+      }
+      if (Object.keys(summary.byModel).length > 0) {
+        console.log(chalk61.bold("By Model"));
+        for (const [model, cost2] of Object.entries(summary.byModel)) {
+          console.log(`  ${model}: ${formatCost(cost2)}`);
+        }
+        console.log();
+      }
+      if (options.detail) {
+        const entries = readTodayCosts();
+        if (entries.length > 0) {
+          console.log(chalk61.bold("Entries"));
+          for (const entry of entries.slice(-10)) {
+            const time = new Date(entry.timestamp).toLocaleTimeString();
+            console.log(`  ${chalk61.dim(time)} ${entry.model} ${formatCost(entry.cost)} ${entry.operation}`);
+          }
+          if (entries.length > 10) {
+            console.log(chalk61.dim(`  ... and ${entries.length - 10} more`));
+          }
+        }
+      }
+    } catch (error) {
+      console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  cost.command("week").description("Show weekly cost summary").action(() => {
+    try {
+      const summary = getWeeklySummary();
+      console.log(chalk61.bold("Weekly Cost Summary"));
+      console.log(chalk61.dim(`${summary.period.start} to ${summary.period.end}`));
+      console.log();
+      console.log(`Total Cost: ${chalk61.green(formatCost(summary.totalCost))}`);
+      console.log(`API Calls: ${summary.entryCount}`);
+      console.log(`Tokens: ${summary.totalTokens.total.toLocaleString()}`);
+      console.log();
+      if (Object.keys(summary.byProvider).length > 0) {
+        console.log(chalk61.bold("By Provider"));
+        for (const [provider, cost2] of Object.entries(summary.byProvider)) {
+          console.log(`  ${provider}: ${formatCost(cost2)}`);
+        }
+        console.log();
+      }
+      if (Object.keys(summary.byIssue).length > 0) {
+        console.log(chalk61.bold("Top Issues by Cost"));
+        const sorted = Object.entries(summary.byIssue).sort(([, a], [, b]) => b - a).slice(0, 5);
+        for (const [issue, cost2] of sorted) {
+          console.log(`  ${issue}: ${formatCost(cost2)}`);
+        }
+      }
+    } catch (error) {
+      console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  cost.command("month").description("Show monthly cost summary").action(() => {
+    try {
+      const summary = getMonthlySummary();
+      console.log(chalk61.bold("Monthly Cost Summary"));
+      console.log(chalk61.dim(`${summary.period.start} to ${summary.period.end}`));
+      console.log();
+      console.log(`Total Cost: ${chalk61.green(formatCost(summary.totalCost))}`);
+      console.log(`API Calls: ${summary.entryCount}`);
+      console.log(`Tokens: ${summary.totalTokens.total.toLocaleString()}`);
+      console.log();
+      if (Object.keys(summary.byProvider).length > 0) {
+        console.log(chalk61.bold("By Provider"));
+        for (const [provider, cost2] of Object.entries(summary.byProvider)) {
+          console.log(`  ${provider}: ${formatCost(cost2)}`);
+        }
+        console.log();
+      }
+      if (Object.keys(summary.byModel).length > 0) {
+        console.log(chalk61.bold("By Model"));
+        for (const [model, cost2] of Object.entries(summary.byModel)) {
+          console.log(`  ${model}: ${formatCost(cost2)}`);
+        }
+        console.log();
+      }
+      if (Object.keys(summary.byIssue).length > 0) {
+        console.log(chalk61.bold("Top 10 Issues by Cost"));
+        const sorted = Object.entries(summary.byIssue).sort(([, a], [, b]) => b - a).slice(0, 10);
+        for (const [issue, cost2] of sorted) {
+          console.log(`  ${issue}: ${formatCost(cost2)}`);
+        }
+      }
+    } catch (error) {
+      console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  cost.command("report").description("Generate a cost report").option("-s, --start <date>", "Start date (YYYY-MM-DD)").option("-e, --end <date>", "End date (YYYY-MM-DD)").action((options) => {
+    try {
+      const end = options.end || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const start = options.start || (() => {
+        const d = /* @__PURE__ */ new Date();
+        d.setDate(d.getDate() - 30);
+        return d.toISOString().split("T")[0];
+      })();
+      const report = generateReport(start, end);
+      console.log(report);
+    } catch (error) {
+      console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  cost.command("issue <issueId>").description("Show costs for a specific issue").option("-d, --days <n>", "Number of days to look back", "30").action((issueId, options) => {
+    try {
+      const entries = readIssueCosts(issueId, parseInt(options.days, 10));
+      if (entries.length === 0) {
+        console.log(chalk61.dim("No costs found for issue:"), issueId);
+        return;
+      }
+      const summary = summarizeCosts(entries);
+      console.log(chalk61.bold(`Costs for ${issueId}`));
+      console.log();
+      console.log(`Total Cost: ${chalk61.green(formatCost(summary.totalCost))}`);
+      console.log(`API Calls: ${summary.entryCount}`);
+      console.log(`Tokens: ${summary.totalTokens.total.toLocaleString()}`);
+      console.log();
+      if (Object.keys(summary.byModel).length > 0) {
+        console.log(chalk61.bold("By Model"));
+        for (const [model, cost2] of Object.entries(summary.byModel)) {
+          console.log(`  ${model}: ${formatCost(cost2)}`);
+        }
+      }
+    } catch (error) {
+      console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  const budget = cost.command("budget").description("Manage cost budgets");
+  budget.command("create <name>").description("Create a cost budget").option("-l, --limit <amount>", "Budget limit in USD", "100").option("-t, --type <type>", "Budget type (daily, monthly, project, issue, feature)", "monthly").option("-a, --alert <threshold>", "Alert threshold (0-1)", "0.8").action((name, options) => {
+    try {
+      const newBudget = createBudget({
+        name,
+        type: options.type,
+        limit: parseFloat(options.limit),
+        currency: "USD",
+        alertThreshold: parseFloat(options.alert),
+        enabled: true
+      });
+      console.log(chalk61.green("\u2713 Budget created"));
+      console.log(`  ID: ${chalk61.cyan(newBudget.id)}`);
+      console.log(`  Name: ${newBudget.name}`);
+      console.log(`  Type: ${newBudget.type}`);
+      console.log(`  Limit: ${formatCost(newBudget.limit)}`);
+      console.log(`  Alert at: ${(newBudget.alertThreshold * 100).toFixed(0)}%`);
+    } catch (error) {
+      console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  budget.command("list").description("List all budgets").action(() => {
+    try {
+      const budgets = getAllBudgets();
+      if (budgets.length === 0) {
+        console.log(chalk61.dim("No budgets configured"));
+        console.log(chalk61.dim('Create one with: pan cost budget create "Monthly Limit" --limit 100'));
+        return;
+      }
+      console.log(chalk61.bold("Budgets"));
+      console.log();
+      for (const b of budgets) {
+        const status = checkBudget(b.id);
+        const percentStr = `${(status.percentUsed * 100).toFixed(0)}%`;
+        let statusColor = chalk61.green;
+        if (status.exceeded) {
+          statusColor = chalk61.red;
+        } else if (status.alert) {
+          statusColor = chalk61.yellow;
+        }
+        console.log(`${b.enabled ? "\u25CF" : "\u25CB"} ${chalk61.cyan(b.id)} ${b.name}`);
+        console.log(`  Type: ${b.type}`);
+        console.log(`  Limit: ${formatCost(b.limit)}`);
+        console.log(`  Spent: ${statusColor(formatCost(b.spent))} (${statusColor(percentStr)})`);
+        console.log(`  Remaining: ${formatCost(status.remaining)}`);
+        console.log();
+      }
+    } catch (error) {
+      console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  budget.command("check <id>").description("Check budget status").action((id) => {
+    try {
+      const status = checkBudget(id);
+      if (!status.budget) {
+        console.log(chalk61.red("Budget not found:"), id);
+        process.exit(1);
+      }
+      const b = status.budget;
+      const percentStr = `${(status.percentUsed * 100).toFixed(0)}%`;
+      let statusColor = chalk61.green;
+      let statusText = "OK";
+      if (status.exceeded) {
+        statusColor = chalk61.red;
+        statusText = "EXCEEDED";
+      } else if (status.alert) {
+        statusColor = chalk61.yellow;
+        statusText = "WARNING";
+      }
+      console.log(chalk61.bold(b.name));
+      console.log();
+      console.log(`Status: ${statusColor(statusText)}`);
+      console.log(`Limit: ${formatCost(b.limit)}`);
+      console.log(`Spent: ${statusColor(formatCost(b.spent))} (${statusColor(percentStr)})`);
+      console.log(`Remaining: ${formatCost(status.remaining)}`);
+      console.log(`Alert Threshold: ${(b.alertThreshold * 100).toFixed(0)}%`);
+    } catch (error) {
+      console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  budget.command("delete <id>").description("Delete a budget").action((id) => {
+    try {
+      const success = deleteBudget(id);
+      if (success) {
+        console.log(chalk61.green("\u2713 Budget deleted"));
+      } else {
+        console.log(chalk61.red("Budget not found:"), id);
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk61.red("Error:"), error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+  cost.command("sync").description("Import cost events from per-project WAL files into the local database").action(runCostSync);
+  return cost;
+}
+
 // src/cli/index.ts
-var PANOPTICON_ENV_FILE = join55(homedir26(), ".panopticon.env");
-if (existsSync55(PANOPTICON_ENV_FILE)) {
+var PANOPTICON_ENV_FILE = join56(homedir27(), ".panopticon.env");
+if (existsSync56(PANOPTICON_ENV_FILE)) {
   try {
-    const envContent = readFileSync48(PANOPTICON_ENV_FILE, "utf-8");
+    const envContent = readFileSync49(PANOPTICON_ENV_FILE, "utf-8");
     for (const line of envContent.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -16500,8 +17109,8 @@ if (existsSync55(PANOPTICON_ENV_FILE)) {
     console.warn("Warning: Failed to load ~/.panopticon.env:", error.message);
   }
 }
-var program = new Command();
-program.name("pan").description("Multi-agent orchestration for AI coding assistants").version(JSON.parse(readFileSync48(join55(import.meta.dirname, "../../package.json"), "utf-8")).version);
+var program = new Command2();
+program.name("pan").description("Multi-agent orchestration for AI coding assistants").version(JSON.parse(readFileSync49(join56(import.meta.dirname, "../../package.json"), "utf-8")).version);
 program.command("init").description("Initialize Panopticon (~/.panopticon/)").action(initCommand);
 program.command("sync").description("Sync skills/agents/rules to devroot").option("--dry-run", "Show what would be synced").option("--force", "Overwrite files modified since Panopticon installed them").option("--diff", "Show diff for modified files").option("--backup-only", "Only create backup").action(syncCommand);
 program.command("restore [timestamp]").description("Restore from backup").action(restoreCommand);
@@ -16525,58 +17134,58 @@ program.command("migrate-config").description("Migrate from settings.json to con
 program.command("status").description("Show running agents (shorthand for work status)").option("--json", "Output as JSON").option("--tldr", "Show TLDR index health across all workspaces").option("--context", "Show context window usage % for each agent").action(statusCommand);
 program.command("up").description("Start dashboard (and Traefik if enabled)").option("--detach", "Run in background").option("--skip-traefik", "Skip Traefik startup").action(async (options) => {
   const { spawn: spawn2, execSync: execSync9 } = await import("child_process");
-  const { join: join56, dirname: dirname17 } = await import("path");
+  const { join: join57, dirname: dirname17 } = await import("path");
   const { fileURLToPath: fileURLToPath6 } = await import("url");
-  const { readFileSync: readFileSync49, existsSync: existsSync56 } = await import("fs");
+  const { readFileSync: readFileSync50, existsSync: existsSync57 } = await import("fs");
   const { parse } = await import("@iarna/toml");
   const __dirname6 = dirname17(fileURLToPath6(import.meta.url));
-  const bundledServer = join56(__dirname6, "..", "dashboard", "server.js");
-  const srcDashboard = join56(__dirname6, "..", "..", "src", "dashboard");
-  const configFile = join56(process.env.HOME || "", ".panopticon", "config.toml");
+  const bundledServer = join57(__dirname6, "..", "dashboard", "server.js");
+  const srcDashboard = join57(__dirname6, "..", "..", "src", "dashboard");
+  const configFile = join57(process.env.HOME || "", ".panopticon", "config.toml");
   let traefikEnabled = false;
   let traefikDomain = "pan.localhost";
   let dashboardPort = 3010;
   let dashboardApiPort = 3011;
-  if (existsSync56(configFile)) {
+  if (existsSync57(configFile)) {
     try {
-      const configContent = readFileSync49(configFile, "utf-8");
+      const configContent = readFileSync50(configFile, "utf-8");
       const config2 = parse(configContent);
       traefikEnabled = config2.traefik?.enabled === true;
       traefikDomain = config2.traefik?.domain || "pan.localhost";
       dashboardPort = config2.dashboard?.port || 3010;
       dashboardApiPort = config2.dashboard?.api_port || 3011;
     } catch (error) {
-      console.log(chalk61.yellow("Warning: Could not read config.toml"));
+      console.log(chalk62.yellow("Warning: Could not read config.toml"));
     }
   }
-  console.log(chalk61.bold("Starting Panopticon...\n"));
+  console.log(chalk62.bold("Starting Panopticon...\n"));
   if (traefikEnabled && !options.skipTraefik) {
     try {
-      const { generatePanopticonTraefikConfig: generatePanopticonTraefikConfig2, ensureProjectCerts: ensureProjectCerts2, generateTlsConfig: generateTlsConfig2, cleanupStaleTlsSections } = await import("../traefik-WFMQX2LY.js");
+      const { generatePanopticonTraefikConfig: generatePanopticonTraefikConfig2, ensureProjectCerts: ensureProjectCerts2, generateTlsConfig: generateTlsConfig2, cleanupStaleTlsSections } = await import("../traefik-5GL3Q7DJ.js");
       cleanupStaleTlsSections();
       if (generatePanopticonTraefikConfig2()) {
-        console.log(chalk61.dim("  Regenerated Traefik config from template"));
+        console.log(chalk62.dim("  Regenerated Traefik config from template"));
       }
       const generatedDomains = ensureProjectCerts2();
       for (const domain of generatedDomains) {
-        console.log(chalk61.dim(`  Generated wildcard cert for *.${domain}`));
+        console.log(chalk62.dim(`  Generated wildcard cert for *.${domain}`));
       }
       if (generateTlsConfig2()) {
-        console.log(chalk61.dim("  Generated TLS config (tls.yml)"));
+        console.log(chalk62.dim("  Generated TLS config (tls.yml)"));
       }
     } catch {
-      console.log(chalk61.yellow("Warning: Could not regenerate Traefik config"));
+      console.log(chalk62.yellow("Warning: Could not regenerate Traefik config"));
     }
     try {
       const { ensureBaseDomain: ensureBaseDomain2, detectDnsSyncMethod: detectDnsSyncMethod2, syncDnsToWindows: syncDnsToWindows2 } = await import("../dns-7BDJSD3E.js");
-      const dnsMethod = (existsSync56(configFile) ? parse(readFileSync49(configFile, "utf-8")).traefik?.dns_sync_method : null) || detectDnsSyncMethod2();
+      const dnsMethod = (existsSync57(configFile) ? parse(readFileSync50(configFile, "utf-8")).traefik?.dns_sync_method : null) || detectDnsSyncMethod2();
       ensureBaseDomain2(dnsMethod, traefikDomain);
       if (dnsMethod === "wsl2hosts") {
         syncDnsToWindows2().catch(() => {
         });
       }
     } catch {
-      console.log(chalk61.yellow(`Warning: Could not ensure DNS for ${traefikDomain}`));
+      console.log(chalk62.yellow(`Warning: Could not ensure DNS for ${traefikDomain}`));
     }
   } else if (!traefikEnabled) {
     try {
@@ -16585,19 +17194,19 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
         { encoding: "utf-8" }
       ).trim();
       if (containerCheck.includes("panopticon-traefik")) {
-        console.log(chalk61.yellow("\u26A0 Traefik container is running but traefik.enabled is not set in config"));
-        console.log(chalk61.yellow("  Run `pan install` to configure Traefik, or `pan down` to stop it\n"));
+        console.log(chalk62.yellow("\u26A0 Traefik container is running but traefik.enabled is not set in config"));
+        console.log(chalk62.yellow("  Run `pan install` to configure Traefik, or `pan down` to stop it\n"));
       }
     } catch {
     }
   }
   if (traefikEnabled && !options.skipTraefik) {
-    const traefikDir = join56(process.env.HOME || "", ".panopticon", "traefik");
-    if (existsSync56(traefikDir)) {
+    const traefikDir = join57(process.env.HOME || "", ".panopticon", "traefik");
+    if (existsSync57(traefikDir)) {
       try {
-        const composeFile = join56(traefikDir, "docker-compose.yml");
-        if (existsSync56(composeFile)) {
-          const content = readFileSync49(composeFile, "utf-8");
+        const composeFile = join57(traefikDir, "docker-compose.yml");
+        if (existsSync57(composeFile)) {
+          const content = readFileSync50(composeFile, "utf-8");
           if (!content.includes("external: true") && content.includes("panopticon:")) {
             const patched = content.replace(
               /networks:\s*\n\s*panopticon:\s*\n\s*name: panopticon\s*\n\s*driver: bridge/,
@@ -16605,43 +17214,43 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
             );
             const { writeFileSync: writeFileSync27 } = await import("fs");
             writeFileSync27(composeFile, patched);
-            console.log(chalk61.dim("  (migrated network config)"));
+            console.log(chalk62.dim("  (migrated network config)"));
           }
         }
-        console.log(chalk61.dim("Starting Traefik..."));
+        console.log(chalk62.dim("Starting Traefik..."));
         execSync9("docker compose up -d", {
           cwd: traefikDir,
           stdio: "pipe"
         });
-        console.log(chalk61.green("\u2713 Traefik started"));
-        console.log(chalk61.dim(`  Dashboard: https://traefik.${traefikDomain}:8080
+        console.log(chalk62.green("\u2713 Traefik started"));
+        console.log(chalk62.dim(`  Dashboard: https://traefik.${traefikDomain}:8080
 `));
       } catch (error) {
-        console.log(chalk61.yellow("\u26A0 Failed to start Traefik (continuing anyway)"));
-        console.log(chalk61.dim("  Run with --skip-traefik to suppress this message\n"));
+        console.log(chalk62.yellow("\u26A0 Failed to start Traefik (continuing anyway)"));
+        console.log(chalk62.dim("  Run with --skip-traefik to suppress this message\n"));
       }
     }
   }
-  const isProduction = existsSync56(bundledServer);
-  const isDevelopment = existsSync56(srcDashboard);
+  const isProduction = existsSync57(bundledServer);
+  const isDevelopment = existsSync57(srcDashboard);
   if (!isProduction && !isDevelopment) {
-    console.error(chalk61.red("Error: Dashboard not found"));
-    console.error(chalk61.dim("This may be a corrupted installation. Try reinstalling panopticon-cli."));
+    console.error(chalk62.red("Error: Dashboard not found"));
+    console.error(chalk62.dim("This may be a corrupted installation. Try reinstalling panopticon-cli."));
     process.exit(1);
   }
   if (isDevelopment && !isProduction) {
     try {
       execSync9("npm --version", { stdio: "pipe" });
     } catch {
-      console.error(chalk61.red("Error: npm not found in PATH"));
-      console.error(chalk61.dim("Make sure Node.js and npm are installed and in your PATH"));
+      console.error(chalk62.red("Error: npm not found in PATH"));
+      console.error(chalk62.dim("Make sure Node.js and npm are installed and in your PATH"));
       process.exit(1);
     }
   }
   if (isProduction) {
-    console.log(chalk61.dim("Starting dashboard (bundled mode)..."));
+    console.log(chalk62.dim("Starting dashboard (bundled mode)..."));
   } else {
-    console.log(chalk61.dim("Starting dashboard (development mode)..."));
+    console.log(chalk62.dim("Starting dashboard (development mode)..."));
   }
   if (options.detach) {
     const child = isProduction ? spawn2("node", [bundledServer], {
@@ -16657,7 +17266,7 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
     let hasError = false;
     child.on("error", (err) => {
       hasError = true;
-      console.error(chalk61.red("Failed to start dashboard in background:"), err.message);
+      console.error(chalk62.red("Failed to start dashboard in background:"), err.message);
       process.exit(1);
     });
     setTimeout(() => {
@@ -16665,23 +17274,23 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
         child.unref();
       }
     }, 100);
-    console.log(chalk61.green("\u2713 Dashboard started in background"));
+    console.log(chalk62.green("\u2713 Dashboard started in background"));
     if (traefikEnabled) {
-      console.log(`  Frontend: ${chalk61.cyan(`https://${traefikDomain}`)}`);
-      console.log(`  API:      ${chalk61.cyan(`https://${traefikDomain}/api`)}`);
+      console.log(`  Frontend: ${chalk62.cyan(`https://${traefikDomain}`)}`);
+      console.log(`  API:      ${chalk62.cyan(`https://${traefikDomain}/api`)}`);
     } else {
-      console.log(`  Frontend: ${chalk61.cyan(`http://localhost:${dashboardPort}`)}`);
-      console.log(`  API:      ${chalk61.cyan(`http://localhost:${dashboardApiPort}`)}`);
+      console.log(`  Frontend: ${chalk62.cyan(`http://localhost:${dashboardPort}`)}`);
+      console.log(`  API:      ${chalk62.cyan(`http://localhost:${dashboardApiPort}`)}`);
     }
   } else {
     if (traefikEnabled) {
-      console.log(`  Frontend: ${chalk61.cyan(`https://${traefikDomain}`)}`);
-      console.log(`  API:      ${chalk61.cyan(`https://${traefikDomain}/api`)}`);
+      console.log(`  Frontend: ${chalk62.cyan(`https://${traefikDomain}`)}`);
+      console.log(`  API:      ${chalk62.cyan(`https://${traefikDomain}/api`)}`);
     } else {
-      console.log(`  Frontend: ${chalk61.cyan(`http://localhost:${dashboardPort}`)}`);
-      console.log(`  API:      ${chalk61.cyan(`http://localhost:${dashboardApiPort}`)}`);
+      console.log(`  Frontend: ${chalk62.cyan(`http://localhost:${dashboardPort}`)}`);
+      console.log(`  API:      ${chalk62.cyan(`http://localhost:${dashboardApiPort}`)}`);
     }
-    console.log(chalk61.dim("\nPress Ctrl+C to stop\n"));
+    console.log(chalk62.dim("\nPress Ctrl+C to stop\n"));
     const child = isProduction ? spawn2("node", [bundledServer], {
       stdio: "inherit",
       env: { ...process.env, DASHBOARD_PORT: String(dashboardPort) }
@@ -16691,41 +17300,41 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
       shell: true
     });
     child.on("error", (err) => {
-      console.error(chalk61.red("Failed to start dashboard:"), err.message);
+      console.error(chalk62.red("Failed to start dashboard:"), err.message);
       process.exit(1);
     });
   }
   try {
     const { getTldrDaemonService: getTldrDaemonService2 } = await import("../tldr-daemon-T3THOUGT.js");
     const projectRoot = process.cwd();
-    const venvPath = join56(projectRoot, ".venv");
-    if (existsSync56(venvPath)) {
-      console.log(chalk61.dim("\nStarting TLDR daemon for project root..."));
+    const venvPath = join57(projectRoot, ".venv");
+    if (existsSync57(venvPath)) {
+      console.log(chalk62.dim("\nStarting TLDR daemon for project root..."));
       const tldrService = getTldrDaemonService2(projectRoot, venvPath);
       await tldrService.start(true);
-      console.log(chalk61.green("\u2713 TLDR daemon started"));
+      console.log(chalk62.green("\u2713 TLDR daemon started"));
     } else {
-      console.log(chalk61.dim("\nSkipping TLDR daemon (no .venv found)"));
-      console.log(chalk61.dim("  Run setup to create venv with llm-tldr"));
+      console.log(chalk62.dim("\nSkipping TLDR daemon (no .venv found)"));
+      console.log(chalk62.dim("  Run setup to create venv with llm-tldr"));
     }
   } catch (error) {
-    console.log(chalk61.yellow("\u26A0 Failed to start TLDR daemon:"), error?.message || String(error));
-    console.log(chalk61.dim("  TLDR will be unavailable but dashboard will work normally"));
+    console.log(chalk62.yellow("\u26A0 Failed to start TLDR daemon:"), error?.message || String(error));
+    console.log(chalk62.dim("  TLDR will be unavailable but dashboard will work normally"));
   }
 });
 program.command("down").description("Stop dashboard (and Traefik if enabled)").option("--skip-traefik", "Skip Traefik shutdown").action(async (options) => {
   const { execSync: execSync9 } = await import("child_process");
-  const { join: join56 } = await import("path");
-  const { readFileSync: readFileSync49, existsSync: existsSync56 } = await import("fs");
+  const { join: join57 } = await import("path");
+  const { readFileSync: readFileSync50, existsSync: existsSync57 } = await import("fs");
   const { parse } = await import("@iarna/toml");
-  console.log(chalk61.bold("Stopping Panopticon...\n"));
-  const configFile = join56(process.env.HOME || "", ".panopticon", "config.toml");
+  console.log(chalk62.bold("Stopping Panopticon...\n"));
+  const configFile = join57(process.env.HOME || "", ".panopticon", "config.toml");
   let traefikEnabled = false;
   let dashboardPort = 3010;
   let dashboardApiPort = 3011;
-  if (existsSync56(configFile)) {
+  if (existsSync57(configFile)) {
     try {
-      const configContent = readFileSync49(configFile, "utf-8");
+      const configContent = readFileSync50(configFile, "utf-8");
       const config2 = parse(configContent);
       traefikEnabled = config2.traefik?.enabled === true;
       dashboardPort = config2.dashboard?.port || 3010;
@@ -16733,44 +17342,44 @@ program.command("down").description("Stop dashboard (and Traefik if enabled)").o
     } catch (error) {
     }
   }
-  console.log(chalk61.dim("Stopping dashboard..."));
+  console.log(chalk62.dim("Stopping dashboard..."));
   try {
     execSync9(`lsof -ti:${dashboardPort} | xargs kill -9 2>/dev/null || true`, { stdio: "pipe" });
     execSync9(`lsof -ti:${dashboardApiPort} | xargs kill -9 2>/dev/null || true`, { stdio: "pipe" });
-    console.log(chalk61.green("\u2713 Dashboard stopped"));
+    console.log(chalk62.green("\u2713 Dashboard stopped"));
   } catch {
-    console.log(chalk61.dim("  No dashboard processes found"));
+    console.log(chalk62.dim("  No dashboard processes found"));
   }
   if (traefikEnabled && !options.skipTraefik) {
-    const traefikDir = join56(process.env.HOME || "", ".panopticon", "traefik");
-    if (existsSync56(traefikDir)) {
-      console.log(chalk61.dim("Stopping Traefik..."));
+    const traefikDir = join57(process.env.HOME || "", ".panopticon", "traefik");
+    if (existsSync57(traefikDir)) {
+      console.log(chalk62.dim("Stopping Traefik..."));
       try {
         execSync9("docker compose down", {
           cwd: traefikDir,
           stdio: "pipe"
         });
-        console.log(chalk61.green("\u2713 Traefik stopped"));
+        console.log(chalk62.green("\u2713 Traefik stopped"));
       } catch (error) {
-        console.log(chalk61.yellow("\u26A0 Failed to stop Traefik"));
+        console.log(chalk62.yellow("\u26A0 Failed to stop Traefik"));
       }
     }
   }
   try {
     const { getTldrDaemonService: getTldrDaemonService2 } = await import("../tldr-daemon-T3THOUGT.js");
-    const { exec: exec23 } = await import("child_process");
-    const { promisify: promisify23 } = await import("util");
-    const execAsync23 = promisify23(exec23);
+    const { exec: exec24 } = await import("child_process");
+    const { promisify: promisify24 } = await import("util");
+    const execAsync24 = promisify24(exec24);
     const projectRoot = process.cwd();
-    const venvPath = join56(projectRoot, ".venv");
-    if (existsSync56(venvPath)) {
-      console.log(chalk61.dim("\nStopping TLDR daemon..."));
+    const venvPath = join57(projectRoot, ".venv");
+    if (existsSync57(venvPath)) {
+      console.log(chalk62.dim("\nStopping TLDR daemon..."));
       const tldrService = getTldrDaemonService2(projectRoot, venvPath);
       await tldrService.stop();
-      console.log(chalk61.green("\u2713 TLDR daemon stopped"));
+      console.log(chalk62.green("\u2713 TLDR daemon stopped"));
     }
   } catch (error) {
-    console.log(chalk61.dim("  (TLDR daemon not running)"));
+    console.log(chalk62.dim("  (TLDR daemon not running)"));
   }
   console.log("");
 });
@@ -16782,5 +17391,9 @@ project.command("remove <nameOrPath>").description("Remove a project from the re
 project.command("init").description("Initialize projects.yaml with example configuration").action(projectInitCommand);
 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(updateCommand2);
-program.parse();
+program.addCommand(createCostCommand());
+program.command("sync-costs").description("Import cost events from per-project WAL files (alias for: pan cost sync)").action(async () => {
+  await program.parseAsync(["cost", "sync"], { from: "user" });
+});
+await program.parseAsync();
 //# sourceMappingURL=index.js.map