panopticon-cli 0.4.33 → 0.5.0

package/dist/cli/index.js

@@ -4,7 +4,7 @@ import {
   ensureProjectCerts,
   generatePanopticonTraefikConfig,
   generateTlsConfig
-} from "../chunk-RBUO57TC.js";
+} from "../chunk-PPRFKTVC.js";
 import {
   applyProjectTemplateOverlay,
   createWorkspace,
@@ -12,7 +12,7 @@ import {
   init_workspace_manager,
   mergeSkillsIntoWorkspace,
   removeWorkspace
-} from "../chunk-PI7Y3PSN.js";
+} from "../chunk-GR6ZZMCX.js";
 import "../chunk-7SN4L4PH.js";
 import {
   init_remote_agents,
@@ -41,7 +41,7 @@ import {
   saveSessionId,
   spawnAgent,
   stopAgent
-} from "../chunk-BKCWRMUX.js";
+} from "../chunk-HZT2AOPN.js";
 import {
   createShadowState,
   getPendingSyncCount,
@@ -93,7 +93,7 @@ import {
   wakeSpecialist,
   wakeSpecialistOrQueue,
   wakeSpecialistWithTask
-} from "../chunk-ASY7T35E.js";
+} from "../chunk-AAFQANKW.js";
 import {
   checkHook,
   clearHook,
@@ -110,7 +110,7 @@ import {
   sendKeysAsync,
   sendMail,
   sessionExists
-} from "../chunk-KJ2TRXNK.js";
+} from "../chunk-FTCPTHIJ.js";
 import "../chunk-JQBV3Q2W.js";
 import {
   addAlias,
@@ -128,19 +128,19 @@ import {
   restoreBackup,
   syncHooks,
   syncStatusline
-} from "../chunk-XKT5MHPT.js";
+} from "../chunk-WQG2TYCB.js";
 import "../chunk-AQXETQHW.js";
 import {
   createTracker,
   createTrackerFromConfig,
   init_factory
-} from "../chunk-XFR2DLMR.js";
+} from "../chunk-NTO3EDB3.js";
 import {
   init_config_yaml,
   init_settings,
   loadConfig as loadConfig2,
   loadSettings
-} from "../chunk-7XNJJBH6.js";
+} from "../chunk-HJSM6E6U.js";
 import {
   getDashboardApiUrl,
   getDefaultConfig,
@@ -215,8 +215,8 @@ import {
 
 // src/cli/index.ts
 init_esm_shims();
-import { readFileSync as readFileSync46, existsSync as existsSync53 } from "fs";
-import { join as join53 } from "path";
+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";
@@ -691,6 +691,23 @@ async function syncCommand(options) {
       mkcertSpinner.warn("Failed to install mkcert - run: https://github.com/FiloSottile/mkcert/releases");
     }
   }
+  if (!checkCommand("ox")) {
+    const oxSpinner = ora2("Installing SageOx CLI (ox)...").start();
+    try {
+      const binDir = join3(homedir2(), ".local", "bin");
+      mkdirSync2(binDir, { recursive: true });
+      const oxPath = join3(binDir, "ox");
+      const arch = process.arch === "x64" ? "amd64" : process.arch;
+      const platform2 = process.platform === "darwin" ? "darwin" : "linux";
+      execSync(`curl -sL "https://github.com/eltmon/ox/releases/download/latest/ox-${platform2}-${arch}" -o "${oxPath}" && chmod +x "${oxPath}"`, {
+        stdio: "pipe",
+        timeout: 6e4
+      });
+      oxSpinner.succeed("SageOx CLI installed");
+    } catch {
+      oxSpinner.warn("Failed to install SageOx CLI - see: https://github.com/eltmon/ox/releases");
+    }
+  }
   const projects = listProjects();
   if (projects.length > 0 && existsSync3(BUNDLED_GIT_HOOKS_DIR)) {
     const gitHooksSpinner = ora2("Installing git hooks in registered projects...").start();
@@ -950,7 +967,7 @@ function resolveShadowMode(options = {}) {
       trackerType
     };
   }
-  const config2 = loadConfig2();
+  const { config: config2 } = loadConfig2();
   let enabled = config2.shadow.enabled;
   let source = config2.shadow.enabled ? "project" : "default";
   if (process.env.SHADOW_MODE !== void 0) {
@@ -1752,7 +1769,7 @@ async function issueCommand(id, options) {
       issueId: id,
       workspace,
       model: options.model,
-      phase: options.phase,
+      phase: options.phase || "implementation",
       prompt
     });
     spinner.succeed(`Agent spawned: ${agent.id}`);
@@ -1798,8 +1815,25 @@ 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";
 init_tldr_daemon();
+function readContextPercent(agentId) {
+  const ctxFile = join9(getAgentDir(agentId), "context-pct");
+  try {
+    if (existsSync9(ctxFile)) {
+      const val = parseInt(readFileSync7(ctxFile, "utf8").trim(), 10);
+      return isNaN(val) ? null : val;
+    }
+  } catch {
+  }
+  return null;
+}
 async function statusCommand(options) {
+  if (options.tldr) {
+    await tldrIndexStatusCommand();
+    return;
+  }
   const agents = listRunningAgents().filter(
     (agent) => agent.id && agent.issueId && agent.workspace
   );
@@ -1811,7 +1845,8 @@ async function statusCommand(options) {
         ...agent,
         shadowMode: shadowed,
         shadowStatus: shadowState?.shadowStatus,
-        trackerStatus: shadowState?.trackerStatus
+        trackerStatus: shadowState?.trackerStatus,
+        ...options.context ? { contextPercent: readContextPercent(agent.id) } : {}
       };
     });
     console.log(JSON.stringify(agentsWithShadow, null, 2));
@@ -1837,6 +1872,11 @@ async function statusCommand(options) {
       const statusStr = `${shadowState.shadowStatus}${shadowState.trackerStatus !== shadowState.shadowStatus ? ` (tracker: ${shadowState.trackerStatus})` : ""}`;
       console.log(`  Shadow:   ${chalk7.cyan("\u{1F47B}")} ${statusStr}`);
     }
+    if (options.context) {
+      const ctxPct = readContextPercent(agent.id);
+      const ctxStr = ctxPct !== null ? `${ctxPct}%` : "--";
+      console.log(`  Context:  ${ctxStr}`);
+    }
     console.log(`  Runtime:  ${agent.runtime} (${agent.model})`);
     console.log(`  Duration: ${duration} min`);
     console.log(`  Workspace: ${chalk7.dim(agent.workspace)}`);
@@ -1857,6 +1897,122 @@ async function statusCommand(options) {
     console.log("");
   }
 }
+function readTldrIndexData(workspacePath) {
+  const tldrPath = join9(workspacePath, ".tldr");
+  if (!existsSync9(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)) {
+    try {
+      const cg = JSON.parse(readFileSync7(cgPath, "utf-8"));
+      if (Array.isArray(cg.edges)) {
+        edgeCount = cg.edges.length;
+        const files = /* @__PURE__ */ new Set();
+        for (const e of cg.edges) {
+          if (e.from_file) files.add(e.from_file);
+          if (e.to_file) files.add(e.to_file);
+        }
+        fileCount = files.size;
+      }
+    } catch {
+    }
+  }
+  const langPath = join9(tldrPath, "languages.json");
+  if (existsSync9(langPath)) {
+    try {
+      const langData = JSON.parse(readFileSync7(langPath, "utf-8"));
+      if (langData.timestamp) {
+        ageMs = Date.now() - langData.timestamp * 1e3;
+      }
+    } catch {
+    }
+  }
+  if (ageMs === null) {
+    try {
+      const stats = statSync4(tldrPath);
+      ageMs = Date.now() - stats.mtimeMs;
+    } catch {
+    }
+  }
+  return { fileCount, edgeCount, ageMs };
+}
+function formatTldrAge(ageMs) {
+  if (ageMs === null) return "unknown";
+  const ageMin = Math.floor(ageMs / 6e4);
+  if (ageMin < 60) return `${ageMin}m`;
+  const ageHours = Math.floor(ageMin / 60);
+  if (ageHours < 24) return `${ageHours}h`;
+  return `${Math.floor(ageHours / 24)}d`;
+}
+function formatTldrRow(label, entry) {
+  const files = entry.fileCount !== null ? entry.fileCount.toLocaleString() : "N/A";
+  const edges = entry.edgeCount !== null ? entry.edgeCount.toLocaleString() : "N/A";
+  const age = formatTldrAge(entry.ageMs);
+  const daemonStr = entry.running ? chalk7.green("running \u2713") : chalk7.dim("stopped \u25CB");
+  const notIndexed = entry.fileCount === null ? chalk7.dim(" (not indexed)") : "";
+  return `  ${chalk7.bold(label)}${notIndexed}  Files: ${files}  Edges: ${edges}  Age: ${age}  Daemon: ${daemonStr}`;
+}
+async function tldrIndexStatusCommand(projectRoot = process.cwd()) {
+  const projectName = basename2(projectRoot);
+  const mainEntries = [];
+  const workspaceEntries = [];
+  const mainVenvPath = join9(projectRoot, ".venv");
+  if (existsSync9(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 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 service = getTldrDaemonService(wsPath, wsVenvPath);
+        const status = await service.getStatus();
+        const { fileCount, edgeCount, ageMs } = readTldrIndexData(wsPath);
+        workspaceEntries.push({ label: ws.name, running: status.running, fileCount, edgeCount, ageMs });
+      }
+    }
+  }
+  console.log(chalk7.bold("\nTLDR Index Health"));
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  if (mainEntries.length === 0 && workspaceEntries.length === 0) {
+    console.log(chalk7.dim("\nNo TLDR indexes found (no .venv directories)"));
+    console.log(chalk7.dim("Run `pan setup` to configure TLDR"));
+    return;
+  }
+  for (const entry of mainEntries) {
+    console.log(formatTldrRow(entry.label, entry));
+  }
+  if (workspaceEntries.length > 0) {
+    console.log("");
+    console.log(chalk7.bold("Workspaces"));
+    for (const entry of workspaceEntries) {
+      console.log(formatTldrRow(entry.label, entry));
+    }
+  }
+  const allEntries = [...mainEntries, ...workspaceEntries];
+  const ONE_HOUR = 60 * 60 * 1e3;
+  const anyMissing = allEntries.some((e) => e.fileCount === null);
+  const anyNotRunning = allEntries.some((e) => !e.running);
+  const anyStale = allEntries.some((e) => e.ageMs === null || e.ageMs >= ONE_HOUR);
+  console.log("");
+  if (anyMissing || anyNotRunning) {
+    console.log(`Health: ${chalk7.red("\u2717 TLDR not fully configured")}`);
+  } else if (anyStale) {
+    console.log(`Health: ${chalk7.yellow("\u26A0 Some indexes stale (>1h)")}`);
+  } else {
+    console.log(`Health: ${chalk7.green("\u2713 All indexes fresh")}`);
+  }
+  console.log("");
+}
 
 // src/cli/commands/work/tell.ts
 init_esm_shims();
@@ -1925,8 +2081,8 @@ init_esm_shims();
 init_agents();
 init_paths();
 import chalk10 from "chalk";
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join10 } from "path";
 async function pendingCommand() {
   const agents = listRunningAgents().filter((a) => !a.tmuxActive && a.status !== "error");
   if (agents.length === 0) {
@@ -1939,9 +2095,9 @@ async function pendingCommand() {
     console.log(`${chalk10.cyan(agent.issueId)}`);
     console.log(`  Agent:     ${agent.id}`);
     console.log(`  Workspace: ${chalk10.dim(agent.workspace)}`);
-    const completionFile = join9(AGENTS_DIR, agent.id, "completion.md");
-    if (existsSync9(completionFile)) {
-      const content = readFileSync7(completionFile, "utf8");
+    const completionFile = join10(AGENTS_DIR, agent.id, "completion.md");
+    if (existsSync10(completionFile)) {
+      const content = readFileSync8(completionFile, "utf8");
       const firstLine = content.split("\n").find((l) => l.trim() && !l.startsWith("#"));
       if (firstLine) {
         console.log(`  Summary:   ${chalk10.dim(firstLine.trim())}`);
@@ -1958,14 +2114,14 @@ init_agents();
 init_paths();
 import chalk11 from "chalk";
 import ora5 from "ora";
-import { existsSync as existsSync10, writeFileSync as writeFileSync3, readFileSync as readFileSync8 } from "fs";
-import { join as join10 } from "path";
+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 { execSync as execSync2 } from "child_process";
 function getLinearApiKey2() {
-  const envFile = join10(homedir4(), ".panopticon.env");
-  if (existsSync10(envFile)) {
-    const content = readFileSync8(envFile, "utf-8");
+  const envFile = join11(homedir4(), ".panopticon.env");
+  if (existsSync11(envFile)) {
+    const content = readFileSync9(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -2102,7 +2258,7 @@ async function approveCommand(id, options = {}) {
     state.status = "stopped";
     state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
     saveAgentState(state);
-    const approvedFile = join10(AGENTS_DIR, agentId, "approved");
+    const approvedFile = join11(AGENTS_DIR, agentId, "approved");
     writeFileSync3(approvedFile, JSON.stringify({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       prMerged,
@@ -2133,8 +2289,8 @@ init_agents();
 init_paths();
 import chalk12 from "chalk";
 import ora6 from "ora";
-import { existsSync as existsSync11, writeFileSync as writeFileSync4, readFileSync as readFileSync9, mkdirSync as mkdirSync4, readdirSync as readdirSync10 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync12, writeFileSync as writeFileSync4, readFileSync as readFileSync10, mkdirSync as mkdirSync4, readdirSync as readdirSync11 } from "fs";
+import { join as join12 } from "path";
 import { homedir as homedir5 } from "os";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -2271,9 +2427,9 @@ function cleanupWorkflowLabels(currentLabels, targetState) {
 // src/cli/commands/work/done.ts
 var execAsync = promisify(exec);
 function getLinearApiKey3() {
-  const envFile = join11(homedir5(), ".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();
   }
@@ -2315,9 +2471,9 @@ ${comment}`
   }
 }
 function getGitHubConfig() {
-  const envFile = join11(homedir5(), ".panopticon.env");
-  if (!existsSync11(envFile)) return null;
-  const content = readFileSync9(envFile, "utf-8");
+  const envFile = join12(homedir5(), ".panopticon.env");
+  if (!existsSync12(envFile)) return null;
+  const content = readFileSync10(envFile, "utf-8");
   const tokenMatch = content.match(/GITHUB_TOKEN=(.+)/);
   if (!tokenMatch) return null;
   const token = tokenMatch[1].trim();
@@ -2373,10 +2529,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-VLK4BMVA.js");
+    const { getAgentState: getAgentState2 } = await import("../agents-E43Y3HNU.js");
     const agentState = getAgentState2(agentId);
     const workspacePath = agentState?.workspace;
-    if (workspacePath && existsSync11(workspacePath)) {
+    if (workspacePath && existsSync12(workspacePath)) {
       const failures = [];
       try {
         const { stdout } = await execAsync("bd list --status open --limit 0 --json", { cwd: workspacePath });
@@ -2391,7 +2547,7 @@ async function doneCommand(id, options = {}) {
         }
       } catch {
       }
-      const hasTopLevelGit = existsSync11(join11(workspacePath, ".git"));
+      const hasTopLevelGit = existsSync12(join12(workspacePath, ".git"));
       if (hasTopLevelGit) {
         try {
           const { stdout } = await execAsync("git status --porcelain", { cwd: workspacePath });
@@ -2405,11 +2561,11 @@ async function doneCommand(id, options = {}) {
         }
       } else {
         try {
-          const entries = readdirSync10(workspacePath, { withFileTypes: true });
+          const entries = readdirSync11(workspacePath, { withFileTypes: true });
           for (const entry of entries) {
             if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-            const subPath = join11(workspacePath, entry.name);
-            if (!existsSync11(join11(subPath, ".git"))) continue;
+            const subPath = join12(workspacePath, entry.name);
+            if (!existsSync12(join12(subPath, ".git"))) continue;
             try {
               const { stdout } = await execAsync("git status --porcelain", { cwd: subPath });
               if (stdout.trim()) {
@@ -2472,7 +2628,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-VLK4BMVA.js");
+    const { getAgentState: getAgentState2, saveAgentState: saveAgentState2 } = await import("../agents-E43Y3HNU.js");
     const existingState = getAgentState2(agentId);
     if (existingState) {
       existingState.status = "stopped";
@@ -2483,8 +2639,8 @@ async function doneCommand(id, options = {}) {
       state: "idle",
       lastActivity: (/* @__PURE__ */ new Date()).toISOString()
     });
-    mkdirSync4(join11(AGENTS_DIR, agentId), { recursive: true });
-    const completedFile = join11(AGENTS_DIR, agentId, "completed");
+    mkdirSync4(join12(AGENTS_DIR, agentId), { recursive: true });
+    const completedFile = join12(AGENTS_DIR, agentId, "completed");
     writeFileSync4(completedFile, JSON.stringify({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       trackerUpdated,
@@ -2549,10 +2705,45 @@ async function doneCommand(id, options = {}) {
           req.write(postData);
           req.end();
         });
-        const result = await reviewReq();
+        let result = await reviewReq();
+        if (!result.success && result.alreadyMerged) {
+          console.log(chalk12.yellow(`  \u26A0 Issue was previously merged. Resetting specialist states for re-review...`));
+          const resetReq = () => new Promise((resolve2, reject) => {
+            const postData = JSON.stringify({});
+            const req = http.request(
+              `${dashboardUrl}/api/workspaces/${issueId}/reset-review`,
+              { method: "POST", headers: { "Content-Type": "application/json" }, timeout: 5e3 },
+              (res) => {
+                let data = "";
+                res.on("data", (chunk) => data += chunk);
+                res.on("end", () => {
+                  try {
+                    resolve2(JSON.parse(data));
+                  } catch {
+                    resolve2({ success: false, error: "Invalid response" });
+                  }
+                });
+              }
+            );
+            req.on("error", reject);
+            req.on("timeout", () => {
+              req.destroy();
+              reject(new Error("Timeout"));
+            });
+            req.write(postData);
+            req.end();
+          });
+          const resetResult = await resetReq();
+          if (resetResult.success) {
+            console.log(chalk12.green(`  \u2713 Specialist states reset`));
+            result = await reviewReq();
+          } else {
+            console.log(chalk12.red(`  \u2717 Failed to reset: ${resetResult.error || resetResult.message || "Unknown error"}`));
+          }
+        }
         if (result.success) {
           console.log(chalk12.green(`  \u2713 Review & test ${result.queued ? "queued" : "started"} automatically`));
-        } else {
+        } else if (!result.alreadyMerged) {
           console.log(chalk12.yellow(`  \u26A0 Auto-review not triggered: ${result.error || result.message || "Unknown error"}`));
           if (result.alreadyReviewed) {
             console.log(chalk12.dim(`    Manual review needed - click "Review and Test" in dashboard`));
@@ -2576,40 +2767,36 @@ init_esm_shims();
 import chalk13 from "chalk";
 import ora7 from "ora";
 import inquirer2 from "inquirer";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, existsSync as existsSync12, mkdirSync as mkdirSync5 } from "fs";
-import { join as join12, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync12, existsSync as existsSync14 } from "fs";
+import { join as join14, dirname as dirname5 } from "path";
 import { homedir as homedir6 } from "os";
-import { exec as exec2 } from "child_process";
+
+// src/lib/planning/plan-utils.ts
+init_esm_shims();
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join13 } from "path";
+import { exec as exec2, spawn } from "child_process";
 import { promisify as promisify2 } from "util";
 init_paths();
 var execAsync2 = promisify2(exec2);
-function getLinearApiKey4() {
-  const envFile = join12(homedir6(), ".panopticon.env");
-  if (existsSync12(envFile)) {
-    const content = readFileSync10(envFile, "utf-8");
-    const match = content.match(/LINEAR_API_KEY=(.+)/);
-    if (match) return match[1].trim();
-  }
-  return process.env.LINEAR_API_KEY || null;
-}
-async function findPRDFiles(issueId) {
+async function findPRDFiles(issueId, cwd) {
   const found = [];
-  const cwd = process.cwd();
+  const searchRoot = cwd || process.cwd();
   if (hasPRDDraft(issueId)) {
     found.push(getPRDDraftPath(issueId));
   }
   const searchPaths = [
-    join12(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR),
-    join12(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, "planned"),
-    join12(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR),
-    join12(PROJECT_DOCS_SUBDIR, "prd"),
+    join13(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR),
+    join13(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, "planned"),
+    join13(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR),
+    join13(PROJECT_DOCS_SUBDIR, "prd"),
     PROJECT_PRDS_SUBDIR,
     PROJECT_DOCS_SUBDIR
   ];
   const issueIdLower = issueId.toLowerCase();
   for (const searchPath of searchPaths) {
-    const fullPath = join12(cwd, searchPath);
-    if (!existsSync12(fullPath)) continue;
+    const fullPath = join13(searchRoot, searchPath);
+    if (!existsSync13(fullPath)) continue;
     try {
       const { stdout: result } = await execAsync2(
         `find "${fullPath}" -type f -name "*.md" 2>/dev/null | xargs grep -l -i "${issueIdLower}" 2>/dev/null || true`,
@@ -2686,7 +2873,7 @@ function analyzeComplexity(issue, prdFiles) {
     estimatedTasks += 1;
   }
   if (prdFiles.length > 0) {
-    reasons.push(`PRD exists - complexity already documented`);
+    reasons.push("PRD exists - complexity already documented");
   }
   const complexLabels = ["complex", "large", "epic", "multi-phase", "architecture"];
   for (const label of issue.labels || []) {
@@ -2703,138 +2890,7 @@ function analyzeComplexity(issue, prdFiles) {
     estimatedTasks: Math.max(estimatedTasks, subsystems.length + 1)
   };
 }
-async function runDiscoveryPhase(issue, complexity, prdContent) {
-  const decisions = [];
-  const tasks = [];
-  console.log("");
-  console.log(chalk13.bold.cyan("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
-  console.log(chalk13.bold.cyan("                    DISCOVERY PHASE"));
-  console.log(chalk13.bold.cyan("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
-  console.log("");
-  console.log(chalk13.dim("Answer questions to create a detailed execution plan."));
-  console.log(chalk13.dim("Press Enter to skip optional questions."));
-  console.log("");
-  console.log(chalk13.bold("Issue:"), `${issue.identifier} - ${issue.title}`);
-  if (complexity.subsystems.length > 0) {
-    console.log(chalk13.bold("Detected subsystems:"), complexity.subsystems.join(", "));
-  }
-  console.log("");
-  const scopeAnswer = await inquirer2.prompt([{
-    type: "input",
-    name: "scope",
-    message: "What specific changes are needed? (be specific about files/components):",
-    default: issue.description?.slice(0, 100) || ""
-  }]);
-  if (scopeAnswer.scope) {
-    decisions.push({ question: "Scope", answer: scopeAnswer.scope });
-  }
-  const approachAnswer = await inquirer2.prompt([{
-    type: "input",
-    name: "approach",
-    message: "Any specific technical approach or patterns to follow?"
-  }]);
-  if (approachAnswer.approach) {
-    decisions.push({ question: "Technical approach", answer: approachAnswer.approach });
-  }
-  const edgeCasesAnswer = await inquirer2.prompt([{
-    type: "input",
-    name: "edgeCases",
-    message: "Any edge cases or error scenarios to handle?"
-  }]);
-  if (edgeCasesAnswer.edgeCases) {
-    decisions.push({ question: "Edge cases", answer: edgeCasesAnswer.edgeCases });
-  }
-  const testingAnswer = await inquirer2.prompt([{
-    type: "checkbox",
-    name: "testing",
-    message: "What testing is required?",
-    choices: [
-      { name: "Unit tests", value: "unit", checked: true },
-      { name: "Integration tests", value: "integration" },
-      { name: "E2E tests (Playwright)", value: "e2e" },
-      { name: "Manual testing only", value: "manual" }
-    ]
-  }]);
-  if (testingAnswer.testing.length > 0) {
-    decisions.push({ question: "Testing", answer: testingAnswer.testing.join(", ") });
-  }
-  const outOfScopeAnswer = await inquirer2.prompt([{
-    type: "input",
-    name: "outOfScope",
-    message: "Anything explicitly OUT of scope for this issue?"
-  }]);
-  if (outOfScopeAnswer.outOfScope) {
-    decisions.push({ question: "Out of scope", answer: outOfScopeAnswer.outOfScope });
-  }
-  console.log("");
-  console.log(chalk13.bold("Define execution tasks:"));
-  console.log(chalk13.dim("Enter tasks in order. Empty task name to finish."));
-  console.log("");
-  const suggestedTasks = [
-    { name: "Understand requirements", description: "Review issue, PRD, and existing code" }
-  ];
-  if (complexity.subsystems.length > 1) {
-    suggestedTasks.push({ name: "Design approach", description: "Document architecture decisions", dependsOn: "Understand requirements" });
-  }
-  for (const subsystem of complexity.subsystems) {
-    suggestedTasks.push({
-      name: `Implement ${subsystem}`,
-      description: `Core ${subsystem} changes`,
-      dependsOn: complexity.subsystems.length > 1 ? "Design approach" : "Understand requirements"
-    });
-  }
-  if (suggestedTasks.length === 1) {
-    suggestedTasks.push({ name: "Implement changes", description: "Core implementation", dependsOn: "Understand requirements" });
-  }
-  if (testingAnswer.testing.includes("unit") || testingAnswer.testing.includes("integration")) {
-    suggestedTasks.push({ name: "Add tests", description: "Unit and/or integration tests", dependsOn: suggestedTasks[suggestedTasks.length - 1].name });
-  }
-  if (testingAnswer.testing.includes("e2e")) {
-    suggestedTasks.push({ name: "Add E2E tests", description: "Playwright E2E tests", dependsOn: "Add tests" });
-  }
-  suggestedTasks.push({ name: "Verify and cleanup", description: "Lint, type check, final review", dependsOn: suggestedTasks[suggestedTasks.length - 1].name });
-  console.log(chalk13.bold("Suggested tasks:"));
-  for (let i = 0; i < suggestedTasks.length; i++) {
-    const task = suggestedTasks[i];
-    console.log(`  ${i + 1}. ${task.name}${task.dependsOn ? chalk13.dim(` (after: ${task.dependsOn})`) : ""}`);
-  }
-  console.log("");
-  const useDefaultAnswer = await inquirer2.prompt([{
-    type: "confirm",
-    name: "useDefault",
-    message: "Use these suggested tasks?",
-    default: true
-  }]);
-  if (useDefaultAnswer.useDefault) {
-    tasks.push(...suggestedTasks);
-  } else {
-    let taskIndex = 1;
-    let previousTask = "";
-    while (true) {
-      const taskAnswer = await inquirer2.prompt([{
-        type: "input",
-        name: "name",
-        message: `Task ${taskIndex} name (empty to finish):`
-      }]);
-      if (!taskAnswer.name) break;
-      const descAnswer = await inquirer2.prompt([{
-        type: "input",
-        name: "description",
-        message: `Task ${taskIndex} description:`,
-        default: taskAnswer.name
-      }]);
-      tasks.push({
-        name: taskAnswer.name,
-        description: descAnswer.description,
-        dependsOn: previousTask || void 0
-      });
-      previousTask = taskAnswer.name;
-      taskIndex++;
-    }
-  }
-  return { tasks, decisions };
-}
-function generateStateFile(issue, decisions, tasks) {
+function generateStateContent(issue, decisions, tasks) {
   const lines = [
     `# Agent State: ${issue.identifier}`,
     "",
@@ -2874,7 +2930,8 @@ function generateStateFile(issue, decisions, tasks) {
   lines.push("");
   return lines.join("\n");
 }
-function generateWorkspaceFile(issue, prdFiles) {
+function generateWorkspaceContent(issue, prdFiles, cwd) {
+  const searchRoot = cwd || process.cwd();
   const lines = [
     `# Workspace: ${issue.identifier}`,
     "",
@@ -2885,7 +2942,7 @@ function generateWorkspaceFile(issue, prdFiles) {
     `- [Linear Issue](${issue.url})`
   ];
   for (const prd of prdFiles) {
-    const relativePath = prd.replace(process.cwd() + "/", "");
+    const relativePath = prd.replace(searchRoot + "/", "");
     lines.push(`- [PRD](${relativePath})`);
   }
   lines.push("");
@@ -2922,86 +2979,269 @@ function generateWorkspaceFile(issue, prdFiles) {
   lines.push("");
   return lines.join("\n");
 }
-function estimateDifficulty(task) {
-  if (task.difficulty) {
-    return task.difficulty;
-  }
+function estimateTaskDifficulty(task) {
+  if (task.difficulty) return task.difficulty;
   const combined = `${task.name} ${task.description || ""}`.toLowerCase();
   const expertPatterns = ["architecture", "security", "performance optimization", "distributed", "auth system", "redesign"];
-  if (expertPatterns.some((p) => combined.includes(p))) {
-    return "expert";
-  }
+  if (expertPatterns.some((p) => combined.includes(p))) return "expert";
   const complexPatterns = ["refactor", "migration", "overhaul", "rewrite", "integrate", "multi-system"];
-  if (complexPatterns.some((p) => combined.includes(p))) {
-    return "complex";
+  if (complexPatterns.some((p) => combined.includes(p))) return "complex";
+  const mediumPatterns = ["implement", "feature", "endpoint", "component", "service", "integration", "add tests"];
+  if (mediumPatterns.some((p) => combined.includes(p))) return "medium";
+  const trivialPatterns = ["typo", "rename", "comment", "documentation", "readme", "formatting"];
+  if (trivialPatterns.some((p) => combined.includes(p))) return "trivial";
+  return "simple";
+}
+async function createBeadsTasks(issue, tasks, cwd) {
+  const created = [];
+  const errors = [];
+  const taskIds = /* @__PURE__ */ new Map();
+  const workDir = cwd || process.cwd();
+  try {
+    await execAsync2("which bd", { encoding: "utf-8" });
+  } catch {
+    return { success: false, created: [], errors: ["bd (beads) CLI not found in PATH"] };
+  }
+  for (const task of tasks) {
+    const fullName = `${issue.identifier}: ${task.name}`;
+    try {
+      const difficulty = estimateTaskDifficulty(task);
+      const escapedName = fullName.replace(/"/g, '\\"');
+      let cmd = `bd create "${escapedName}" --type task -l "${issue.identifier},linear,difficulty:${difficulty}"`;
+      if (task.dependsOn) {
+        const depName = `${issue.identifier}: ${task.dependsOn}`;
+        const depId = taskIds.get(depName);
+        if (depId) {
+          cmd += ` --deps "blocks:${depId}"`;
+        }
+      }
+      if (task.description) {
+        const escapedDesc = task.description.replace(/"/g, '\\"');
+        cmd += ` -d "${escapedDesc}"`;
+      }
+      const { stdout: result } = await execAsync2(cmd, { encoding: "utf-8", cwd: workDir });
+      const idMatch = result.match(/bd-[a-f0-9]+/i) || result.match(/([a-f0-9-]{8,})/i);
+      if (idMatch) {
+        taskIds.set(fullName, idMatch[0]);
+      }
+      created.push(fullName);
+    } catch (error) {
+      const errMsg = error.stderr?.toString() || error.message;
+      errors.push(`Failed to create "${task.name}": ${errMsg.split("\n")[0]}`);
+    }
+  }
+  if (created.length > 0) {
+    try {
+      await execAsync2("bd flush", { encoding: "utf-8", cwd: workDir });
+    } catch {
+    }
+  }
+  return { success: errors.length === 0, created, errors };
+}
+function writePlanFiles(projectPath, stateContent, workspaceContent) {
+  const planningDir = join13(projectPath, ".planning");
+  mkdirSync5(planningDir, { recursive: true });
+  const statePath = join13(planningDir, "STATE.md");
+  const workspacePath = join13(planningDir, "WORKSPACE.md");
+  writeFileSync5(statePath, stateContent);
+  writeFileSync5(workspacePath, workspaceContent);
+  return { statePath, workspacePath };
+}
+async function copyToPRDDirectory(projectPath, issue, content, options) {
+  const prdDir = join13(projectPath, PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR);
+  try {
+    mkdirSync5(prdDir, { recursive: true });
+    const filename = `${issue.identifier.toLowerCase()}-plan.md`;
+    const prdPath = join13(prdDir, filename);
+    writeFileSync5(prdPath, content);
+    let committed = false;
+    if (options?.commitAndPush) {
+      try {
+        const relativePrdPath = join13(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR, filename);
+        await execAsync2(`git add ${relativePrdPath}`, { cwd: projectPath, encoding: "utf-8" });
+        try {
+          await execAsync2("git diff --cached --quiet", { cwd: projectPath, encoding: "utf-8" });
+        } catch {
+          await execAsync2(`git commit -m "docs: add ${issue.identifier} PRD to active"`, {
+            cwd: projectPath,
+            encoding: "utf-8"
+          });
+          const pushChild = spawn("git", ["push"], { cwd: projectPath, detached: true, stdio: "ignore" });
+          pushChild.unref();
+          committed = true;
+        }
+      } catch (gitErr) {
+        console.warn(`[plan] Could not commit PRD (non-fatal): ${gitErr.message}`);
+      }
+    }
+    return { prdPath, committed };
+  } catch {
+    return { prdPath: null, committed: false };
+  }
+}
+async function executePlan(issue, tasks, decisions, projectPath, options) {
+  const prdFiles = options?.prdFiles || [];
+  const stateContent = generateStateContent(issue, decisions, tasks);
+  const workspaceContent = generateWorkspaceContent(issue, prdFiles, projectPath);
+  const { statePath, workspacePath } = writePlanFiles(projectPath, stateContent, workspaceContent);
+  const { prdPath, committed } = await copyToPRDDirectory(
+    projectPath,
+    issue,
+    stateContent,
+    { commitAndPush: options?.commitAndPush ?? false }
+  );
+  const beads = await createBeadsTasks(issue, tasks, projectPath);
+  return {
+    files: {
+      state: statePath,
+      workspace: workspacePath,
+      prd: prdPath || void 0
+    },
+    prdCommitted: committed,
+    beads
+  };
+}
+
+// src/cli/commands/work/plan.ts
+function getLinearApiKey4() {
+  const envFile = join14(homedir6(), ".panopticon.env");
+  if (existsSync14(envFile)) {
+    const content = readFileSync12(envFile, "utf-8");
+    const match = content.match(/LINEAR_API_KEY=(.+)/);
+    if (match) return match[1].trim();
+  }
+  return process.env.LINEAR_API_KEY || null;
+}
+async function runDiscoveryPhase(issue, complexity, prdContent) {
+  const decisions = [];
+  const tasks = [];
+  console.log("");
+  console.log(chalk13.bold.cyan("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+  console.log(chalk13.bold.cyan("                    DISCOVERY PHASE"));
+  console.log(chalk13.bold.cyan("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+  console.log("");
+  console.log(chalk13.dim("Answer questions to create a detailed execution plan."));
+  console.log(chalk13.dim("Press Enter to skip optional questions."));
+  console.log("");
+  console.log(chalk13.bold("Issue:"), `${issue.identifier} - ${issue.title}`);
+  if (complexity.subsystems.length > 0) {
+    console.log(chalk13.bold("Detected subsystems:"), complexity.subsystems.join(", "));
+  }
+  console.log("");
+  const scopeAnswer = await inquirer2.prompt([{
+    type: "input",
+    name: "scope",
+    message: "What specific changes are needed? (be specific about files/components):",
+    default: issue.description?.slice(0, 100) || ""
+  }]);
+  if (scopeAnswer.scope) {
+    decisions.push({ question: "Scope", answer: scopeAnswer.scope });
+  }
+  const approachAnswer = await inquirer2.prompt([{
+    type: "input",
+    name: "approach",
+    message: "Any specific technical approach or patterns to follow?"
+  }]);
+  if (approachAnswer.approach) {
+    decisions.push({ question: "Technical approach", answer: approachAnswer.approach });
+  }
+  const edgeCasesAnswer = await inquirer2.prompt([{
+    type: "input",
+    name: "edgeCases",
+    message: "Any edge cases or error scenarios to handle?"
+  }]);
+  if (edgeCasesAnswer.edgeCases) {
+    decisions.push({ question: "Edge cases", answer: edgeCasesAnswer.edgeCases });
+  }
+  const testingAnswer = await inquirer2.prompt([{
+    type: "checkbox",
+    name: "testing",
+    message: "What testing is required?",
+    choices: [
+      { name: "Unit tests", value: "unit", checked: true },
+      { name: "Integration tests", value: "integration" },
+      { name: "E2E tests (Playwright)", value: "e2e" },
+      { name: "Manual testing only", value: "manual" }
+    ]
+  }]);
+  if (testingAnswer.testing.length > 0) {
+    decisions.push({ question: "Testing", answer: testingAnswer.testing.join(", ") });
+  }
+  const outOfScopeAnswer = await inquirer2.prompt([{
+    type: "input",
+    name: "outOfScope",
+    message: "Anything explicitly OUT of scope for this issue?"
+  }]);
+  if (outOfScopeAnswer.outOfScope) {
+    decisions.push({ question: "Out of scope", answer: outOfScopeAnswer.outOfScope });
+  }
+  console.log("");
+  console.log(chalk13.bold("Define execution tasks:"));
+  console.log(chalk13.dim("Enter tasks in order. Empty task name to finish."));
+  console.log("");
+  const suggestedTasks = [
+    { name: "Understand requirements", description: "Review issue, PRD, and existing code" }
+  ];
+  if (complexity.subsystems.length > 1) {
+    suggestedTasks.push({ name: "Design approach", description: "Document architecture decisions", dependsOn: "Understand requirements" });
+  }
+  for (const subsystem of complexity.subsystems) {
+    suggestedTasks.push({
+      name: `Implement ${subsystem}`,
+      description: `Core ${subsystem} changes`,
+      dependsOn: complexity.subsystems.length > 1 ? "Design approach" : "Understand requirements"
+    });
   }
-  const mediumPatterns = ["implement", "feature", "endpoint", "component", "service", "integration", "add tests"];
-  if (mediumPatterns.some((p) => combined.includes(p))) {
-    return "medium";
+  if (suggestedTasks.length === 1) {
+    suggestedTasks.push({ name: "Implement changes", description: "Core implementation", dependsOn: "Understand requirements" });
   }
-  const trivialPatterns = ["typo", "rename", "comment", "documentation", "readme", "formatting"];
-  if (trivialPatterns.some((p) => combined.includes(p))) {
-    return "trivial";
+  if (testingAnswer.testing.includes("unit") || testingAnswer.testing.includes("integration")) {
+    suggestedTasks.push({ name: "Add tests", description: "Unit and/or integration tests", dependsOn: suggestedTasks[suggestedTasks.length - 1].name });
   }
-  return "simple";
-}
-async function createBeadsTasks(issue, tasks) {
-  const created = [];
-  const errors = [];
-  const taskIds = /* @__PURE__ */ new Map();
-  try {
-    await execAsync2("which bd", { encoding: "utf-8" });
-  } catch {
-    return { success: false, created: [], errors: ["bd (beads) CLI not found in PATH"] };
+  if (testingAnswer.testing.includes("e2e")) {
+    suggestedTasks.push({ name: "Add E2E tests", description: "Playwright E2E tests", dependsOn: "Add tests" });
   }
-  for (const task of tasks) {
-    const fullName = `${issue.identifier}: ${task.name}`;
-    try {
-      const difficulty = estimateDifficulty(task);
-      const escapedName = fullName.replace(/"/g, '\\"');
-      let cmd = `bd create "${escapedName}" --type task -l "${issue.identifier},linear,difficulty:${difficulty}"`;
-      if (task.dependsOn) {
-        const depName = `${issue.identifier}: ${task.dependsOn}`;
-        const depId = taskIds.get(depName);
-        if (depId) {
-          cmd += ` --deps "blocks:${depId}"`;
-        }
-      }
-      if (task.description) {
-        const escapedDesc = task.description.replace(/"/g, '\\"');
-        cmd += ` -d "${escapedDesc}"`;
-      }
-      const { stdout: result } = await execAsync2(cmd, { encoding: "utf-8", cwd: process.cwd() });
-      const idMatch = result.match(/bd-[a-f0-9]+/i) || result.match(/([a-f0-9-]{8,})/i);
-      if (idMatch) {
-        taskIds.set(fullName, idMatch[0]);
-      }
-      created.push(fullName);
-    } catch (error) {
-      const errMsg = error.stderr?.toString() || error.message;
-      errors.push(`Failed to create "${task.name}": ${errMsg.split("\n")[0]}`);
-    }
+  suggestedTasks.push({ name: "Verify and cleanup", description: "Lint, type check, final review", dependsOn: suggestedTasks[suggestedTasks.length - 1].name });
+  console.log(chalk13.bold("Suggested tasks:"));
+  for (let i = 0; i < suggestedTasks.length; i++) {
+    const task = suggestedTasks[i];
+    console.log(`  ${i + 1}. ${task.name}${task.dependsOn ? chalk13.dim(` (after: ${task.dependsOn})`) : ""}`);
   }
-  if (created.length > 0) {
-    try {
-      await execAsync2("bd flush", { encoding: "utf-8", cwd: process.cwd() });
-    } catch {
+  console.log("");
+  const useDefaultAnswer = await inquirer2.prompt([{
+    type: "confirm",
+    name: "useDefault",
+    message: "Use these suggested tasks?",
+    default: true
+  }]);
+  if (useDefaultAnswer.useDefault) {
+    tasks.push(...suggestedTasks);
+  } else {
+    let taskIndex = 1;
+    let previousTask = "";
+    while (true) {
+      const taskAnswer = await inquirer2.prompt([{
+        type: "input",
+        name: "name",
+        message: `Task ${taskIndex} name (empty to finish):`
+      }]);
+      if (!taskAnswer.name) break;
+      const descAnswer = await inquirer2.prompt([{
+        type: "input",
+        name: "description",
+        message: `Task ${taskIndex} description:`,
+        default: taskAnswer.name
+      }]);
+      tasks.push({
+        name: taskAnswer.name,
+        description: descAnswer.description,
+        dependsOn: previousTask || void 0
+      });
+      previousTask = taskAnswer.name;
+      taskIndex++;
     }
   }
-  return { success: errors.length === 0, created, errors };
-}
-function copyToPRDDirectory(issue, stateContent) {
-  const cwd = process.cwd();
-  const prdDir = join12(cwd, PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR);
-  try {
-    mkdirSync5(prdDir, { recursive: true });
-    const filename = `${issue.identifier.toLowerCase()}-plan.md`;
-    const prdPath = join12(prdDir, filename);
-    writeFileSync5(prdPath, stateContent);
-    return prdPath;
-  } catch {
-    return null;
-  }
+  return { tasks, decisions };
 }
 async function planCommand(id, options = {}) {
   const spinner = ora7(`Creating execution plan for ${id}...`).start();
@@ -3041,9 +3281,9 @@ async function planCommand(id, options = {}) {
       identifier: issue.identifier,
       title: issue.title,
       description: issue.description || void 0,
+      url: issue.url,
       state: { name: state?.name || "Unknown" },
       priority: issue.priority,
-      url: issue.url,
       labels: labels.nodes.map((l) => ({ name: l.name })),
       assignee: assignee ? { name: assignee.name } : void 0,
       project: project2 ? { name: project2.name } : void 0
@@ -3108,29 +3348,23 @@ async function planCommand(id, options = {}) {
       decisions = discovery.decisions;
     }
     const spinnerCreate = ora7("Creating context files...").start();
-    const stateContent = generateStateFile(issueData, decisions, tasks);
-    const workspaceContent = generateWorkspaceFile(issueData, prdFiles);
     const outputDir = options.output ? dirname5(options.output) : process.cwd();
-    const planningDir = join12(outputDir, ".planning");
-    mkdirSync5(planningDir, { recursive: true });
-    const statePath = join12(planningDir, "STATE.md");
-    writeFileSync5(statePath, stateContent);
-    const workspacePath = join12(planningDir, "WORKSPACE.md");
-    writeFileSync5(workspacePath, workspaceContent);
+    const result = await executePlan(issueData, tasks, decisions, outputDir, {
+      prdFiles
+    });
     spinnerCreate.succeed("Context files created");
-    const spinnerBeads = ora7("Creating Beads tasks...").start();
-    const beadsResult = await createBeadsTasks(issueData, tasks);
-    if (beadsResult.success) {
-      spinnerBeads.succeed(`Created ${beadsResult.created.length} Beads tasks`);
-    } else {
-      spinnerBeads.warn(`Created ${beadsResult.created.length} tasks with errors`);
-      for (const error of beadsResult.errors) {
-        console.log(chalk13.red(`  - ${error}`));
+    if (result.beads.created.length > 0) {
+      if (result.beads.success) {
+        console.log(chalk13.green(`Created ${result.beads.created.length} Beads tasks`));
+      } else {
+        console.log(chalk13.yellow(`Created ${result.beads.created.length} Beads tasks with errors`));
+        for (const error of result.beads.errors) {
+          console.log(chalk13.red(`  - ${error}`));
+        }
       }
     }
-    const prdPath = copyToPRDDirectory(issueData, stateContent);
-    if (prdPath) {
-      console.log(chalk13.dim(`Plan copied to: ${prdPath.replace(process.cwd() + "/", "")}`));
+    if (result.files.prd) {
+      console.log(chalk13.dim(`Plan copied to: ${result.files.prd.replace(process.cwd() + "/", "")}`));
     }
     if (options.json) {
       console.log(JSON.stringify({
@@ -3138,12 +3372,8 @@ async function planCommand(id, options = {}) {
         complexity,
         tasks,
         decisions,
-        files: {
-          state: statePath,
-          workspace: workspacePath,
-          prd: prdPath
-        },
-        beads: beadsResult
+        files: result.files,
+        beads: result.beads
       }, null, 2));
       return;
     }
@@ -3153,8 +3383,8 @@ async function planCommand(id, options = {}) {
     console.log(chalk13.bold.green("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
     console.log("");
     console.log(chalk13.bold("Files created:"));
-    console.log(`  ${chalk13.cyan(statePath.replace(process.cwd() + "/", ""))}`);
-    console.log(`  ${chalk13.cyan(workspacePath.replace(process.cwd() + "/", ""))}`);
+    console.log(`  ${chalk13.cyan(result.files.state.replace(process.cwd() + "/", ""))}`);
+    console.log(`  ${chalk13.cyan(result.files.workspace.replace(process.cwd() + "/", ""))}`);
     console.log("");
     console.log(chalk13.bold("Beads tasks:"));
     for (const task of tasks) {
@@ -3359,8 +3589,8 @@ init_esm_shims();
 init_config();
 import chalk15 from "chalk";
 import ora9 from "ora";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, existsSync as existsSync13, mkdirSync as mkdirSync6 } from "fs";
-import { join as join13 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync6, existsSync as existsSync15, mkdirSync as mkdirSync6 } from "fs";
+import { join as join15 } from "path";
 import { homedir as homedir7 } from "os";
 function getTrackerConfig2(trackerType) {
   const config2 = loadConfig();
@@ -3379,13 +3609,13 @@ function getTrackerConfig2(trackerType) {
   };
 }
 function getTriageStatePath() {
-  return join13(homedir7(), ".panopticon", "triage-state.json");
+  return join15(homedir7(), ".panopticon", "triage-state.json");
 }
 function loadTriageState() {
   const path = getTriageStatePath();
-  if (existsSync13(path)) {
+  if (existsSync15(path)) {
     try {
-      return JSON.parse(readFileSync11(path, "utf-8"));
+      return JSON.parse(readFileSync13(path, "utf-8"));
     } catch {
       return { dismissed: [], created: {} };
     }
@@ -3393,8 +3623,8 @@ function loadTriageState() {
   return { dismissed: [], created: {} };
 }
 function saveTriageState(state) {
-  const dir = join13(homedir7(), ".panopticon");
-  if (!existsSync13(dir)) {
+  const dir = join15(homedir7(), ".panopticon");
+  if (!existsSync15(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
   const path = getTriageStatePath();
@@ -3779,23 +4009,23 @@ import chalk19 from "chalk";
 // src/lib/context.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync7, appendFileSync, readdirSync as readdirSync11 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync7, appendFileSync, readdirSync as readdirSync12 } from "fs";
+import { join as join16 } from "path";
 function getStateFile(agentId) {
-  return join14(AGENTS_DIR, agentId, "STATE.md");
+  return join16(AGENTS_DIR, agentId, "STATE.md");
 }
 function readAgentState(agentId) {
   const stateFile = getStateFile(agentId);
-  if (!existsSync14(stateFile)) return null;
+  if (!existsSync16(stateFile)) return null;
   try {
-    const content = readFileSync12(stateFile, "utf-8");
+    const content = readFileSync14(stateFile, "utf-8");
     return parseStateMd(content);
   } catch {
     return null;
   }
 }
 function writeAgentState(agentId, state) {
-  const dir = join14(AGENTS_DIR, agentId);
+  const dir = join16(AGENTS_DIR, agentId);
   mkdirSync7(dir, { recursive: true });
   const content = generateStateMd(state);
   writeFileSync7(getStateFile(agentId), content);
@@ -3872,14 +4102,14 @@ function parseStateMd(content) {
   return state;
 }
 function getSummaryFile(agentId) {
-  return join14(AGENTS_DIR, agentId, "SUMMARY.md");
+  return join16(AGENTS_DIR, agentId, "SUMMARY.md");
 }
 function appendSummary(agentId, summary) {
-  const dir = join14(AGENTS_DIR, agentId);
+  const dir = join16(AGENTS_DIR, agentId);
   mkdirSync7(dir, { recursive: true });
   const summaryFile = getSummaryFile(agentId);
   const content = generateSummaryEntry(summary);
-  if (existsSync14(summaryFile)) {
+  if (existsSync16(summaryFile)) {
     appendFileSync(summaryFile, "\n---\n\n" + content);
   } else {
     writeFileSync7(summaryFile, "# Work Summaries\n\n" + content);
@@ -3920,14 +4150,14 @@ function generateSummaryEntry(summary) {
   return lines.join("\n");
 }
 function getHistoryDir(agentId) {
-  return join14(AGENTS_DIR, agentId, "history");
+  return join16(AGENTS_DIR, agentId, "history");
 }
 function logHistory(agentId, action, details) {
   const historyDir = getHistoryDir(agentId);
   mkdirSync7(historyDir, { recursive: true });
   const date = /* @__PURE__ */ new Date();
   const dateStr = date.toISOString().split("T")[0];
-  const historyFile = join14(historyDir, `${dateStr}.log`);
+  const historyFile = join16(historyDir, `${dateStr}.log`);
   const timestamp = date.toISOString();
   const detailsStr = details ? ` ${JSON.stringify(details)}` : "";
   const logLine = `[${timestamp}] ${action}${detailsStr}
@@ -3936,13 +4166,13 @@ function logHistory(agentId, action, details) {
 }
 function searchHistory(agentId, pattern) {
   const historyDir = getHistoryDir(agentId);
-  if (!existsSync14(historyDir)) return [];
+  if (!existsSync16(historyDir)) return [];
   const results = [];
   const regex = new RegExp(pattern, "i");
-  const files = readdirSync11(historyDir).filter((f) => f.endsWith(".log"));
+  const files = readdirSync12(historyDir).filter((f) => f.endsWith(".log"));
   files.sort().reverse();
   for (const file of files) {
-    const content = readFileSync12(join14(historyDir, file), "utf-8");
+    const content = readFileSync14(join16(historyDir, file), "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       if (regex.test(line)) {
@@ -3954,13 +4184,13 @@ function searchHistory(agentId, pattern) {
 }
 function getRecentHistory(agentId, limit = 20) {
   const historyDir = getHistoryDir(agentId);
-  if (!existsSync14(historyDir)) return [];
+  if (!existsSync16(historyDir)) return [];
   const results = [];
-  const files = readdirSync11(historyDir).filter((f) => f.endsWith(".log"));
+  const files = readdirSync12(historyDir).filter((f) => f.endsWith(".log"));
   files.sort().reverse();
   for (const file of files) {
     if (results.length >= limit) break;
-    const content = readFileSync12(join14(historyDir, file), "utf-8");
+    const content = readFileSync14(join16(historyDir, file), "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     for (const line of lines.reverse()) {
       if (results.length >= limit) break;
@@ -3973,28 +4203,28 @@ function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 function getMaterializedDir(agentId) {
-  return join14(AGENTS_DIR, agentId, "materialized");
+  return join16(AGENTS_DIR, agentId, "materialized");
 }
 function listMaterialized(agentId) {
   const dir = getMaterializedDir(agentId);
-  if (!existsSync14(dir)) return [];
-  return readdirSync11(dir).filter((f) => f.endsWith(".md")).map((f) => {
+  if (!existsSync16(dir)) return [];
+  return readdirSync12(dir).filter((f) => f.endsWith(".md")).map((f) => {
     const match = f.match(/^(.+)-(\d+)\.md$/);
     if (!match) return null;
     return {
       tool: match[1],
       timestamp: parseInt(match[2], 10),
-      file: join14(dir, f)
+      file: join16(dir, f)
     };
   }).filter(Boolean);
 }
 function readMaterialized(filepath) {
-  if (!existsSync14(filepath)) return null;
-  return readFileSync12(filepath, "utf-8");
+  if (!existsSync16(filepath)) return null;
+  return readFileSync14(filepath, "utf-8");
 }
 
 // src/cli/commands/work/context.ts
-import { readFileSync as readFileSync13, existsSync as existsSync15 } from "fs";
+import { readFileSync as readFileSync15, existsSync as existsSync17 } from "fs";
 async function contextCommand(action, arg1, arg2, options = {}) {
   const agentId = process.env.PANOPTICON_AGENT_ID || arg1 || "default";
   switch (action) {
@@ -4110,7 +4340,7 @@ History matches for "${pattern}":
     }
     case "materialize": {
       const filepath = arg1;
-      if (filepath && existsSync15(filepath)) {
+      if (filepath && existsSync17(filepath)) {
         const content = readMaterialized(filepath);
         if (content) {
           console.log(content);
@@ -4138,8 +4368,8 @@ History matches for "${pattern}":
         return;
       }
       let text = target;
-      if (existsSync15(target)) {
-        text = readFileSync13(target, "utf-8");
+      if (existsSync17(target)) {
+        text = readFileSync15(target, "utf-8");
       }
       const tokens = estimateTokens(text);
       console.log(`Estimated tokens: ${chalk19.cyan(tokens.toLocaleString())}`);
@@ -4167,8 +4397,8 @@ import chalk20 from "chalk";
 init_esm_shims();
 init_paths();
 init_agents();
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "fs";
+import { join as join17 } from "path";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync3 = promisify3(exec3);
@@ -4177,7 +4407,7 @@ var DEFAULT_CONSECUTIVE_FAILURES = 3;
 var DEFAULT_COOLDOWN_MS = 5 * 60 * 1e3;
 var DEFAULT_CHECK_INTERVAL_MS = 30 * 1e3;
 function getHealthFile(agentId) {
-  return join15(AGENTS_DIR, agentId, "health.json");
+  return join17(AGENTS_DIR, agentId, "health.json");
 }
 function getAgentHealth(agentId) {
   const healthFile = getHealthFile(agentId);
@@ -4189,9 +4419,9 @@ function getAgentHealth(agentId) {
     recoveryCount: 0,
     inCooldown: false
   };
-  if (existsSync16(healthFile)) {
+  if (existsSync18(healthFile)) {
     try {
-      const stored = JSON.parse(readFileSync14(healthFile, "utf-8"));
+      const stored = JSON.parse(readFileSync16(healthFile, "utf-8"));
       return { ...defaultHealth, ...stored };
     } catch {
     }
@@ -4199,7 +4429,7 @@ function getAgentHealth(agentId) {
   return defaultHealth;
 }
 function saveAgentHealth(health) {
-  const dir = join15(AGENTS_DIR, health.agentId);
+  const dir = join17(AGENTS_DIR, health.agentId);
   mkdirSync8(dir, { recursive: true });
   writeFileSync8(getHealthFile(health.agentId), JSON.stringify(health, null, 2));
 }
@@ -4322,9 +4552,9 @@ async function runHealthCheck(config2 = {
     sessions = output.trim().split("\n").filter((s) => s.startsWith("agent-"));
   } catch {
   }
-  if (existsSync16(AGENTS_DIR)) {
-    const { readdirSync: readdirSync21 } = await import("fs");
-    const dirs = readdirSync21(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("agent-")).map((d) => d.name);
+  if (existsSync18(AGENTS_DIR)) {
+    const { readdirSync: readdirSync22 } = await import("fs");
+    const dirs = readdirSync22(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("agent-")).map((d) => d.name);
     for (const dir of dirs) {
       if (!sessions.includes(dir)) {
         sessions.push(dir);
@@ -4560,15 +4790,15 @@ init_esm_shims();
 import chalk21 from "chalk";
 import ora11 from "ora";
 import inquirer3 from "inquirer";
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
-import { join as join17, dirname as dirname6 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
+import { join as join19, dirname as dirname6 } from "path";
 import { homedir as homedir8 } from "os";
 import { LinearClient } from "@linear/sdk";
 
 // src/lib/reopen.ts
 init_esm_shims();
-import { existsSync as existsSync17, readFileSync as readFileSync15, appendFileSync as appendFileSync2 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync17, appendFileSync as appendFileSync2 } from "fs";
+import { join as join18 } from "path";
 
 // src/dashboard/server/review-status.ts
 init_esm_shims();
@@ -4634,9 +4864,9 @@ function reopenWorkspaceState(issueId, workspacePath, options = {}) {
       result.queueItemsRemoved[specialistName] = removed;
     }
   }
-  const statePath = join16(workspacePath, ".planning", "STATE.md");
-  if (existsSync17(statePath)) {
-    const previousContent = readFileSync15(statePath, "utf-8");
+  const statePath = join18(workspacePath, ".planning", "STATE.md");
+  if (existsSync19(statePath)) {
+    const previousContent = readFileSync17(statePath, "utf-8");
     const lastStatusMatch = previousContent.match(/\*\*STATUS:\s*([^*\n]+)\*\*/);
     const previousStatus = lastStatusMatch ? lastStatusMatch[1].trim() : "Unknown";
     const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -4672,9 +4902,9 @@ function reopenWorkspaceState(issueId, workspacePath, options = {}) {
 // src/cli/commands/work/reopen.ts
 init_projects();
 function getLinearApiKey5() {
-  const envFile = join17(homedir8(), ".panopticon.env");
-  if (existsSync18(envFile)) {
-    const content = readFileSync16(envFile, "utf-8");
+  const envFile = join19(homedir8(), ".panopticon.env");
+  if (existsSync20(envFile)) {
+    const content = readFileSync18(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -4747,15 +4977,15 @@ function findLocalWorkspace2(issueId, startDir) {
   const normalizedId = issueId.toLowerCase();
   const resolved = resolveProjectFromIssue(issueId, []);
   if (resolved) {
-    const workspacePath = join17(resolved.projectPath, "workspaces", `feature-${normalizedId}`);
-    if (existsSync18(workspacePath)) return workspacePath;
+    const workspacePath = join19(resolved.projectPath, "workspaces", `feature-${normalizedId}`);
+    if (existsSync20(workspacePath)) return workspacePath;
   }
   let dir = startDir ?? process.cwd();
   for (let i = 0; i < 10; i++) {
-    const workspacesDir = join17(dir, "workspaces");
-    if (existsSync18(workspacesDir)) {
-      const workspacePath = join17(workspacesDir, `feature-${normalizedId}`);
-      if (existsSync18(workspacePath)) return workspacePath;
+    const workspacesDir = join19(dir, "workspaces");
+    if (existsSync20(workspacesDir)) {
+      const workspacePath = join19(workspacesDir, `feature-${normalizedId}`);
+      if (existsSync20(workspacePath)) return workspacePath;
     }
     const parent = dirname6(dir);
     if (parent === dir) break;
@@ -4881,8 +5111,22 @@ Previous state: ${issue.state}`
     console.log("");
     console.log(chalk21.green(`\u2713 ${issue.identifier} reopened and ready for re-work`));
     console.log("");
-    console.log(chalk21.dim("Start the agent to resume implementation:"));
-    console.log(`  pan work ${id}`);
+    try {
+      const { getAgentState: getAgentState2 } = await import("../agents-E43Y3HNU.js");
+      const agentId = `agent-${id.toLowerCase()}`;
+      const agentState = getAgentState2(agentId);
+      const agentRunning = agentState?.status === "active" || agentState?.status === "running";
+      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>"`);
+      } else {
+        console.log(chalk21.dim("Start the agent to resume implementation:"));
+        console.log(`  pan work issue ${id}`);
+      }
+    } catch {
+      console.log(chalk21.dim("Start the agent to resume implementation:"));
+      console.log(`  pan work issue ${id}`);
+    }
     console.log("");
   } catch (error) {
     if (spinner.isSpinning) spinner.fail();
@@ -4985,8 +5229,8 @@ init_agents();
 init_tmux();
 import chalk24 from "chalk";
 import { homedir as homedir9 } from "os";
-import { join as join18 } from "path";
-import { existsSync as existsSync19, rmSync, readFileSync as readFileSync17 } from "fs";
+import { join as join20 } from "path";
+import { existsSync as existsSync21, rmSync, readFileSync as readFileSync19 } from "fs";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
 var execAsync4 = promisify4(exec4);
@@ -5075,10 +5319,10 @@ async function wipeCommand(issueId, options) {
     }
   }
   const agentDirs = [
-    join18(homedir9(), ".panopticon", "agents", `agent-${issueLower}`)
+    join20(homedir9(), ".panopticon", "agents", `agent-${issueLower}`)
   ];
   for (const dir of agentDirs) {
-    if (existsSync19(dir)) {
+    if (existsSync21(dir)) {
       rmSync(dir, { recursive: true, force: true });
       cleanupLog.push(`Deleted agent state: ${dir}`);
       console.log(chalk24.green(`  \u2713 Deleted agent state: ${dir.replace(homedir9(), "~")}`));
@@ -5086,11 +5330,11 @@ async function wipeCommand(issueId, options) {
   }
   let projectPath;
   const prefix = issueId.split("-")[0].toUpperCase();
-  const projectsYamlPath = join18(homedir9(), ".panopticon", "projects.yaml");
-  if (existsSync19(projectsYamlPath)) {
+  const projectsYamlPath = join20(homedir9(), ".panopticon", "projects.yaml");
+  if (existsSync21(projectsYamlPath)) {
     try {
       const yaml2 = await import("js-yaml");
-      const projectsConfig = yaml2.load(readFileSync17(projectsYamlPath, "utf-8"));
+      const projectsConfig = yaml2.load(readFileSync19(projectsYamlPath, "utf-8"));
       for (const [, config2] of Object.entries(projectsConfig.projects || {})) {
         const projConfig = config2;
         if (projConfig.linear_team?.toUpperCase() === prefix) {
@@ -5102,19 +5346,19 @@ async function wipeCommand(issueId, options) {
     }
   }
   if (options.workspace && projectPath) {
-    const workspacePath = join18(projectPath, "workspaces", `feature-${issueLower}`);
-    if (existsSync19(workspacePath)) {
+    const workspacePath = join20(projectPath, "workspaces", `feature-${issueLower}`);
+    if (existsSync21(workspacePath)) {
       try {
         const gitDirs = ["api", "frontend", "fe", "."];
         for (const gitDir of gitDirs) {
-          const gitPath = join18(projectPath, gitDir);
-          if (existsSync19(join18(gitPath, ".git"))) {
+          const gitPath = join20(projectPath, gitDir);
+          if (existsSync21(join20(gitPath, ".git"))) {
             await execAsync4(`cd "${gitPath}" && git worktree remove "${workspacePath}" --force 2>/dev/null || true`);
           }
         }
       } catch (e) {
       }
-      if (existsSync19(workspacePath)) {
+      if (existsSync21(workspacePath)) {
         rmSync(workspacePath, { recursive: true, force: true });
       }
       cleanupLog.push(`Deleted workspace: ${workspacePath}`);
@@ -5172,14 +5416,14 @@ import ora12 from "ora";
 
 // src/lib/shadow-utils.ts
 init_esm_shims();
-import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
+import { join as join21 } from "path";
 import { homedir as homedir10 } from "os";
 import chalk25 from "chalk";
 function getLinearApiKey6() {
-  const envFile = join19(homedir10(), ".panopticon.env");
-  if (existsSync20(envFile)) {
-    const content = readFileSync18(envFile, "utf-8");
+  const envFile = join21(homedir10(), ".panopticon.env");
+  if (existsSync22(envFile)) {
+    const content = readFileSync20(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -5278,10 +5522,10 @@ init_esm_shims();
 import chalk27 from "chalk";
 import ora13 from "ora";
 import inquirer4 from "inquirer";
-import { existsSync as existsSync21, readFileSync as readFileSync19, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9 } from "fs";
-import { join as join20, dirname as dirname7 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync21, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9 } from "fs";
+import { join as join22, dirname as dirname7 } from "path";
 import { homedir as homedir11 } from "os";
-var SYNC_QUEUE_FILE = join20(homedir11(), ".panopticon", "sync-queue.json");
+var SYNC_QUEUE_FILE = join22(homedir11(), ".panopticon", "sync-queue.json");
 async function syncToLinear(apiKey, issueId, targetState) {
   try {
     const { LinearClient: LinearClient2 } = await import("@linear/sdk");
@@ -5453,11 +5697,11 @@ async function syncCommand2(id, options = {}) {
   }
 }
 function loadSyncQueue() {
-  if (!existsSync21(SYNC_QUEUE_FILE)) {
+  if (!existsSync23(SYNC_QUEUE_FILE)) {
     return [];
   }
   try {
-    const content = readFileSync19(SYNC_QUEUE_FILE, "utf-8");
+    const content = readFileSync21(SYNC_QUEUE_FILE, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     console.error(chalk27.yellow("Warning: Failed to load sync queue"));
@@ -5466,7 +5710,7 @@ function loadSyncQueue() {
 }
 function saveSyncQueue(queue) {
   const dir = dirname7(SYNC_QUEUE_FILE);
-  if (!existsSync21(dir)) {
+  if (!existsSync23(dir)) {
     mkdirSync9(dir, { recursive: true });
   }
   try {
@@ -5593,8 +5837,8 @@ async function refreshCommand(id, options = {}) {
 init_esm_shims();
 init_tldr_daemon();
 import chalk29 from "chalk";
-import { existsSync as existsSync22, readdirSync as readdirSync13, readFileSync as readFileSync20, statSync as statSync4 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync14, readFileSync as readFileSync22, statSync as statSync5 } from "fs";
+import { join as join23 } from "path";
 async function tldrCommand(action, workspace, options = {}) {
   switch (action) {
     case "status":
@@ -5617,19 +5861,19 @@ async function tldrCommand(action, workspace, options = {}) {
 }
 async function statusCommand2(options) {
   const projectRoot = process.cwd();
-  const venvPath = join21(projectRoot, ".venv");
+  const venvPath = join23(projectRoot, ".venv");
   const results = [];
-  if (existsSync22(venvPath)) {
+  if (existsSync24(venvPath)) {
     const service = getTldrDaemonService(projectRoot, venvPath);
     const status = await service.getStatus();
-    const tldrPath = join21(projectRoot, ".tldr");
+    const tldrPath = join23(projectRoot, ".tldr");
     let indexAge = "N/A";
     let fileCount = "N/A";
-    if (existsSync22(tldrPath)) {
+    if (existsSync24(tldrPath)) {
       try {
-        const langPath = join21(tldrPath, "languages.json");
-        if (existsSync22(langPath)) {
-          const langData = JSON.parse(readFileSync20(langPath, "utf-8"));
+        const langPath = join23(tldrPath, "languages.json");
+        if (existsSync24(langPath)) {
+          const langData = JSON.parse(readFileSync22(langPath, "utf-8"));
           if (langData.timestamp) {
             const ageMs = Date.now() - langData.timestamp * 1e3;
             const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
@@ -5637,14 +5881,14 @@ async function statusCommand2(options) {
           }
         }
         if (indexAge === "N/A") {
-          const stats = statSync4(tldrPath);
+          const stats = statSync5(tldrPath);
           const ageMs = Date.now() - stats.mtimeMs;
           const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
           indexAge = ageDays === 0 ? "today" : `${ageDays}d ago`;
         }
-        const cgPath = join21(tldrPath, "cache", "call_graph.json");
-        if (existsSync22(cgPath)) {
-          const cg = JSON.parse(readFileSync20(cgPath, "utf-8"));
+        const cgPath = join23(tldrPath, "cache", "call_graph.json");
+        if (existsSync24(cgPath)) {
+          const cg = JSON.parse(readFileSync22(cgPath, "utf-8"));
           if (Array.isArray(cg.edges)) {
             const files = /* @__PURE__ */ new Set();
             for (const e of cg.edges) {
@@ -5666,23 +5910,23 @@ async function statusCommand2(options) {
       fileCount
     });
   }
-  const workspacesDir = join21(projectRoot, "workspaces");
-  if (existsSync22(workspacesDir)) {
-    const workspaces = readdirSync13(workspacesDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("feature-"));
+  const workspacesDir = join23(projectRoot, "workspaces");
+  if (existsSync24(workspacesDir)) {
+    const workspaces = readdirSync14(workspacesDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("feature-"));
     for (const ws of workspaces) {
-      const wsPath = join21(workspacesDir, ws.name);
-      const wsVenvPath = join21(wsPath, ".venv");
-      if (existsSync22(wsVenvPath)) {
+      const wsPath = join23(workspacesDir, ws.name);
+      const wsVenvPath = join23(wsPath, ".venv");
+      if (existsSync24(wsVenvPath)) {
         const service = getTldrDaemonService(wsPath, wsVenvPath);
         const status = await service.getStatus();
-        const tldrPath = join21(wsPath, ".tldr");
+        const tldrPath = join23(wsPath, ".tldr");
         let indexAge = "N/A";
         let fileCount = "N/A";
-        if (existsSync22(tldrPath)) {
+        if (existsSync24(tldrPath)) {
           try {
-            const langPath = join21(tldrPath, "languages.json");
-            if (existsSync22(langPath)) {
-              const langData = JSON.parse(readFileSync20(langPath, "utf-8"));
+            const langPath = join23(tldrPath, "languages.json");
+            if (existsSync24(langPath)) {
+              const langData = JSON.parse(readFileSync22(langPath, "utf-8"));
               if (langData.timestamp) {
                 const ageMs = Date.now() - langData.timestamp * 1e3;
                 const ageHours = Math.floor(ageMs / (1e3 * 60 * 60));
@@ -5690,14 +5934,14 @@ async function statusCommand2(options) {
               }
             }
             if (indexAge === "N/A") {
-              const stats = statSync4(tldrPath);
+              const stats = statSync5(tldrPath);
               const ageMs = Date.now() - stats.mtimeMs;
               const ageHours = Math.floor(ageMs / (1e3 * 60 * 60));
               indexAge = ageHours === 0 ? "now" : ageHours < 24 ? `${ageHours}h ago` : `${Math.floor(ageHours / 24)}d ago`;
             }
-            const cgPath = join21(tldrPath, "cache", "call_graph.json");
-            if (existsSync22(cgPath)) {
-              const cg = JSON.parse(readFileSync20(cgPath, "utf-8"));
+            const cgPath = join23(tldrPath, "cache", "call_graph.json");
+            if (existsSync24(cgPath)) {
+              const cg = JSON.parse(readFileSync22(cgPath, "utf-8"));
               if (Array.isArray(cg.edges)) {
                 const files = /* @__PURE__ */ new Set();
                 for (const e of cg.edges) {
@@ -5747,13 +5991,13 @@ async function statusCommand2(options) {
 async function startCommand(workspace, options) {
   const projectRoot = process.cwd();
   if (workspace) {
-    const wsPath = join21(projectRoot, "workspaces", workspace);
-    const venvPath = join21(wsPath, ".venv");
-    if (!existsSync22(wsPath)) {
+    const wsPath = join23(projectRoot, "workspaces", workspace);
+    const venvPath = join23(wsPath, ".venv");
+    if (!existsSync24(wsPath)) {
       console.error(chalk29.red(`Error: Workspace not found: ${workspace}`));
       process.exit(1);
     }
-    if (!existsSync22(venvPath)) {
+    if (!existsSync24(venvPath)) {
       console.error(chalk29.red(`Error: No .venv found in workspace: ${workspace}`));
       console.error(chalk29.dim("Workspace needs to be recreated with TLDR support"));
       process.exit(1);
@@ -5764,8 +6008,8 @@ async function startCommand(workspace, options) {
       console.log(chalk29.green(`\u2713 Started TLDR daemon for ${workspace}`));
     }
   } else {
-    const venvPath = join21(projectRoot, ".venv");
-    if (!existsSync22(venvPath)) {
+    const venvPath = join23(projectRoot, ".venv");
+    if (!existsSync24(venvPath)) {
       console.error(chalk29.red("Error: No .venv found in project root"));
       console.error(chalk29.dim("Run `pan setup` to configure TLDR"));
       process.exit(1);
@@ -5780,13 +6024,13 @@ async function startCommand(workspace, options) {
 async function stopCommand(workspace, options) {
   const projectRoot = process.cwd();
   if (workspace) {
-    const wsPath = join21(projectRoot, "workspaces", workspace);
-    const venvPath = join21(wsPath, ".venv");
-    if (!existsSync22(wsPath)) {
+    const wsPath = join23(projectRoot, "workspaces", workspace);
+    const venvPath = join23(wsPath, ".venv");
+    if (!existsSync24(wsPath)) {
       console.error(chalk29.red(`Error: Workspace not found: ${workspace}`));
       process.exit(1);
     }
-    if (!existsSync22(venvPath)) {
+    if (!existsSync24(venvPath)) {
       console.error(chalk29.red(`Error: No .venv found in workspace: ${workspace}`));
       process.exit(1);
     }
@@ -5796,8 +6040,8 @@ async function stopCommand(workspace, options) {
       console.log(chalk29.green(`\u2713 Stopped TLDR daemon for ${workspace}`));
     }
   } else {
-    const venvPath = join21(projectRoot, ".venv");
-    if (!existsSync22(venvPath)) {
+    const venvPath = join23(projectRoot, ".venv");
+    if (!existsSync24(venvPath)) {
       console.error(chalk29.red("Error: No .venv found in project root"));
       process.exit(1);
     }
@@ -5811,13 +6055,13 @@ async function stopCommand(workspace, options) {
 async function warmCommand(workspace, options) {
   const projectRoot = process.cwd();
   if (workspace) {
-    const wsPath = join21(projectRoot, "workspaces", workspace);
-    const venvPath = join21(wsPath, ".venv");
-    if (!existsSync22(wsPath)) {
+    const wsPath = join23(projectRoot, "workspaces", workspace);
+    const venvPath = join23(wsPath, ".venv");
+    if (!existsSync24(wsPath)) {
       console.error(chalk29.red(`Error: Workspace not found: ${workspace}`));
       process.exit(1);
     }
-    if (!existsSync22(venvPath)) {
+    if (!existsSync24(venvPath)) {
       console.error(chalk29.red(`Error: No .venv found in workspace: ${workspace}`));
       process.exit(1);
     }
@@ -5831,8 +6075,8 @@ async function warmCommand(workspace, options) {
       console.log(chalk29.green(`\u2713 Index warming complete for ${workspace}`));
     }
   } else {
-    const venvPath = join21(projectRoot, ".venv");
-    if (!existsSync22(venvPath)) {
+    const venvPath = join23(projectRoot, ".venv");
+    if (!existsSync24(venvPath)) {
       console.error(chalk29.red("Error: No .venv found in project root"));
       console.error(chalk29.dim("Run `pan setup` to configure TLDR"));
       process.exit(1);
@@ -5915,8 +6159,8 @@ async function syncMainCommand(id) {
 // src/cli/commands/work/close-out.ts
 init_esm_shims();
 import chalk31 from "chalk";
-import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync25 } from "fs";
+import { join as join28 } from "path";
 import { homedir as homedir13 } from "os";
 
 // src/lib/lifecycle/index.ts
@@ -5924,8 +6168,8 @@ init_esm_shims();
 
 // src/lib/lifecycle/types.ts
 init_esm_shims();
-import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync23 } from "fs";
+import { join as join24 } from "path";
 import { homedir as homedir12 } from "os";
 function stepOk(step, details) {
   return { step, success: true, skipped: false, details };
@@ -5938,9 +6182,9 @@ function stepFailed(step, error, details) {
 }
 function getLinearApiKey7() {
   if (process.env.LINEAR_API_KEY) return process.env.LINEAR_API_KEY;
-  const envFile = join22(homedir12(), ".panopticon.env");
-  if (existsSync23(envFile)) {
-    const content = readFileSync21(envFile, "utf-8");
+  const envFile = join24(homedir12(), ".panopticon.env");
+  if (existsSync25(envFile)) {
+    const content = readFileSync23(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -5950,20 +6194,20 @@ function getLinearApiKey7() {
 // src/lib/lifecycle/archive-planning.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync24, mkdirSync as mkdirSync10, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
-import { join as join23, dirname as dirname8 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync10, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
+import { join as join25, dirname as dirname8 } from "path";
 import { exec as exec5 } from "child_process";
 import { promisify as promisify5 } from "util";
 var execAsync5 = promisify5(exec5);
 function findWorkspacePath(projectPath, issueLower) {
   const candidates = [
-    join23(projectPath, "workspaces", `feature-${issueLower}`),
-    join23(projectPath, "workspaces", issueLower),
-    join23(projectPath, ".worktrees", issueLower),
-    join23(dirname8(projectPath), `feature-${issueLower}`)
+    join25(projectPath, "workspaces", `feature-${issueLower}`),
+    join25(projectPath, "workspaces", issueLower),
+    join25(projectPath, ".worktrees", issueLower),
+    join25(dirname8(projectPath), `feature-${issueLower}`)
   ];
   for (const p of candidates) {
-    if (existsSync24(p)) return p;
+    if (existsSync26(p)) return p;
   }
   return null;
 }
@@ -5971,28 +6215,28 @@ async function movePrd(ctx, opts = {}) {
   const { pushToRemote = true } = opts;
   const issueLower = ctx.issueId.toLowerCase();
   const step = "archive-planning:move-prd";
-  const completedPrdPath = join23(
+  const completedPrdPath = join25(
     ctx.projectPath,
     PROJECT_DOCS_SUBDIR,
     PROJECT_PRDS_SUBDIR,
     PROJECT_PRDS_COMPLETED_SUBDIR,
     `${issueLower}-plan.md`
   );
-  const activePrdPath = join23(
+  const activePrdPath = join25(
     ctx.projectPath,
     PROJECT_DOCS_SUBDIR,
     PROJECT_PRDS_SUBDIR,
     PROJECT_PRDS_ACTIVE_SUBDIR,
     `${issueLower}-plan.md`
   );
-  if (existsSync24(completedPrdPath)) {
+  if (existsSync26(completedPrdPath)) {
     return stepSkipped(step, ["PRD already in completed/"]);
   }
-  if (!existsSync24(activePrdPath)) {
+  if (!existsSync26(activePrdPath)) {
     return stepSkipped(step, ["No PRD found in active/ (may not have had one)"]);
   }
   const completedDir = dirname8(completedPrdPath);
-  if (!existsSync24(completedDir)) {
+  if (!existsSync26(completedDir)) {
     mkdirSync10(completedDir, { recursive: true });
   }
   try {
@@ -6006,7 +6250,7 @@ async function movePrd(ctx, opts = {}) {
   }
   try {
     cpSync2(activePrdPath, completedPrdPath);
-    if (!existsSync24(completedPrdPath)) {
+    if (!existsSync26(completedPrdPath)) {
       return stepFailed(step, "PRD copy appeared to succeed but file not found at destination");
     }
     return stepOk(step, ["Copied PRD to completed/ (git mv failed, plain copy succeeded)"]);
@@ -6018,14 +6262,14 @@ async function archiveWorkspaceArtifacts(ctx) {
   const issueLower = ctx.issueId.toLowerCase();
   const step = "archive-planning:archive-artifacts";
   const workspacePath = findWorkspacePath(ctx.projectPath, issueLower);
-  if (!workspacePath || !existsSync24(workspacePath)) {
+  if (!workspacePath || !existsSync26(workspacePath)) {
     return stepSkipped(step, ["No workspace found to archive"]);
   }
   try {
-    let archiveDir = join23(ARCHIVES_DIR, issueLower);
-    if (existsSync24(archiveDir)) {
+    let archiveDir = join25(ARCHIVES_DIR, issueLower);
+    if (existsSync26(archiveDir)) {
       let version = 1;
-      while (existsSync24(`${archiveDir}.${version}`)) {
+      while (existsSync26(`${archiveDir}.${version}`)) {
         version++;
       }
       const rotatedDir = `${archiveDir}.${version}`;
@@ -6034,24 +6278,24 @@ async function archiveWorkspaceArtifacts(ctx) {
     }
     mkdirSync10(archiveDir, { recursive: true });
     const details = [];
-    const feedbackDir = join23(workspacePath, ".planning", "feedback");
-    if (existsSync24(feedbackDir)) {
-      cpSync2(feedbackDir, join23(archiveDir, "feedback"), { recursive: true });
+    const feedbackDir = join25(workspacePath, ".planning", "feedback");
+    if (existsSync26(feedbackDir)) {
+      cpSync2(feedbackDir, join25(archiveDir, "feedback"), { recursive: true });
       details.push("Archived feedback/");
     }
-    const stateMd = join23(workspacePath, ".planning", "STATE.md");
-    if (existsSync24(stateMd)) {
-      cpSync2(stateMd, join23(archiveDir, "STATE.md"));
+    const stateMd = join25(workspacePath, ".planning", "STATE.md");
+    if (existsSync26(stateMd)) {
+      cpSync2(stateMd, join25(archiveDir, "STATE.md"));
       details.push("Archived STATE.md");
     }
-    const beadsDir = join23(workspacePath, ".planning", "beads");
-    if (existsSync24(beadsDir)) {
-      cpSync2(beadsDir, join23(archiveDir, "beads"), { recursive: true });
+    const beadsDir = join25(workspacePath, ".planning", "beads");
+    if (existsSync26(beadsDir)) {
+      cpSync2(beadsDir, join25(archiveDir, "beads"), { recursive: true });
       details.push("Archived beads/");
     }
-    const prdMd = join23(workspacePath, ".planning", "PRD.md");
-    if (existsSync24(prdMd)) {
-      cpSync2(prdMd, join23(archiveDir, "PRD.md"));
+    const prdMd = join25(workspacePath, ".planning", "PRD.md");
+    if (existsSync26(prdMd)) {
+      cpSync2(prdMd, join25(archiveDir, "PRD.md"));
       details.push("Archived workspace PRD.md");
     }
     details.push(`Archived to ${archiveDir}`);
@@ -6316,8 +6560,8 @@ async function applyLabelLinear(ctx, apiKey) {
 init_esm_shims();
 init_paths();
 init_tmux();
-import { existsSync as existsSync25, rmSync as rmSync3, unlinkSync as unlinkSync2 } from "fs";
-import { join as join24, basename as basename4 } from "path";
+import { existsSync as existsSync27, rmSync as rmSync3, unlinkSync as unlinkSync2 } from "fs";
+import { join as join26, basename as basename5 } from "path";
 import { exec as exec7 } from "child_process";
 import { promisify as promisify7 } from "util";
 var execAsync7 = promisify7(exec7);
@@ -6347,8 +6591,8 @@ async function killTmuxSessions(issueLower) {
 }
 async function stopTldrDaemon(workspacePath) {
   const step = "teardown:tldr-daemon";
-  const venvPath = join24(workspacePath, ".venv");
-  if (!existsSync25(venvPath)) {
+  const venvPath = join26(workspacePath, ".venv");
+  if (!existsSync27(venvPath)) {
     return stepSkipped(step, ["No .venv found"]);
   }
   try {
@@ -6363,7 +6607,7 @@ async function stopTldrDaemon(workspacePath) {
 async function stopDocker(workspacePath, projectName, issueLower) {
   const step = "teardown:docker";
   try {
-    const { stopWorkspaceDocker } = await import("../workspace-manager-KLHUCIZV.js");
+    const { stopWorkspaceDocker } = await import("../workspace-manager-IE4JL2JP.js");
     await stopWorkspaceDocker(workspacePath, projectName, issueLower);
     return stepOk(step, ["Stopped Docker containers"]);
   } catch {
@@ -6372,7 +6616,7 @@ async function stopDocker(workspacePath, projectName, issueLower) {
 }
 async function removeWorktree(projectPath, workspacePath) {
   const step = "teardown:worktree";
-  if (!existsSync25(workspacePath)) {
+  if (!existsSync27(workspacePath)) {
     return stepSkipped(step, ["Workspace directory does not exist"]);
   }
   try {
@@ -6390,12 +6634,12 @@ async function removeWorktree(projectPath, workspacePath) {
 async function removeAgentState(issueLower) {
   const step = "teardown:agent-state";
   const dirs = [
-    join24(AGENTS_DIR, `agent-${issueLower}`),
-    join24(AGENTS_DIR, `planning-${issueLower}`)
+    join26(AGENTS_DIR, `agent-${issueLower}`),
+    join26(AGENTS_DIR, `planning-${issueLower}`)
   ];
   let removed = 0;
   for (const dir of dirs) {
-    if (existsSync25(dir)) {
+    if (existsSync27(dir)) {
       rmSync3(dir, { recursive: true, force: true });
       removed++;
     }
@@ -6438,8 +6682,8 @@ async function clearShadowState(issueId) {
 }
 async function clearLegacyPlanningDir(projectPath, issueLower) {
   const step = "teardown:legacy-planning-dir";
-  const legacyDir = join24(projectPath, ".planning", issueLower);
-  if (existsSync25(legacyDir)) {
+  const legacyDir = join26(projectPath, ".planning", issueLower);
+  if (existsSync27(legacyDir)) {
     rmSync3(legacyDir, { recursive: true, force: true });
     return stepOk(step, [`Deleted legacy planning dir: ${legacyDir}`]);
   }
@@ -6447,8 +6691,8 @@ async function clearLegacyPlanningDir(projectPath, issueLower) {
 }
 async function clearPlanningMarker(workspacePath) {
   const step = "teardown:planning-marker";
-  const markerPath = join24(workspacePath, ".planning", ".planning-complete");
-  if (existsSync25(markerPath)) {
+  const markerPath = join26(workspacePath, ".planning", ".planning-complete");
+  if (existsSync27(markerPath)) {
     unlinkSync2(markerPath);
     return stepOk(step, ["Cleared .planning-complete marker"]);
   }
@@ -6457,7 +6701,7 @@ async function clearPlanningMarker(workspacePath) {
 function buildPlaceholders(ctx, opts, workspacePath) {
   const issueLower = ctx.issueId.toLowerCase();
   const featureFolder = `feature-${issueLower}`;
-  const projName = opts.projectName || ctx.projectName || basename4(ctx.projectPath);
+  const projName = opts.projectName || ctx.projectName || basename5(ctx.projectPath);
   const domain = opts.workspaceConfig?.dns?.domain || "localhost";
   return {
     FEATURE_NAME: issueLower,
@@ -6499,7 +6743,7 @@ async function teardownWorkspace(ctx, opts = {}) {
   results.push(await killTmuxSessions(issueLower));
   results.push(await clearShadowState(ctx.issueId));
   results.push(await clearLegacyPlanningDir(ctx.projectPath, issueLower));
-  if (workspacePath && existsSync25(workspacePath)) {
+  if (workspacePath && existsSync27(workspacePath)) {
     if (shouldDeleteWorkspace) {
       results.push(await stopTldrDaemon(workspacePath));
     }
@@ -6538,8 +6782,8 @@ var execAsync8 = promisify8(exec8);
 // src/lib/lifecycle/workflows.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync26, readFileSync as readFileSync22 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync24 } from "fs";
+import { join as join27 } from "path";
 import { exec as exec9 } from "child_process";
 import { promisify as promisify9 } from "util";
 var execAsync9 = promisify9(exec9);
@@ -6584,20 +6828,34 @@ async function verifyBranchMerged(ctx) {
   const issueLower = ctx.issueId.toLowerCase();
   const branchName = `feature/${issueLower}`;
   try {
+    try {
+      const { loadReviewStatuses: loadReviewStatuses3 } = await import("../review-status-EPFG4XM7.js");
+      const statuses = loadReviewStatuses3();
+      const issueKey = ctx.issueId.toUpperCase();
+      if (statuses[issueKey]?.mergeStatus === "merged") {
+        return stepOk(step, ["Merge specialist confirmed merge completed"]);
+      }
+    } catch {
+    }
     const { stdout: branchExists } = await execAsync9(
       `git branch --list "${branchName}" 2>/dev/null || true`,
       { cwd: ctx.projectPath, encoding: "utf-8" }
     );
     if (branchExists.trim()) {
-      const { stdout: unmerged } = await execAsync9(
-        `git log main..${branchName} --oneline 2>/dev/null || true`,
-        { cwd: ctx.projectPath, encoding: "utf-8" }
-      );
-      if (unmerged.trim()) {
-        const count = unmerged.trim().split("\n").length;
+      try {
+        await execAsync9(
+          `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(
+          `git log main..${branchName} --oneline 2>/dev/null || true`,
+          { cwd: ctx.projectPath, encoding: "utf-8" }
+        );
+        const count = unmerged.trim() ? unmerged.trim().split("\n").length : 0;
         return stepFailed(step, `${count} unmerged commit(s) on ${branchName}. Merge before closing out.`);
       }
-      return stepOk(step, ["All commits merged to main"]);
     }
     const { stdout: remoteBranch } = await execAsync9(
       `git ls-remote --heads origin "${branchName}" 2>/dev/null || true`,
@@ -6606,15 +6864,20 @@ async function verifyBranchMerged(ctx) {
     if (remoteBranch.trim()) {
       await execAsync9(`git fetch origin ${branchName}`, { cwd: ctx.projectPath }).catch(() => {
       });
-      const { stdout: remoteUnmerged } = await execAsync9(
-        `git log main..origin/${branchName} --oneline 2>/dev/null || true`,
-        { cwd: ctx.projectPath, encoding: "utf-8" }
-      );
-      if (remoteUnmerged.trim()) {
-        const count = remoteUnmerged.trim().split("\n").length;
+      try {
+        await execAsync9(
+          `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(
+          `git log main..origin/${branchName} --oneline 2>/dev/null || true`,
+          { cwd: ctx.projectPath, encoding: "utf-8" }
+        );
+        const count = remoteUnmerged.trim() ? remoteUnmerged.trim().split("\n").length : 0;
         return stepFailed(step, `${count} unmerged commit(s) on remote ${branchName}.`);
       }
-      return stepOk(step, ["Remote branch fully merged"]);
     }
     return stepOk(step, ["Branch already cleaned up (squash-merged)"]);
   } catch (err) {
@@ -6629,9 +6892,9 @@ async function clearReviewStatusStep(issueId) {
     return stepOk(step, ["Review status cleared"]);
   } catch {
     try {
-      const statusFile = join25(PANOPTICON_HOME, "review-status.json");
-      if (existsSync26(statusFile)) {
-        const data = JSON.parse(readFileSync22(statusFile, "utf-8"));
+      const statusFile = join27(PANOPTICON_HOME, "review-status.json");
+      if (existsSync28(statusFile)) {
+        const data = JSON.parse(readFileSync24(statusFile, "utf-8"));
         const upperKey = issueId.toUpperCase();
         if (data[upperKey]) {
           delete data[upperKey];
@@ -6649,9 +6912,9 @@ async function clearReviewStatusStep(issueId) {
 // src/cli/commands/work/close-out.ts
 init_projects();
 function getGitHubConfig2() {
-  const envFile = join26(homedir13(), ".panopticon.env");
-  if (!existsSync27(envFile)) return null;
-  const content = readFileSync23(envFile, "utf-8");
+  const envFile = join28(homedir13(), ".panopticon.env");
+  if (!existsSync29(envFile)) return null;
+  const content = readFileSync25(envFile, "utf-8");
   const reposMatch = content.match(/GITHUB_REPOS=(.+)/);
   if (!reposMatch) return null;
   const repoStr = reposMatch[1].trim();
@@ -6758,13 +7021,13 @@ Running close-out for ${issueUpper}...
 // src/cli/commands/work/linear-states.ts
 init_esm_shims();
 import chalk32 from "chalk";
-import { readFileSync as readFileSync24, existsSync as existsSync28 } from "fs";
+import { readFileSync as readFileSync26, existsSync as existsSync30 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join27 } from "path";
+import { join as join29 } from "path";
 function getLinearApiKey8() {
-  const envFile = join27(homedir14(), ".panopticon.env");
-  if (existsSync28(envFile)) {
-    const content = readFileSync24(envFile, "utf-8");
+  const envFile = join29(homedir14(), ".panopticon.env");
+  if (existsSync30(envFile)) {
+    const content = readFileSync26(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -6910,7 +7173,7 @@ async function cleanupStatesCommand(options) {
 function registerWorkCommands(program2) {
   const work = program2.command("work").description("Agent and work management");
   work.command("issue <id>").description("Spawn agent for Linear issue").option("--model <model>", "Model to use (sonnet/opus/haiku/kimi-k2.5/etc) - defaults to Cloister config").option("--dry-run", "Show what would be created").option("--shadow", "Enable shadow mode (track status locally, don't update tracker)").option("--no-shadow", "Disable shadow mode (override config/env settings)").option("--remote", "Use remote workspace (exe.dev)").option("--local", "Use local workspace (explicit override)").option("--phase <phase>", "Work phase for model routing (exploration/implementation/documentation/review-response)").action(issueCommand);
-  work.command("status").description("Show all running agents").option("--json", "Output as JSON").action(statusCommand);
+  work.command("status").description("Show all running agents").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);
   work.command("tell <id> <message>").description("Send message to running agent").action(tellCommand);
   work.command("kill <id>").description("Kill an agent").option("--force", "Kill without confirmation").action(killCommand);
   work.command("pending").description("Show completed work awaiting review").action(pendingCommand);
@@ -6953,8 +7216,8 @@ function registerWorkCommands(program2) {
 init_esm_shims();
 import chalk33 from "chalk";
 import ora16 from "ora";
-import { existsSync as existsSync29, writeFileSync as writeFileSync10, rmSync as rmSync4, readFileSync as readFileSync25, realpathSync } from "fs";
-import { join as join28, basename as basename5 } from "path";
+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";
 
 // src/lib/worktree.ts
 init_esm_shims();
@@ -7052,8 +7315,8 @@ async function initializeWorkspaceBeads(workspacePath, issueId) {
       const match = stdout.match(/([a-z]+-[a-z0-9]+)/);
       return { success: true, beadId: match?.[1] };
     } else {
-      const beadsDir = join28(workspacePath, ".beads");
-      if (existsSync29(beadsDir)) {
+      const beadsDir = join30(workspacePath, ".beads");
+      if (existsSync31(beadsDir)) {
         rmSync4(beadsDir, { recursive: true, force: true });
       }
       const prefix = "workspace";
@@ -7146,7 +7409,7 @@ async function createCommand(issueId, options) {
         if (projectConfig.workspace.services && projectConfig.workspace.services.length > 0) {
           console.log("");
           console.log(chalk33.bold("To start services:"));
-          const composeProject = `${basename5(projectConfig.path)}-${folderName}`;
+          const composeProject = `${basename6(projectConfig.path)}-${folderName}`;
           for (const service of projectConfig.workspace.services) {
             const containerName = `${composeProject}-${service.name}-1`;
             const cmd = service.docker_command || service.start_command;
@@ -7218,8 +7481,8 @@ async function createCommand(issueId, options) {
         projectRoot = process.cwd();
       }
     }
-    const workspacesDir = join28(projectRoot, "workspaces");
-    const workspacePath = join28(workspacesDir, folderName);
+    const workspacesDir = join30(projectRoot, "workspaces");
+    const workspacePath = join30(workspacesDir, folderName);
     if (options.dryRun) {
       spinner.info("Dry run mode");
       console.log("");
@@ -7232,11 +7495,11 @@ async function createCommand(issueId, options) {
       console.log(`  Branch:    ${chalk33.cyan(branchName)}`);
       return;
     }
-    if (existsSync29(workspacePath)) {
+    if (existsSync31(workspacePath)) {
       spinner.fail(`Workspace already exists: ${workspacePath}`);
       process.exit(1);
     }
-    if (!existsSync29(join28(projectRoot, ".git"))) {
+    if (!existsSync31(join30(projectRoot, ".git"))) {
       spinner.fail("Not a git repository. Run this from the project root.");
       process.exit(1);
     }
@@ -7260,7 +7523,7 @@ async function createCommand(issueId, options) {
       BEAD_ID: workspaceBeadId
     };
     const claudeMd = generateClaudeMd(projectRoot, variables);
-    writeFileSync10(join28(workspacePath, "CLAUDE.md"), claudeMd);
+    writeFileSync10(join30(workspacePath, "CLAUDE.md"), claudeMd);
     let skillsResult = { added: [], updated: [], skipped: [], overlayed: [] };
     if (options.skills !== false) {
       spinner.text = "Merging skills and agents...";
@@ -7270,19 +7533,19 @@ async function createCommand(issueId, options) {
     let dockerError;
     if (options.docker) {
       const composeLocations = [
-        join28(workspacePath, "docker-compose.yml"),
-        join28(workspacePath, "docker-compose.yaml"),
-        join28(workspacePath, ".devcontainer", "docker-compose.yml"),
-        join28(workspacePath, ".devcontainer", "docker-compose.yaml"),
-        join28(workspacePath, ".devcontainer", "docker-compose.devcontainer.yml"),
-        join28(workspacePath, ".devcontainer", "compose.yml"),
-        join28(workspacePath, ".devcontainer", "compose.yaml")
+        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")
       ];
-      const composeFile = composeLocations.find((f) => existsSync29(f));
+      const composeFile = composeLocations.find((f) => existsSync31(f));
       if (composeFile) {
         spinner.text = "Starting Docker containers...";
         try {
-          const composeDir = join28(composeFile, "..");
+          const composeDir = join30(composeFile, "..");
           await execAsync10(`docker compose -f "${composeFile}" up -d --build`, {
             cwd: composeDir,
             encoding: "utf-8",
@@ -7349,15 +7612,15 @@ async function listCommand2(options) {
       const workspaces2 = [];
       if (isPolyrepo && config2.workspace?.repos) {
         for (const repo of config2.workspace.repos) {
-          const repoPath = join28(config2.path, repo.path);
-          if (!existsSync29(join28(repoPath, ".git"))) continue;
+          const repoPath = join30(config2.path, repo.path);
+          if (!existsSync31(join30(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 = join28(config2.path, "workspaces", workspaceDir);
+                const canonicalPath = join30(config2.path, "workspaces", workspaceDir);
                 if (!workspaces2.some((w) => w.path === canonicalPath)) {
                   workspaces2.push({ ...wt, path: canonicalPath });
                 }
@@ -7366,7 +7629,7 @@ async function listCommand2(options) {
           }
         }
       } else {
-        if (!existsSync29(join28(config2.path, ".git"))) continue;
+        if (!existsSync31(join30(config2.path, ".git"))) continue;
         const worktrees2 = listWorktrees(config2.path);
         for (const wt of worktrees2) {
           if (wt.path.includes("/workspaces/") || wt.path.includes("\\workspaces\\")) {
@@ -7396,7 +7659,7 @@ async function listCommand2(options) {
 ${proj.projectName}
 `));
       for (const ws of proj.workspaces) {
-        const name = basename5(ws.path);
+        const name = basename6(ws.path);
         const status = ws.prunable ? chalk33.yellow(" (prunable)") : "";
         console.log(`  ${chalk33.cyan(name)}${status}`);
         console.log(`    Branch: ${ws.branch || chalk33.dim("(detached)")}`);
@@ -7406,7 +7669,7 @@ ${proj.projectName}
     return;
   }
   const projectRoot = process.cwd();
-  if (!existsSync29(join28(projectRoot, ".git"))) {
+  if (!existsSync31(join30(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."));
@@ -7431,7 +7694,7 @@ ${proj.projectName}
   }
   console.log(chalk33.bold("\nWorkspaces\n"));
   for (const ws of workspaces) {
-    const name = basename5(ws.path);
+    const name = basename6(ws.path);
     const status = ws.prunable ? chalk33.yellow(" (prunable)") : "";
     console.log(`${chalk33.cyan(name)}${status}`);
     console.log(`  Branch: ${ws.branch || chalk33.dim("(detached)")}`);
@@ -7502,17 +7765,17 @@ async function destroyCommand(issueId, options) {
         projectRoot = process.cwd();
       }
     }
-    const workspacePath = join28(projectRoot, "workspaces", folderName);
-    if (!existsSync29(workspacePath)) {
-      const cwdPath = join28(process.cwd(), "workspaces", folderName);
-      if (projectRoot !== process.cwd() && existsSync29(cwdPath)) {
+    const workspacePath = join30(projectRoot, "workspaces", folderName);
+    if (!existsSync31(workspacePath)) {
+      const cwdPath = join30(process.cwd(), "workspaces", folderName);
+      if (projectRoot !== process.cwd() && existsSync31(cwdPath)) {
         projectRoot = process.cwd();
       } else {
         spinner.fail(`Workspace not found: ${workspacePath}`);
         process.exit(1);
       }
     }
-    const finalWorkspacePath = join28(projectRoot, "workspaces", folderName);
+    const finalWorkspacePath = join30(projectRoot, "workspaces", folderName);
     spinner.text = "Removing git worktree...";
     removeWorktree2(projectRoot, finalWorkspacePath);
     spinner.succeed(`Workspace destroyed: ${folderName}`);
@@ -7598,13 +7861,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 = [
-      join28(homedir15(), ".panopticon", "ssh", "exe-dev-key"),
-      join28(homedir15(), ".ssh", "id_ed25519"),
-      join28(homedir15(), ".ssh", "id_rsa")
+      join30(homedir15(), ".panopticon", "ssh", "exe-dev-key"),
+      join30(homedir15(), ".ssh", "id_ed25519"),
+      join30(homedir15(), ".ssh", "id_rsa")
     ];
-    const sshKeyPath = sshKeyPaths.find((p) => existsSync29(p));
+    const sshKeyPath = sshKeyPaths.find((p) => existsSync31(p));
     if (sshKeyPath) {
-      const sshKeyBase64 = Buffer.from(readFileSync25(sshKeyPath, "utf-8")).toString("base64");
+      const sshKeyBase64 = Buffer.from(readFileSync27(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}`);
     }
@@ -7620,8 +7883,8 @@ 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 = join28(projectRoot, repo.path);
-        const actualRepoPath = existsSync29(rawRepoPath) ? realpathSync(rawRepoPath) : rawRepoPath;
+        const rawRepoPath = join30(projectRoot, repo.path);
+        const actualRepoPath = existsSync31(rawRepoPath) ? realpathSync(rawRepoPath) : rawRepoPath;
         let repoRemoteUrl;
         try {
           const { stdout } = await execAsync10("git remote get-url origin", {
@@ -7882,8 +8145,8 @@ async function sshCommand(issueId) {
     console.log(chalk33.dim("Create one with: pan workspace create --remote " + issueId));
     process.exit(1);
   }
-  const { spawn } = await import("child_process");
-  const child = spawn("exe", ["ssh", metadata.vmName], {
+  const { spawn: spawn2 } = await import("child_process");
+  const child = spawn2("exe", ["ssh", metadata.vmName], {
     stdio: "inherit"
   });
   child.on("exit", (code) => {
@@ -7954,8 +8217,8 @@ async function destroyRemoteWorkspace(issueId, normalizedId, metadata, spinner,
       } catch {
       }
     }
-    const metadataFile = join28(WORKSPACES_DIR, `${normalizedId}.yaml`);
-    if (existsSync29(metadataFile)) {
+    const metadataFile = join30(WORKSPACES_DIR, `${normalizedId}.yaml`);
+    if (existsSync31(metadataFile)) {
       rmSync4(metadataFile);
     }
     spinner.succeed(`Remote workspace ${issueId} destroyed`);
@@ -7981,9 +8244,9 @@ async function updateCommand(issueId, options) {
       process.exit(1);
     }
     const workspaceConfig = projectConfig.workspace;
-    const workspacesDir = join28(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
-    const workspacePath = join28(workspacesDir, folderName);
-    if (!existsSync29(workspacePath)) {
+    const workspacesDir = join30(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
+    const workspacePath = join30(workspacesDir, folderName);
+    if (!existsSync31(workspacePath)) {
       spinner.fail(`Workspace not found: ${workspacePath}`);
       process.exit(1);
     }
@@ -8003,7 +8266,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 = join28(projectConfig.path, workspaceConfig.agent.template_dir);
+      const templateDir = join30(projectConfig.path, workspaceConfig.agent.template_dir);
       const overlayed = applyProjectTemplateOverlay(workspacePath, templateDir);
       result.overlayed = overlayed;
     }
@@ -8035,8 +8298,8 @@ import ora17 from "ora";
 // src/lib/test-runner.ts
 init_esm_shims();
 init_workspace_config();
-import { existsSync as existsSync30, mkdirSync as mkdirSync13, writeFileSync as writeFileSync11 } from "fs";
-import { join as join29, basename as basename6 } from "path";
+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";
@@ -8090,8 +8353,8 @@ function parseTestOutput(output, type) {
   return { passed, failed };
 }
 async function runTestSuite(testName, testConfig, workspacePath, placeholders, reportsDir, timestamp) {
-  const testPath = join29(workspacePath, testConfig.path);
-  const logFile = join29(reportsDir, `${testName}-${timestamp}.log`);
+  const testPath = join31(workspacePath, testConfig.path);
+  const logFile = join31(reportsDir, `${testName}-${timestamp}.log`);
   const result = {
     name: testName,
     status: "pending",
@@ -8183,8 +8446,8 @@ 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 = join29(homedir16(), ".panopticon", "bin", "notify-complete");
-  if (existsSync30(notifyScript)) {
+  const notifyScript = join31(homedir16(), ".panopticon", "bin", "notify-complete");
+  if (existsSync32(notifyScript)) {
     try {
       await execAsync11(`"${notifyScript}" "${result.target}" "${message}"`);
     } catch {
@@ -8202,12 +8465,12 @@ async function runTests(options) {
   let target;
   let baseUrl;
   if (featureName) {
-    const workspacesDir = join29(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
+    const workspacesDir = join31(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
     const featureFolder2 = `feature-${featureName}`;
-    workspacePath = join29(workspacesDir, featureFolder2);
+    workspacePath = join31(workspacesDir, featureFolder2);
     target = featureFolder2;
     baseUrl = workspaceConfig?.dns?.domain ? `https://${featureFolder2}.${workspaceConfig.dns.domain}` : `http://localhost:3000`;
-    if (!existsSync30(workspacePath)) {
+    if (!existsSync32(workspacePath)) {
       throw new Error(`Workspace not found: ${workspacePath}`);
     }
   } else {
@@ -8220,16 +8483,16 @@ async function runTests(options) {
     FEATURE_NAME: featureName || "main",
     FEATURE_FOLDER: featureFolder,
     BRANCH_NAME: featureName ? `feature/${featureName}` : "main",
-    COMPOSE_PROJECT: `${basename6(projectConfig.path)}-${featureFolder}`,
+    COMPOSE_PROJECT: `${basename7(projectConfig.path)}-${featureFolder}`,
     DOMAIN: workspaceConfig?.dns?.domain || "localhost",
-    PROJECT_NAME: basename6(projectConfig.path),
+    PROJECT_NAME: basename7(projectConfig.path),
     PROJECT_PATH: projectConfig.path,
     WORKSPACE_PATH: workspacePath
   };
-  const reportsDir = join29(projectConfig.path, "reports");
+  const reportsDir = join31(projectConfig.path, "reports");
   mkdirSync13(reportsDir, { recursive: true });
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const reportFile = join29(reportsDir, `test-run-${target}-${timestamp}.md`);
+  const reportFile = join31(reportsDir, `test-run-${target}-${timestamp}.md`);
   const result = {
     target,
     baseUrl,
@@ -8393,22 +8656,22 @@ import chalk35 from "chalk";
 import ora18 from "ora";
 import inquirer5 from "inquirer";
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync31, mkdirSync as mkdirSync14, writeFileSync as writeFileSync12, readFileSync as readFileSync26, copyFileSync, readdirSync as readdirSync14, statSync as statSync5 } from "fs";
-import { join as join30 } from "path";
+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";
 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").action(installCommand);
+  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 (!existsSync31(source)) {
+  if (!existsSync33(source)) {
     throw new Error(`Source directory not found: ${source}`);
   }
   mkdirSync14(dest, { recursive: true });
-  const entries = readdirSync14(source);
+  const entries = readdirSync15(source);
   for (const entry of entries) {
-    const sourcePath = join30(source, entry);
-    const destPath = join30(dest, entry);
-    const stat = statSync5(sourcePath);
+    const sourcePath = join32(source, entry);
+    const destPath = join32(dest, entry);
+    const stat = statSync6(sourcePath);
     if (stat.isDirectory()) {
       copyDirectoryRecursive(sourcePath, destPath);
     } else {
@@ -8493,6 +8756,13 @@ function checkPrerequisites() {
     message: hasRouter ? "installed" : "not found (will auto-install)",
     fix: "npm install -g @musistudio/claude-code-router"
   });
+  const hasOx = checkCommand2("ox");
+  results.push({
+    name: "SageOx CLI (ox)",
+    passed: hasOx,
+    message: hasOx ? "installed" : "not found (will auto-install)",
+    fix: "curl -sL https://github.com/eltmon/ox/releases/download/latest/ox-linux-amd64 -o ~/.local/bin/ox && chmod +x ~/.local/bin/ox"
+  });
   const hasJq = checkCommand2("jq");
   results.push({
     name: "jq",
@@ -8500,7 +8770,7 @@ function checkPrerequisites() {
     message: hasJq ? "installed" : "not found",
     fix: "apt install jq / brew install jq"
   });
-  const hasTtyd = checkCommand2("ttyd") || existsSync31(join30(homedir17(), "bin", "ttyd"));
+  const hasTtyd = checkCommand2("ttyd") || existsSync33(join32(homedir17(), "bin", "ttyd"));
   results.push({
     name: "ttyd",
     passed: hasTtyd,
@@ -8510,7 +8780,7 @@ function checkPrerequisites() {
   return {
     results,
     // mkcert, ttyd, beads, and claude-code-router are optional (will be auto-installed or skipped)
-    allPassed: results.filter((r) => r.name !== "mkcert" && r.name !== "ttyd" && r.name !== "Beads CLI (bd)" && r.name !== "claude-code-router").every((r) => r.passed)
+    allPassed: results.filter((r) => r.name !== "mkcert" && r.name !== "ttyd" && r.name !== "Beads CLI (bd)" && r.name !== "claude-code-router" && r.name !== "SageOx CLI (ox)").every((r) => r.passed)
   };
 }
 function printPrereqStatus(prereqs) {
@@ -8576,9 +8846,9 @@ async function installCommand(options) {
           execSync4("brew install mkcert", { stdio: "pipe", timeout: 12e4 });
           spinner.succeed("mkcert installed via Homebrew");
         } else {
-          const binDir = join30(homedir17(), ".local", "bin");
+          const binDir = join32(homedir17(), ".local", "bin");
           mkdirSync14(binDir, { recursive: true });
-          const mkcertPath = join30(binDir, "mkcert");
+          const mkcertPath = join32(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",
@@ -8597,14 +8867,14 @@ async function installCommand(options) {
         execSync4("mkcert -install", { stdio: "pipe" });
         spinner.succeed("mkcert CA installed");
         spinner.start("Generating wildcard certificates...");
-        const traefikCertFile = join30(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost.pem");
-        const traefikKeyFile = join30(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost-key.pem");
+        const traefikCertFile = join32(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost.pem");
+        const traefikKeyFile = join32(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 = join30(CERTS_DIR, "localhost.pem");
-        const legacyKeyFile = join30(CERTS_DIR, "localhost-key.pem");
+        const legacyCertFile = join32(CERTS_DIR, "localhost.pem");
+        const legacyKeyFile = join32(CERTS_DIR, "localhost-key.pem");
         copyFileSync(traefikCertFile, legacyCertFile);
         copyFileSync(traefikKeyFile, legacyKeyFile);
         spinner.succeed("Wildcard certificates generated (*.pan.localhost, *.localhost)");
@@ -8622,13 +8892,13 @@ async function installCommand(options) {
       spinner.info("Skipping mkcert (not installed)");
     }
   }
-  const hasTtyd = checkCommand2("ttyd") || existsSync31(join30(homedir17(), "bin", "ttyd"));
+  const hasTtyd = checkCommand2("ttyd") || existsSync33(join32(homedir17(), "bin", "ttyd"));
   if (!hasTtyd) {
     spinner.start("Installing ttyd (web terminal)...");
     try {
-      const binDir = join30(homedir17(), "bin");
+      const binDir = join32(homedir17(), "bin");
       mkdirSync14(binDir, { recursive: true });
-      const ttydPath = join30(binDir, "ttyd");
+      const ttydPath = join32(binDir, "ttyd");
       const plat2 = detectPlatform();
       let downloadUrl = "";
       if (plat2 === "darwin") {
@@ -8733,10 +9003,35 @@ async function installCommand(options) {
       spinner.info("claude-code-router already installed");
     }
   }
+  if (options.skipSageox) {
+    spinner.info("Skipping SageOx installation (--skip-sageox)");
+  } else {
+    const hasOxNow = checkCommand2("ox");
+    if (!hasOxNow) {
+      spinner.start("Installing SageOx CLI (ox)...");
+      try {
+        const binDir = join32(homedir17(), ".local", "bin");
+        mkdirSync14(binDir, { recursive: true });
+        const oxPath = join32(binDir, "ox");
+        const arch = process.arch === "x64" ? "amd64" : process.arch;
+        const plat2 = detectPlatform();
+        const platform2 = plat2 === "darwin" ? "darwin" : "linux";
+        execSync4(`curl -sL "https://github.com/eltmon/ox/releases/download/latest/ox-${platform2}-${arch}" -o "${oxPath}" && chmod +x "${oxPath}"`, {
+          stdio: "pipe",
+          timeout: 6e4
+        });
+        spinner.succeed(`SageOx CLI installed to ${oxPath}`);
+      } catch {
+        spinner.warn("SageOx installation failed - install manually from https://github.com/eltmon/ox/releases");
+      }
+    } else {
+      spinner.info("SageOx CLI already installed");
+    }
+  }
   if (!options.minimal) {
     spinner.start("Setting up Traefik configuration...");
     try {
-      if (!existsSync31(join30(TRAEFIK_DIR, "docker-compose.yml"))) {
+      if (!existsSync33(join32(TRAEFIK_DIR, "docker-compose.yml"))) {
         copyDirectoryRecursive(SOURCE_TRAEFIK_TEMPLATES, TRAEFIK_DIR);
         cleanupTemplateFiles();
         spinner.succeed("Traefik configuration created from templates");
@@ -8749,9 +9044,9 @@ async function installCommand(options) {
       if (generateTlsConfig()) {
         spinner.succeed("TLS config generated (tls.yml)");
       }
-      const existingCompose = join30(TRAEFIK_DIR, "docker-compose.yml");
-      if (existsSync31(existingCompose)) {
-        const content = readFileSync26(existingCompose, "utf-8");
+      const existingCompose = join32(TRAEFIK_DIR, "docker-compose.yml");
+      if (existsSync33(existingCompose)) {
+        const content = readFileSync28(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/,
@@ -8766,8 +9061,8 @@ async function installCommand(options) {
       console.log(chalk35.yellow("You can set up Traefik manually later"));
     }
   }
-  const configFile = join30(PANOPTICON_HOME, "config.toml");
-  const configExists = existsSync31(configFile);
+  const configFile = join32(PANOPTICON_HOME, "config.toml");
+  const configExists = existsSync33(configFile);
   if (!configExists) {
     spinner.start("Creating default config...");
   } else {
@@ -8979,13 +9274,13 @@ function getHealthLabel(state) {
 init_esm_shims();
 init_paths();
 import Database from "better-sqlite3";
-import { join as join31 } from "path";
-import { existsSync as existsSync32, mkdirSync as mkdirSync15 } from "fs";
-var CLOISTER_DB_PATH = join31(PANOPTICON_HOME, "cloister.db");
+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 (!existsSync32(PANOPTICON_HOME)) {
+  if (!existsSync34(PANOPTICON_HOME)) {
     mkdirSync15(PANOPTICON_HOME, { recursive: true });
   }
   db = new Database(CLOISTER_DB_PATH);
@@ -9064,10 +9359,10 @@ init_esm_shims();
 init_agents();
 init_tmux();
 init_jsonl_parser();
-import { existsSync as existsSync33, readFileSync as readFileSync27, statSync as statSync6, mkdirSync as mkdirSync16, writeFileSync as writeFileSync13 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync29, statSync as statSync7, mkdirSync as mkdirSync16, writeFileSync as writeFileSync13 } from "fs";
+import { join as join34 } from "path";
 import { homedir as homedir18 } from "os";
-var CLAUDE_PROJECTS_DIR = join32(homedir18(), ".claude", "projects");
+var CLAUDE_PROJECTS_DIR = join34(homedir18(), ".claude", "projects");
 var ClaudeCodeRuntime = class {
   name = "claude-code";
   /**
@@ -9077,15 +9372,15 @@ var ClaudeCodeRuntime = class {
    * We need to find the project directory that contains sessions for this workspace.
    */
   getProjectDirForWorkspace(workspace) {
-    if (!existsSync33(CLAUDE_PROJECTS_DIR)) {
+    if (!existsSync35(CLAUDE_PROJECTS_DIR)) {
       return null;
     }
     const projectDirs = getProjectDirs();
     for (const projectDir of projectDirs) {
-      const indexPath = join32(projectDir, "sessions-index.json");
-      if (existsSync33(indexPath)) {
+      const indexPath = join34(projectDir, "sessions-index.json");
+      if (existsSync35(indexPath)) {
         try {
-          const indexContent = readFileSync27(indexPath, "utf-8");
+          const indexContent = readFileSync29(indexPath, "utf-8");
           if (indexContent.includes(workspace)) {
             return projectDir;
           }
@@ -9099,12 +9394,12 @@ var ClaudeCodeRuntime = class {
    * Get the active session ID for an agent from the sessions index
    */
   getActiveSessionId(projectDir) {
-    const indexPath = join32(projectDir, "sessions-index.json");
-    if (!existsSync33(indexPath)) {
+    const indexPath = join34(projectDir, "sessions-index.json");
+    if (!existsSync35(indexPath)) {
       return null;
     }
     try {
-      const indexContent = readFileSync27(indexPath, "utf-8");
+      const indexContent = readFileSync29(indexPath, "utf-8");
       const index = JSON.parse(indexContent);
       if (index.sessions && Array.isArray(index.sessions)) {
         const sessions = index.sessions;
@@ -9139,8 +9434,8 @@ var ClaudeCodeRuntime = class {
     }
     const sessionId = this.getActiveSessionId(projectDir);
     if (sessionId) {
-      const sessionPath = join32(projectDir, `${sessionId}.jsonl`);
-      if (existsSync33(sessionPath)) {
+      const sessionPath = join34(projectDir, `${sessionId}.jsonl`);
+      if (existsSync35(sessionPath)) {
         return sessionPath;
       }
     }
@@ -9153,11 +9448,11 @@ var ClaudeCodeRuntime = class {
    */
   getLastActivity(agentId) {
     const sessionPath = this.getSessionPath(agentId);
-    if (!sessionPath || !existsSync33(sessionPath)) {
+    if (!sessionPath || !existsSync35(sessionPath)) {
       return null;
     }
     try {
-      const stat = statSync6(sessionPath);
+      const stat = statSync7(sessionPath);
       return stat.mtime;
     } catch {
       return null;
@@ -9167,12 +9462,12 @@ var ClaudeCodeRuntime = class {
    * Read active heartbeat file if it exists
    */
   getActiveHeartbeat(agentId) {
-    const heartbeatPath = join32(homedir18(), ".panopticon", "heartbeats", `${agentId}.json`);
-    if (!existsSync33(heartbeatPath)) {
+    const heartbeatPath = join34(homedir18(), ".panopticon", "heartbeats", `${agentId}.json`);
+    if (!existsSync35(heartbeatPath)) {
       return null;
     }
     try {
-      const content = readFileSync27(heartbeatPath, "utf-8");
+      const content = readFileSync29(heartbeatPath, "utf-8");
       const data = JSON.parse(content);
       const timestamp = new Date(data.timestamp);
       const now = /* @__PURE__ */ new Date();
@@ -9276,11 +9571,11 @@ var ClaudeCodeRuntime = class {
       throw new Error(`Agent ${agentId} is not running`);
     }
     await sendKeysAsync(agentId, message);
-    const mailDir = join32(getAgentDir(agentId), "mail");
+    const mailDir = join34(getAgentDir(agentId), "mail");
     mkdirSync16(mailDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     writeFileSync13(
-      join32(mailDir, `${timestamp}.md`),
+      join34(mailDir, `${timestamp}.md`),
       `# Message
 
 ${message}
@@ -9361,7 +9656,7 @@ ${message}
     if (!sessionUsage) {
       return null;
     }
-    const stat = statSync6(file);
+    const stat = statSync7(file);
     return {
       id: sessionUsage.sessionId,
       agentId: "unknown",
@@ -9616,12 +9911,12 @@ async function checkAllTriggers(agentId, workspace, issueId, currentModel, healt
 init_esm_shims();
 init_agents();
 import { writeFileSync as writeFileSync14, mkdirSync as mkdirSync17 } from "fs";
-import { join as join34 } from "path";
+import { join as join36 } from "path";
 
 // src/lib/cloister/handoff-context.ts
 init_esm_shims();
-import { existsSync as existsSync34, readFileSync as readFileSync28 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync30 } 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);
@@ -9645,13 +9940,13 @@ async function captureHandoffContext(agentState, targetModel, reason) {
 }
 async function captureFiles(context, workspace) {
   try {
-    const stateFile = join33(workspace, ".planning/STATE.md");
-    if (existsSync34(stateFile)) {
-      context.stateFile = readFileSync28(stateFile, "utf-8");
+    const stateFile = join35(workspace, ".planning/STATE.md");
+    if (existsSync36(stateFile)) {
+      context.stateFile = readFileSync30(stateFile, "utf-8");
     }
-    const claudeMd = join33(workspace, "CLAUDE.md");
-    if (existsSync34(claudeMd)) {
-      context.claudeMd = readFileSync28(claudeMd, "utf-8");
+    const claudeMd = join35(workspace, "CLAUDE.md");
+    if (existsSync36(claudeMd)) {
+      context.claudeMd = readFileSync30(claudeMd, "utf-8");
     }
   } catch (error) {
     console.error("Error capturing files:", error);
@@ -9842,15 +10137,16 @@ async function performKillAndSpawn(state, options) {
     const context = await captureHandoffContext(state, options.targetModel, options.reason);
     stopAgent(state.id);
     const prompt = buildHandoffPrompt(context, options.additionalInstructions);
-    const handoffDir = join34(getAgentDir(state.id), "handoffs");
+    const handoffDir = join36(getAgentDir(state.id), "handoffs");
     mkdirSync17(handoffDir, { recursive: true });
-    const handoffFile = join34(handoffDir, `handoff-${Date.now()}.md`);
+    const handoffFile = join36(handoffDir, `handoff-${Date.now()}.md`);
     writeFileSync14(handoffFile, prompt);
     const newState = await spawnAgent({
       issueId: state.issueId,
       workspace: state.workspace,
       runtime: state.runtime,
       model: options.targetModel,
+      phase: "implementation",
       prompt
     });
     newState.handoffCount = (state.handoffCount || 0) + 1;
@@ -9952,12 +10248,12 @@ function sleep(ms) {
 // src/lib/cloister/handoff-logger.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync36, mkdirSync as mkdirSync18, appendFileSync as appendFileSync3, readFileSync as readFileSync29, writeFileSync as writeFileSync15 } from "fs";
-import { join as join35 } from "path";
-var HANDOFF_LOG_FILE = join35(PANOPTICON_HOME, "logs", "handoffs.jsonl");
+import { existsSync as existsSync38, mkdirSync as mkdirSync18, appendFileSync as appendFileSync3, readFileSync as readFileSync31, 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 = join35(PANOPTICON_HOME, "logs");
-  if (!existsSync36(logDir)) {
+  const logDir = join37(PANOPTICON_HOME, "logs");
+  if (!existsSync38(logDir)) {
     mkdirSync18(logDir, { recursive: true });
   }
 }
@@ -10001,8 +10297,8 @@ function createHandoffEvent(agentId, issueId, context, trigger, success, errorMe
 // src/lib/cloister/fpp-violations.ts
 init_esm_shims();
 init_hooks();
-import { readFileSync as readFileSync30, existsSync as existsSync37, writeFileSync as writeFileSync16, mkdirSync as mkdirSync19, unlinkSync as unlinkSync3 } from "fs";
-import { join as join36, dirname as dirname11 } from "path";
+import { readFileSync as readFileSync32, existsSync as existsSync39, writeFileSync as writeFileSync16, mkdirSync as mkdirSync19, unlinkSync as unlinkSync3 } from "fs";
+import { join as join38, dirname as dirname11 } from "path";
 init_paths();
 var DEFAULT_FPP_CONFIG = {
   hook_idle_minutes: 5,
@@ -10010,13 +10306,13 @@ var DEFAULT_FPP_CONFIG = {
   review_pending_minutes: 15,
   max_nudges: 3
 };
-var VIOLATIONS_DATA_FILE = join36(PANOPTICON_HOME, "fpp-violations.json");
+var VIOLATIONS_DATA_FILE = join38(PANOPTICON_HOME, "fpp-violations.json");
 function loadViolations() {
-  if (!existsSync37(VIOLATIONS_DATA_FILE)) {
+  if (!existsSync39(VIOLATIONS_DATA_FILE)) {
     return /* @__PURE__ */ new Map();
   }
   try {
-    const fileContent = readFileSync30(VIOLATIONS_DATA_FILE, "utf-8");
+    const fileContent = readFileSync32(VIOLATIONS_DATA_FILE, "utf-8");
     const persisted = JSON.parse(fileContent);
     return new Map(persisted.violations || []);
   } catch (error) {
@@ -10027,7 +10323,7 @@ function loadViolations() {
 function saveViolations(violations) {
   try {
     const dir = dirname11(VIOLATIONS_DATA_FILE);
-    if (!existsSync37(dir)) {
+    if (!existsSync39(dir)) {
       mkdirSync19(dir, { recursive: true });
     }
     const persisted = {
@@ -10035,7 +10331,7 @@ function saveViolations(violations) {
     };
     const tempFile = `${VIOLATIONS_DATA_FILE}.tmp`;
     writeFileSync16(tempFile, JSON.stringify(persisted, null, 2));
-    writeFileSync16(VIOLATIONS_DATA_FILE, readFileSync30(tempFile));
+    writeFileSync16(VIOLATIONS_DATA_FILE, readFileSync32(tempFile));
     try {
       unlinkSync3(tempFile);
     } catch (unlinkError) {
@@ -10125,11 +10421,11 @@ function clearOldViolations(hoursOld = 24) {
 init_esm_shims();
 init_paths();
 init_config2();
-import { readFileSync as readFileSync31, existsSync as existsSync38, writeFileSync as writeFileSync17, mkdirSync as mkdirSync20, unlinkSync as unlinkSync4 } from "fs";
-import { join as join37, dirname as dirname12 } from "path";
-var COST_DATA_FILE = join37(PANOPTICON_HOME, "cost-data.json");
+import { readFileSync as readFileSync33, existsSync as existsSync40, writeFileSync as writeFileSync17, mkdirSync as mkdirSync20, 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() {
-  if (!existsSync38(COST_DATA_FILE)) {
+  if (!existsSync40(COST_DATA_FILE)) {
     return {
       perAgent: /* @__PURE__ */ new Map(),
       perIssue: /* @__PURE__ */ new Map(),
@@ -10138,7 +10434,7 @@ function loadCostData() {
     };
   }
   try {
-    const fileContent = readFileSync31(COST_DATA_FILE, "utf-8");
+    const fileContent = readFileSync33(COST_DATA_FILE, "utf-8");
     const persisted = JSON.parse(fileContent);
     return {
       perAgent: new Map(Object.entries(persisted.perAgent || {})),
@@ -10159,7 +10455,7 @@ function loadCostData() {
 function saveCostData(data) {
   try {
     const dir = dirname12(COST_DATA_FILE);
-    if (!existsSync38(dir)) {
+    if (!existsSync40(dir)) {
       mkdirSync20(dir, { recursive: true });
     }
     const persisted = {
@@ -10170,7 +10466,7 @@ function saveCostData(data) {
     };
     const tempFile = `${COST_DATA_FILE}.tmp`;
     writeFileSync17(tempFile, JSON.stringify(persisted, null, 2));
-    writeFileSync17(COST_DATA_FILE, readFileSync31(tempFile));
+    writeFileSync17(COST_DATA_FILE, readFileSync33(tempFile));
     try {
       unlinkSync4(tempFile);
     } catch (unlinkError) {
@@ -10291,7 +10587,7 @@ function getCostSummary() {
 init_esm_shims();
 init_paths();
 import { writeFileSync as writeFileSync18 } from "fs";
-import { join as join38 } from "path";
+import { join as join40 } from "path";
 import { exec as exec14 } from "child_process";
 import { promisify as promisify14 } from "util";
 init_agents();
@@ -10431,7 +10727,7 @@ async function rotateSpecialistSession(specialistName, workingDir) {
     let memoryFile;
     if (specialistName === "merge-agent" && workingDir) {
       memoryContent = await buildMergeAgentMemory(workingDir);
-      memoryFile = join38(PANOPTICON_HOME, `merge-agent-memory-${Date.now()}.md`);
+      memoryFile = join40(PANOPTICON_HOME, `merge-agent-memory-${Date.now()}.md`);
       writeFileSync18(memoryFile, memoryContent);
       console.log(`Built memory file: ${memoryFile}`);
     }
@@ -10487,17 +10783,17 @@ init_config2();
 init_specialists();
 init_agents();
 init_tmux();
-import { readFileSync as readFileSync33, writeFileSync as writeFileSync19, existsSync as existsSync40, mkdirSync as mkdirSync21, readdirSync as readdirSync16, statSync as statSync7, rmSync as rmSync5 } from "fs";
-import { join as join39 } from "path";
+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 { 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 = join39(homedir19(), ".panopticon", "review-status.json");
+var REVIEW_STATUS_FILE = join41(homedir19(), ".panopticon", "review-status.json");
 function updateTestStatusToTesting(issueId) {
   try {
-    if (!existsSync40(REVIEW_STATUS_FILE)) return;
-    const data = JSON.parse(readFileSync33(REVIEW_STATUS_FILE, "utf-8"));
+    if (!existsSync42(REVIEW_STATUS_FILE)) return;
+    const data = JSON.parse(readFileSync35(REVIEW_STATUS_FILE, "utf-8"));
     const upper = issueId.toUpperCase();
     if (data[upper]) {
       data[upper].testStatus = "testing";
@@ -10523,15 +10819,15 @@ var DEFAULT_CONFIG = {
   massDeathWindowMs: 6e4
   // 1 minute window for mass death detection
 };
-var DEACON_DIR = join39(PANOPTICON_HOME, "deacon");
-var STATE_FILE = join39(DEACON_DIR, "health-state.json");
-var CONFIG_FILE2 = join39(DEACON_DIR, "config.json");
+var DEACON_DIR = join41(PANOPTICON_HOME, "deacon");
+var STATE_FILE = join41(DEACON_DIR, "health-state.json");
+var CONFIG_FILE2 = join41(DEACON_DIR, "config.json");
 var deaconInterval = null;
 var config = { ...DEFAULT_CONFIG };
 function loadConfig3() {
   try {
-    if (existsSync40(CONFIG_FILE2)) {
-      const content = readFileSync33(CONFIG_FILE2, "utf-8");
+    if (existsSync42(CONFIG_FILE2)) {
+      const content = readFileSync35(CONFIG_FILE2, "utf-8");
       const loaded = JSON.parse(content);
       config = { ...DEFAULT_CONFIG, ...loaded };
     }
@@ -10541,15 +10837,15 @@ function loadConfig3() {
   return config;
 }
 function ensureDeaconDir() {
-  if (!existsSync40(DEACON_DIR)) {
+  if (!existsSync42(DEACON_DIR)) {
     mkdirSync21(DEACON_DIR, { recursive: true });
   }
 }
 function loadState() {
   ensureDeaconDir();
   try {
-    if (existsSync40(STATE_FILE)) {
-      const content = readFileSync33(STATE_FILE, "utf-8");
+    if (existsSync42(STATE_FILE)) {
+      const content = readFileSync35(STATE_FILE, "utf-8");
       return JSON.parse(content);
     }
   } catch (error) {
@@ -10598,12 +10894,12 @@ function getCooldownRemaining(healthState) {
 }
 function checkHeartbeat(name) {
   const tmuxSession = getTmuxSessionName(name);
-  const heartbeatFile = join39(PANOPTICON_HOME, "heartbeats", `${tmuxSession}.json`);
+  const heartbeatFile = join41(PANOPTICON_HOME, "heartbeats", `${tmuxSession}.json`);
   try {
-    if (!existsSync40(heartbeatFile)) {
+    if (!existsSync42(heartbeatFile)) {
       return { isResponsive: false };
     }
-    const content = readFileSync33(heartbeatFile, "utf-8");
+    const content = readFileSync35(heartbeatFile, "utf-8");
     const heartbeat = JSON.parse(content);
     const lastActivity = new Date(heartbeat.timestamp).getTime();
     const age = Date.now() - lastActivity;
@@ -10889,10 +11185,10 @@ function isIssueCompletedOrInReview(agentId) {
     const match = agentId.match(/agent-([a-z]+-\d+)/i);
     if (!match) return false;
     const issueId = match[1].toUpperCase();
-    if (!existsSync40(REVIEW_STATUS_FILE)) {
+    if (!existsSync42(REVIEW_STATUS_FILE)) {
       return false;
     }
-    const content = readFileSync33(REVIEW_STATUS_FILE, "utf-8");
+    const content = readFileSync35(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const status = statuses[issueId];
     if (!status) {
@@ -10951,6 +11247,12 @@ async function isAgentActiveInTmux(sessionName) {
     if (!stdout.trim()) return false;
     for (const pattern of ACTIVE_STATUS_PATTERNS) {
       if (pattern.test(stdout)) {
+        if (/thinking/i.test(stdout)) {
+          const thinkingMs = parseThinkingDuration(stdout);
+          if (thinkingMs !== null && thinkingMs >= STUCK_THINKING_THRESHOLD_MS) {
+            return false;
+          }
+        }
         return true;
       }
     }
@@ -10959,39 +11261,123 @@ async function isAgentActiveInTmux(sessionName) {
     return false;
   }
 }
+var STUCK_THINKING_THRESHOLD_MS = 10 * 60 * 1e3;
+var STUCK_RECOVERY_COOLDOWN_MS = 5 * 60 * 1e3;
+var stuckRecoveryState = /* @__PURE__ */ new Map();
+function parseThinkingDuration(tmuxOutput) {
+  const match = tmuxOutput.match(/[Tt]hinking[^\n]*?\((?:(\d+)m\s*)?(\d+)s/);
+  if (!match) return null;
+  const minutes = match[1] ? parseInt(match[1], 10) : 0;
+  const seconds = parseInt(match[2], 10);
+  return (minutes * 60 + seconds) * 1e3;
+}
+async function checkStuckWorkAgents() {
+  const actions = [];
+  const agents = listRunningAgents();
+  const specialists = getEnabledSpecialists();
+  const specialistNames = new Set(specialists.map((s) => getTmuxSessionName(s.name)));
+  const now = Date.now();
+  for (const agent of agents) {
+    if (!agent.tmuxActive) continue;
+    const isWorkAgent = agent.id.startsWith("agent-") && !specialistNames.has(agent.id);
+    if (!isWorkAgent) continue;
+    const recovery = stuckRecoveryState.get(agent.id);
+    if (recovery && now - recovery.lastAttempt < STUCK_RECOVERY_COOLDOWN_MS) {
+      continue;
+    }
+    let tmuxOutput;
+    try {
+      const { stdout } = await execAsync15(
+        `tmux capture-pane -t "${agent.id}" -p -S -10 2>/dev/null || echo ""`,
+        { encoding: "utf-8" }
+      );
+      tmuxOutput = stdout;
+    } catch {
+      continue;
+    }
+    if (!tmuxOutput.trim()) continue;
+    const thinkingMs = parseThinkingDuration(tmuxOutput);
+    if (thinkingMs === null || thinkingMs < STUCK_THINKING_THRESHOLD_MS) {
+      if (recovery && recovery.attempts > 0) {
+        stuckRecoveryState.delete(agent.id);
+      }
+      continue;
+    }
+    const thinkingMinutes = Math.round(thinkingMs / 6e4);
+    const attempts = recovery?.attempts ?? 0;
+    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`);
+        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`);
+        actions.push(`Stuck recovery: sent Ctrl+C to ${agent.id} (thinking ${thinkingMinutes}m)`);
+      } else {
+        const launcherPath = join41(AGENTS_DIR, agent.id, "launcher.sh");
+        const agentState = getAgentState(agent.id);
+        const workspace = agentState?.workspace;
+        if (!existsSync42(launcherPath) || !workspace) {
+          console.error(`[deacon] Cannot respawn ${agent.id}: missing launcher.sh or workspace`);
+          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 new Promise((r) => setTimeout(r, 1e3));
+        await execAsync15(
+          `tmux new-session -d -s "${agent.id}" -c "${workspace}" "bash ${launcherPath}"`,
+          { encoding: "utf-8" }
+        );
+        stuckRecoveryState.set(agent.id, { lastAttempt: now, attempts: 0 });
+        actions.push(`Stuck recovery: respawned ${agent.id} (was stuck thinking ${thinkingMinutes}m, attempt ${attempts + 1})`);
+        console.log(`[deacon] Respawned stuck work agent ${agent.id}`);
+        continue;
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      console.error(`[deacon] Stuck recovery failed for ${agent.id}:`, msg);
+      actions.push(`Stuck recovery error for ${agent.id}: ${msg}`);
+    }
+    stuckRecoveryState.set(agent.id, {
+      lastAttempt: now,
+      attempts: attempts + 1
+    });
+  }
+  return actions;
+}
 async function cleanupStaleAgentState() {
   const actions = [];
   const cloisterConfig = loadCloisterConfig();
   const retentionDays = cloisterConfig.retention?.agent_state_days ?? 30;
   const retentionMs = retentionDays * 24 * 60 * 60 * 1e3;
   const now = Date.now();
-  if (!existsSync40(AGENTS_DIR)) {
+  if (!existsSync42(AGENTS_DIR)) {
     return actions;
   }
   try {
-    const dirs = readdirSync16(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+    const dirs = readdirSync17(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const dir of dirs) {
-      const agentDir = join39(AGENTS_DIR, dir.name);
+      const agentDir = join41(AGENTS_DIR, dir.name);
       try {
         try {
           await execAsync15(`tmux has-session -t "${dir.name}" 2>/dev/null`);
           continue;
         } catch {
         }
-        const stateFile = join39(agentDir, "state.json");
+        const stateFile = join41(agentDir, "state.json");
         let mtime;
-        if (existsSync40(stateFile)) {
-          mtime = statSync7(stateFile).mtimeMs;
+        if (existsSync42(stateFile)) {
+          mtime = statSync8(stateFile).mtimeMs;
         } else {
-          mtime = statSync7(agentDir).mtimeMs;
+          mtime = statSync8(agentDir).mtimeMs;
         }
         const ageMs = now - mtime;
         if (ageMs < retentionMs) {
           continue;
         }
-        const completedFile = join39(agentDir, "completed");
-        if (existsSync40(completedFile)) {
-          const completedAge = now - statSync7(completedFile).mtimeMs;
+        const completedFile = join41(agentDir, "completed");
+        if (existsSync42(completedFile)) {
+          const completedAge = now - statSync8(completedFile).mtimeMs;
           if (completedAge < 7 * 24 * 60 * 60 * 1e3) {
             continue;
           }
@@ -11017,10 +11403,10 @@ async function cleanupStaleAgentState() {
 async function checkOrphanedReviewStatuses() {
   const actions = [];
   try {
-    if (!existsSync40(REVIEW_STATUS_FILE)) {
+    if (!existsSync42(REVIEW_STATUS_FILE)) {
       return actions;
     }
-    const content = readFileSync33(REVIEW_STATUS_FILE, "utf-8");
+    const content = readFileSync35(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const reviewAgentSession = getTmuxSessionName("review-agent");
     const reviewAgentRunning = sessionExists(reviewAgentSession);
@@ -11066,10 +11452,10 @@ var DEAD_END_COOLDOWN_MS = 10 * 60 * 1e3;
 async function checkDeadEndAgents() {
   const actions = [];
   try {
-    if (!existsSync40(REVIEW_STATUS_FILE)) {
+    if (!existsSync42(REVIEW_STATUS_FILE)) {
       return actions;
     }
-    const content = readFileSync33(REVIEW_STATUS_FILE, "utf-8");
+    const content = readFileSync35(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const now = Date.now();
     for (const [key, status] of Object.entries(statuses)) {
@@ -11084,8 +11470,8 @@ async function checkDeadEndAgents() {
       const lastRecovery = deadEndCooldowns.get(key);
       if (lastRecovery && now - lastRecovery < DEAD_END_COOLDOWN_MS) continue;
       const autoRequeueCount = status.autoRequeueCount || 0;
-      if (autoRequeueCount >= 3) {
-        console.log(`[deacon] Dead-end detected for ${key} but circuit breaker active (${autoRequeueCount}/3 requeues used)`);
+      if (autoRequeueCount >= 7) {
+        console.log(`[deacon] Dead-end detected for ${key} but circuit breaker active (${autoRequeueCount}/7 requeues used)`);
         continue;
       }
       const issueId = status.issueId || key;
@@ -11117,6 +11503,117 @@ async function checkDeadEndAgents() {
   }
   return actions;
 }
+var firstCompletionCooldowns = /* @__PURE__ */ new Map();
+var FIRST_COMPLETION_IDLE_MS = 10 * 60 * 1e3;
+var FIRST_COMPLETION_COOLDOWN_MS = 15 * 60 * 1e3;
+async function checkFirstCompletionAgents() {
+  const actions = [];
+  try {
+    const agents = listRunningAgents();
+    const now = Date.now();
+    for (const agent of agents) {
+      const agentId = agent.id;
+      if (!agentId || !agentId.startsWith("agent-") || !agent.tmuxActive) continue;
+      if (agentId.startsWith("specialist-")) continue;
+      const completedFile = join41(AGENTS_DIR, agent.id, "completed");
+      if (existsSync42(completedFile)) continue;
+      const runtimeState = getAgentRuntimeState(agent.id);
+      if (!runtimeState || runtimeState.state !== "idle") continue;
+      const lastActivity = new Date(runtimeState.lastActivity);
+      const idleMs = now - lastActivity.getTime();
+      if (idleMs < FIRST_COMPLETION_IDLE_MS) continue;
+      try {
+        const { stdout: lastLines } = await execAsync15(
+          `tmux capture-pane -t "${agent.id}" -p -S -3 2>/dev/null || echo ""`,
+          { encoding: "utf-8" }
+        );
+        const lines = lastLines.split("\n").filter((l) => l.trim().length > 0);
+        const tail = lines.slice(-3).join("\n");
+        const isAtPrompt = /❯/.test(tail) || /bypass permissions/.test(tail) || /Worked for/.test(tail);
+        if (!isAtPrompt) continue;
+      } catch {
+        continue;
+      }
+      const lastNudge = firstCompletionCooldowns.get(agent.id);
+      if (lastNudge && now - lastNudge < FIRST_COMPLETION_COOLDOWN_MS) continue;
+      const issueId = agent.issueId || agent.id.replace("agent-", "").toUpperCase();
+      const issueKey = issueId.toLowerCase();
+      if (existsSync42(REVIEW_STATUS_FILE)) {
+        try {
+          const statuses = JSON.parse(readFileSync35(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})`);
+            continue;
+          }
+        } catch {
+        }
+      }
+      const agentStateForGate = getAgentState(agent.id);
+      if (agentStateForGate?.workspace) {
+        const feedbackDir = join41(agentStateForGate.workspace, ".planning", "feedback");
+        if (existsSync42(feedbackDir)) {
+          try {
+            const feedbackFiles = readdirSync17(feedbackDir);
+            if (feedbackFiles.length > 0) {
+              console.log(`[deacon] First-completion gate: skipping ${agent.id} \u2014 has ${feedbackFiles.length} review feedback file(s) in .planning/feedback/`);
+              continue;
+            }
+          } catch {
+          }
+        }
+      }
+      const agentState = getAgentState(agent.id);
+      if (!agentState?.workspace || !existsSync42(agentState.workspace)) continue;
+      let hasCommits = false;
+      try {
+        const { stdout: gitLog } = await execAsync15(
+          "git log --oneline -3 2>/dev/null",
+          { cwd: agentState.workspace }
+        );
+        hasCommits = gitLog.trim().length > 0;
+      } catch {
+        try {
+          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(
+                "git log --oneline -3 2>/dev/null",
+                { cwd: join41(agentState.workspace, sub.name) }
+              );
+              if (subLog.trim().length > 0) {
+                hasCommits = true;
+                break;
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      if (!hasCommits) continue;
+      const idleMinutes = Math.round(idleMs / 6e4);
+      console.log(`[deacon] First-completion gap detected: ${agent.id} (${issueId}) idle for ${idleMinutes}m with commits but no completion marker`);
+      firstCompletionCooldowns.set(agent.id, now);
+      try {
+        const nudgeMessage = `You appear to have stopped working without calling "pan work done". If your implementation is complete, run this now:
+
+pan work done ${issueId} -c "Implementation complete"
+
+If you still have remaining tasks, continue working on them.`;
+        await sendKeysAsync(agent.id, nudgeMessage);
+        actions.push(`First-completion nudge: ${agent.id} (idle ${idleMinutes}m)`);
+        console.log(`[deacon] Sent first-completion nudge to ${agent.id}`);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[deacon] Failed to send first-completion nudge to ${agent.id}:`, msg);
+      }
+    }
+  } catch (error) {
+    console.error("[deacon] Error in first-completion detection:", error);
+  }
+  return actions;
+}
 async function runPatrol() {
   const state = loadState();
   state.patrolCycle++;
@@ -11172,7 +11669,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-VLK4BMVA.js");
+          const { resumeAgent } = await import("../agents-E43Y3HNU.js");
           const message = `# Queued Work
 
 Processing queued task: ${nextTask.payload.issueId}`;
@@ -11226,9 +11723,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 firstCompletionActions = await checkFirstCompletionAgents();
+  actions.push(...firstCompletionActions);
+  for (const a of firstCompletionActions) addLog("action", a, state.patrolCycle);
   const lazyActions = await checkAndCorrectLazyAgents();
   actions.push(...lazyActions);
   for (const a of lazyActions) addLog("action", a, state.patrolCycle);
+  const stuckActions = await checkStuckWorkAgents();
+  actions.push(...stuckActions);
+  for (const a of stuckActions) addLog("action", a, state.patrolCycle);
   if (Math.random() < 3e-3) {
     const cleanupActions = await cleanupStaleAgentState();
     actions.push(...cleanupActions);
@@ -11304,9 +11807,9 @@ function getDeaconStatus() {
 // src/lib/cloister/service.ts
 init_paths();
 init_paths();
-import { existsSync as existsSync41, writeFileSync as writeFileSync20, unlinkSync as unlinkSync5, readFileSync as readFileSync34, readdirSync as readdirSync17, renameSync as renameSync3 } from "fs";
-import { join as join40 } from "path";
-var CLOISTER_STATE_FILE = join40(PANOPTICON_HOME, "cloister.state");
+import { existsSync as existsSync43, writeFileSync as writeFileSync20, unlinkSync as unlinkSync5, readFileSync as readFileSync36, 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) {
   try {
     if (running) {
@@ -11316,7 +11819,7 @@ function writeStateFile(running, pid) {
         startedAt: (/* @__PURE__ */ new Date()).toISOString()
       }));
     } else {
-      if (existsSync41(CLOISTER_STATE_FILE)) {
+      if (existsSync43(CLOISTER_STATE_FILE)) {
         unlinkSync5(CLOISTER_STATE_FILE);
       }
     }
@@ -11326,8 +11829,8 @@ function writeStateFile(running, pid) {
 }
 function readStateFile() {
   try {
-    if (existsSync41(CLOISTER_STATE_FILE)) {
-      const data = JSON.parse(readFileSync34(CLOISTER_STATE_FILE, "utf-8"));
+    if (existsSync43(CLOISTER_STATE_FILE)) {
+      const data = JSON.parse(readFileSync36(CLOISTER_STATE_FILE, "utf-8"));
       if (data.pid) {
         try {
           process.kill(data.pid, 0);
@@ -11545,14 +12048,14 @@ var CloisterService = class {
    */
   async checkCompletionMarkers() {
     try {
-      if (!existsSync41(AGENTS_DIR)) return;
-      const agentDirs = readdirSync17(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("agent-"));
+      if (!existsSync43(AGENTS_DIR)) return;
+      const agentDirs = readdirSync18(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("agent-"));
       for (const dir of agentDirs) {
-        const completedFile = join40(AGENTS_DIR, dir.name, "completed");
-        const processedFile = join40(AGENTS_DIR, dir.name, "completed.processed");
-        if (!existsSync41(completedFile) || existsSync41(processedFile)) continue;
+        const completedFile = join42(AGENTS_DIR, dir.name, "completed");
+        const processedFile = join42(AGENTS_DIR, dir.name, "completed.processed");
+        if (!existsSync43(completedFile) || existsSync43(processedFile)) continue;
         try {
-          const content = JSON.parse(readFileSync34(completedFile, "utf-8"));
+          const content = JSON.parse(readFileSync36(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)`);
@@ -12209,8 +12712,8 @@ init_esm_shims();
 // src/cli/commands/setup/hooks.ts
 init_esm_shims();
 import chalk39 from "chalk";
-import { readFileSync as readFileSync35, writeFileSync as writeFileSync21, existsSync as existsSync42, mkdirSync as mkdirSync22, copyFileSync as copyFileSync2, chmodSync } from "fs";
-import { join as join41 } from "path";
+import { readFileSync as readFileSync37, writeFileSync as writeFileSync21, existsSync as existsSync44, mkdirSync as mkdirSync22, 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";
 function checkJqInstalled() {
@@ -12288,14 +12791,14 @@ async function setupHooksCommand() {
   } else {
     console.log(chalk39.green("\u2713 jq is installed"));
   }
-  const panopticonHome = join41(homedir20(), ".panopticon");
-  const binDir = join41(panopticonHome, "bin");
-  const heartbeatsDir = join41(panopticonHome, "heartbeats");
-  if (!existsSync42(binDir)) {
+  const panopticonHome = join43(homedir20(), ".panopticon");
+  const binDir = join43(panopticonHome, "bin");
+  const heartbeatsDir = join43(panopticonHome, "heartbeats");
+  if (!existsSync44(binDir)) {
     mkdirSync22(binDir, { recursive: true });
     console.log(chalk39.green("\u2713 Created ~/.panopticon/bin/"));
   }
-  if (!existsSync42(heartbeatsDir)) {
+  if (!existsSync44(heartbeatsDir)) {
     mkdirSync22(heartbeatsDir, { recursive: true });
     console.log(chalk39.green("\u2713 Created ~/.panopticon/heartbeats/"));
   }
@@ -12304,13 +12807,13 @@ async function setupHooksCommand() {
   const { dirname: dirname17 } = await import("path");
   const __dirname6 = dirname17(fileURLToPath6(import.meta.url));
   for (const scriptName of hookScripts) {
-    const devSource = join41(process.cwd(), "scripts", scriptName);
-    const installedSource = join41(__dirname6, "..", "..", "..", "scripts", scriptName);
-    const scriptDest = join41(binDir, scriptName);
+    const devSource = join43(process.cwd(), "scripts", scriptName);
+    const installedSource = join43(__dirname6, "..", "..", "..", "scripts", scriptName);
+    const scriptDest = join43(binDir, scriptName);
     let sourcePath = null;
-    if (existsSync42(devSource)) {
+    if (existsSync44(devSource)) {
       sourcePath = devSource;
-    } else if (existsSync42(installedSource)) {
+    } else if (existsSync44(installedSource)) {
       sourcePath = installedSource;
     }
     if (!sourcePath) {
@@ -12323,12 +12826,12 @@ async function setupHooksCommand() {
     chmodSync(scriptDest, 493);
   }
   console.log(chalk39.green("\u2713 Installed hook scripts (pre-tool, post-tool, stop, specialist-stop)"));
-  const claudeDir = join41(homedir20(), ".claude");
-  const settingsPath = join41(claudeDir, "settings.json");
+  const claudeDir = join43(homedir20(), ".claude");
+  const settingsPath = join43(claudeDir, "settings.json");
   let settings = {};
-  if (existsSync42(settingsPath)) {
+  if (existsSync44(settingsPath)) {
     try {
-      const settingsContent = readFileSync35(settingsPath, "utf-8");
+      const settingsContent = readFileSync37(settingsPath, "utf-8");
       settings = JSON.parse(settingsContent);
       console.log(chalk39.green("\u2713 Read existing Claude Code settings"));
     } catch (error) {
@@ -12337,7 +12840,7 @@ async function setupHooksCommand() {
     }
   } else {
     console.log(chalk39.dim("No existing settings.json found, creating new file"));
-    if (!existsSync42(claudeDir)) {
+    if (!existsSync44(claudeDir)) {
       mkdirSync22(claudeDir, { recursive: true });
     }
   }
@@ -12351,11 +12854,11 @@ async function setupHooksCommand() {
     console.log(chalk39.dim("  Install Python3 to enable token-efficient code analysis\n"));
   }
   if (python3Available) {
-    const mcpPath = join41(dirname17(settingsPath), "mcp.json");
+    const mcpPath = join43(dirname17(settingsPath), "mcp.json");
     let mcpConfig = {};
     try {
-      if (existsSync42(mcpPath)) {
-        mcpConfig = JSON.parse(readFileSync35(mcpPath, "utf-8"));
+      if (existsSync44(mcpPath)) {
+        mcpConfig = JSON.parse(readFileSync37(mcpPath, "utf-8"));
       }
     } catch {
       mcpConfig = {};
@@ -12390,7 +12893,7 @@ async function setupHooksCommand() {
     hooks: [
       {
         type: "command",
-        command: join41(binDir, "pre-tool-hook")
+        command: join43(binDir, "pre-tool-hook")
       }
     ]
   });
@@ -12400,7 +12903,7 @@ async function setupHooksCommand() {
       hooks: [
         {
           type: "command",
-          command: join41(binDir, "tldr-read-enforcer")
+          command: join43(binDir, "tldr-read-enforcer")
         }
       ]
     });
@@ -12413,7 +12916,7 @@ async function setupHooksCommand() {
     hooks: [
       {
         type: "command",
-        command: join41(binDir, "heartbeat-hook")
+        command: join43(binDir, "heartbeat-hook")
       }
     ]
   });
@@ -12423,7 +12926,7 @@ async function setupHooksCommand() {
       hooks: [
         {
           type: "command",
-          command: join41(binDir, "tldr-post-edit")
+          command: join43(binDir, "tldr-post-edit")
         }
       ]
     });
@@ -12436,7 +12939,7 @@ async function setupHooksCommand() {
     hooks: [
       {
         type: "command",
-        command: join41(binDir, "stop-hook")
+        command: join43(binDir, "stop-hook")
       }
     ]
   });
@@ -12549,17 +13052,17 @@ import chalk41 from "chalk";
 import { exec as exec16 } from "child_process";
 import { promisify as promisify16 } from "util";
 import { setTimeout as sleep2 } from "timers/promises";
-import { existsSync as existsSync43, mkdirSync as mkdirSync23, writeFileSync as writeFileSync22 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync23, writeFileSync as writeFileSync22 } from "fs";
+import { join as join44 } from "path";
 var execAsync16 = promisify16(exec16);
-var TASKS_DIR = join42(PANOPTICON_HOME, "specialists", "tasks");
+var TASKS_DIR = join44(PANOPTICON_HOME, "specialists", "tasks");
 function sendTask(tmuxSession, specialistName, task) {
   const isLargeTask = task.length > 500 || task.includes("\n");
   if (isLargeTask) {
-    if (!existsSync43(TASKS_DIR)) {
+    if (!existsSync45(TASKS_DIR)) {
       mkdirSync23(TASKS_DIR, { recursive: true });
     }
-    const taskFile = join42(TASKS_DIR, `${specialistName}-${Date.now()}.md`);
+    const taskFile = join44(TASKS_DIR, `${specialistName}-${Date.now()}.md`);
     writeFileSync22(taskFile, task, "utf-8");
     const shortMessage = `Read and execute the task in: ${taskFile}`;
     sendKeys(tmuxSession, shortMessage);
@@ -12867,11 +13370,11 @@ init_esm_shims();
 init_specialists();
 init_paths();
 import chalk44 from "chalk";
-import { existsSync as existsSync44, readFileSync as readFileSync36, writeFileSync as writeFileSync23 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync46, readFileSync as readFileSync38, 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"];
-var REVIEW_STATUS_FILE2 = join43(PANOPTICON_HOME, "review-status.json");
+var REVIEW_STATUS_FILE2 = join45(PANOPTICON_HOME, "review-status.json");
 async function clearQueueCommand(name, options) {
   if (!ALL_SPECIALISTS2.includes(name)) {
     console.log(chalk44.red(`
@@ -12921,10 +13424,10 @@ ${metadata.displayName} Queue:
       issueIds.push(payload.issueId);
     }
   }
-  const hookFile = join43(PANOPTICON_HOME, "agents", specialistName, "hook.json");
-  if (existsSync44(hookFile)) {
+  const hookFile = join45(PANOPTICON_HOME, "agents", specialistName, "hook.json");
+  if (existsSync46(hookFile)) {
     try {
-      const hook = JSON.parse(readFileSync36(hookFile, "utf-8"));
+      const hook = JSON.parse(readFileSync38(hookFile, "utf-8"));
       hook.items = [];
       hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
       writeFileSync23(hookFile, JSON.stringify(hook, null, 2), "utf-8");
@@ -12935,9 +13438,9 @@ ${metadata.displayName} Queue:
     }
   }
   if (options.resetStatus && issueIds.length > 0) {
-    if (existsSync44(REVIEW_STATUS_FILE2)) {
+    if (existsSync46(REVIEW_STATUS_FILE2)) {
       try {
-        const statuses = JSON.parse(readFileSync36(REVIEW_STATUS_FILE2, "utf-8"));
+        const statuses = JSON.parse(readFileSync38(REVIEW_STATUS_FILE2, "utf-8"));
         let resetCount = 0;
         for (const issueId of issueIds) {
           const key = Object.keys(statuses).find((k) => k.toLowerCase() === issueId.toLowerCase());
@@ -12979,14 +13482,14 @@ function confirm2(question) {
 // src/cli/commands/specialists/done.ts
 init_esm_shims();
 import chalk45 from "chalk";
-import { existsSync as existsSync45, readFileSync as readFileSync37, writeFileSync as writeFileSync24 } from "fs";
-import { join as join44 } from "path";
+import { existsSync as existsSync47, readFileSync as readFileSync39, writeFileSync as writeFileSync24 } from "fs";
+import { join as join46 } from "path";
 import { homedir as homedir21 } from "os";
-var REVIEW_STATUS_FILE3 = join44(homedir21(), ".panopticon", "review-status.json");
+var REVIEW_STATUS_FILE3 = join46(homedir21(), ".panopticon", "review-status.json");
 function loadReviewStatuses2() {
   try {
-    if (existsSync45(REVIEW_STATUS_FILE3)) {
-      return JSON.parse(readFileSync37(REVIEW_STATUS_FILE3, "utf-8"));
+    if (existsSync47(REVIEW_STATUS_FILE3)) {
+      return JSON.parse(readFileSync39(REVIEW_STATUS_FILE3, "utf-8"));
     }
   } catch (error) {
     console.error(chalk45.yellow("Warning: Could not load review statuses"));
@@ -13095,13 +13598,13 @@ function formatStatus(status) {
 
 // src/cli/commands/specialists/logs.ts
 init_esm_shims();
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 import { exec as exec18 } from "child_process";
 import { promisify as promisify18 } from "util";
 var execAsync18 = promisify18(exec18);
 async function listLogsCommand(project2, type, options) {
   try {
-    const { listRunLogs } = await import("../specialist-logs-CVKD3YJ3.js");
+    const { listRunLogs } = await import("../specialist-logs-KLGJCEUL.js");
     const limit = options.limit ? parseInt(options.limit) : 10;
     const runs = listRunLogs(project2, type, { limit });
     if (options.json) {
@@ -13146,7 +13649,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-CVKD3YJ3.js");
+    const { getRunLog, parseLogMetadata, getRunLogPath } = await import("../specialist-logs-KLGJCEUL.js");
     const content = getRunLog(project2, type, runId);
     if (!content) {
       console.error(`\u274C Run log not found: ${runId}`);
@@ -13170,23 +13673,23 @@ async function viewLogCommand(project2, type, runId, options) {
 }
 async function tailLogCommand(project2, type) {
   try {
-    const { getRunLogPath } = await import("../specialist-logs-CVKD3YJ3.js");
-    const { getProjectSpecialistMetadata } = await import("../specialists-TKAP6T6Z.js");
+    const { getRunLogPath } = await import("../specialist-logs-KLGJCEUL.js");
+    const { getProjectSpecialistMetadata } = await import("../specialists-O4HWDJL5.js");
     const metadata = getProjectSpecialistMetadata(project2, type);
     if (!metadata.currentRun) {
       console.error(`\u274C No active run for ${project2}/${type}`);
       process.exit(1);
     }
     const logPath = getRunLogPath(project2, type, metadata.currentRun);
-    if (!existsSync46(logPath)) {
+    if (!existsSync48(logPath)) {
       console.error(`\u274C Log file not found: ${logPath}`);
       process.exit(1);
     }
     console.log(`\u{1F4E1} Following ${project2}/${type} (${metadata.currentRun})...`);
     console.log(`   Press Ctrl+C to stop
 `);
-    const { spawn } = await import("child_process");
-    const tail = spawn("tail", ["-f", logPath], {
+    const { spawn: spawn2 } = await import("child_process");
+    const tail = spawn2("tail", ["-f", logPath], {
       stdio: "inherit"
     });
     process.on("SIGINT", () => {
@@ -13240,7 +13743,7 @@ async function cleanupLogsCommand(projectOrAll, type, options) {
         console.log("   Use --force to confirm.");
         process.exit(1);
       }
-      const { cleanupAllLogs } = await import("../specialist-logs-CVKD3YJ3.js");
+      const { cleanupAllLogs } = await import("../specialist-logs-KLGJCEUL.js");
       console.log("\u{1F9F9} Cleaning up old logs for all projects...\n");
       const results = cleanupAllLogs();
       console.log(`
@@ -13267,7 +13770,7 @@ async function cleanupLogsCommand(projectOrAll, type, options) {
       console.log("   Use --force to confirm.");
       process.exit(1);
     }
-    const { cleanupOldLogs } = await import("../specialist-logs-CVKD3YJ3.js");
+    const { cleanupOldLogs } = await import("../specialist-logs-KLGJCEUL.js");
     const { getSpecialistRetention } = await import("../projects-JEIVIYC6.js");
     const retention = getSpecialistRetention(projectOrAll);
     console.log(`\u{1F9F9} Cleaning up old logs for ${projectOrAll}/${type}...`);
@@ -13306,8 +13809,8 @@ import ora19 from "ora";
 // src/lib/convoy.ts
 init_esm_shims();
 init_tmux();
-import { existsSync as existsSync47, mkdirSync as mkdirSync24, writeFileSync as writeFileSync25, readFileSync as readFileSync39, readdirSync as readdirSync18 } from "fs";
-import { join as join45 } from "path";
+import { existsSync as existsSync49, mkdirSync as mkdirSync24, writeFileSync as writeFileSync25, readFileSync as readFileSync41, 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";
@@ -13416,13 +13919,13 @@ function getExecutionOrder(template) {
 init_paths();
 init_work_type_router();
 var execAsync19 = promisify19(exec19);
-var CONVOY_DIR = join45(homedir22(), ".panopticon", "convoys");
+var CONVOY_DIR = join47(homedir22(), ".panopticon", "convoys");
 function getConvoyStateFile(convoyId) {
-  return join45(CONVOY_DIR, `${convoyId}.json`);
+  return join47(CONVOY_DIR, `${convoyId}.json`);
 }
 function getConvoyOutputDir(convoyId, template) {
   const baseDir = template.config?.outputDir || ".panopticon/convoy-output";
-  return join45(process.cwd(), baseDir, convoyId);
+  return join47(process.cwd(), baseDir, convoyId);
 }
 function saveConvoyState(state) {
   mkdirSync24(CONVOY_DIR, { recursive: true });
@@ -13430,11 +13933,11 @@ function saveConvoyState(state) {
 }
 function loadConvoyState(convoyId) {
   const stateFile = getConvoyStateFile(convoyId);
-  if (!existsSync47(stateFile)) {
+  if (!existsSync49(stateFile)) {
     return void 0;
   }
   try {
-    const content = readFileSync39(stateFile, "utf-8");
+    const content = readFileSync41(stateFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -13444,10 +13947,10 @@ function getConvoyStatus(convoyId) {
   return loadConvoyState(convoyId);
 }
 function listConvoys(filter) {
-  if (!existsSync47(CONVOY_DIR)) {
+  if (!existsSync49(CONVOY_DIR)) {
     return [];
   }
-  const files = readdirSync18(CONVOY_DIR).filter((f) => f.endsWith(".json"));
+  const files = readdirSync19(CONVOY_DIR).filter((f) => f.endsWith(".json"));
   const convoys = [];
   for (const file of files) {
     const convoyId = file.replace(".json", "");
@@ -13463,10 +13966,10 @@ function listConvoys(filter) {
   );
 }
 function parseAgentTemplate(templatePath) {
-  if (!existsSync47(templatePath)) {
+  if (!existsSync49(templatePath)) {
     throw new Error(`Agent template not found: ${templatePath}`);
   }
-  const content = readFileSync39(templatePath, "utf-8");
+  const content = readFileSync41(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}`);
@@ -13492,7 +13995,7 @@ function mapConvoyRoleToWorkType(role) {
 }
 async function spawnConvoyAgent(convoy, agent, agentState, context) {
   const { role, subagent } = agent;
-  const templatePath = join45(AGENTS_DIR, `${subagent}.md`);
+  const templatePath = join47(AGENTS_DIR, `${subagent}.md`);
   const template = parseAgentTemplate(templatePath);
   let model = template.model;
   try {
@@ -13531,7 +14034,7 @@ ${context.issueId ? `**Issue ID**: ${context.issueId}` : ""}
 `;
   prompt = contextInstructions + prompt;
   mkdirSync24(convoy.outputDir, { recursive: true });
-  const promptFile = join45(convoy.outputDir, `${role}-prompt.md`);
+  const promptFile = join47(convoy.outputDir, `${role}-prompt.md`);
   writeFileSync25(promptFile, prompt);
   const claudeCmd = `claude --dangerously-skip-permissions --model ${model}`;
   createSession(agentState.tmuxSession, convoy.context.projectPath, claudeCmd, {
@@ -13570,7 +14073,7 @@ async function startConvoy(templateName, context) {
   };
   for (const agent of template.agents) {
     const tmuxSession = `${convoyId}-${agent.role}`;
-    const outputFile = join45(outputDir, `${agent.role}.md`);
+    const outputFile = join47(outputDir, `${agent.role}.md`);
     state.agents.push({
       role: agent.role,
       subagent: agent.subagent,
@@ -13605,8 +14108,8 @@ async function executePhase(convoy, template, phaseAgents, context) {
     const agentContext = { ...context };
     for (const depRole of deps) {
       const depAgent = convoy.agents.find((a) => a.role === depRole);
-      if (depAgent?.outputFile && existsSync47(depAgent.outputFile)) {
-        agentContext[`${depRole}_output`] = readFileSync39(depAgent.outputFile, "utf-8");
+      if (depAgent?.outputFile && existsSync49(depAgent.outputFile)) {
+        agentContext[`${depRole}_output`] = readFileSync41(depAgent.outputFile, "utf-8");
       }
     }
     spawnPromises.push(spawnConvoyAgent(convoy, agent, agentState, agentContext));
@@ -13669,7 +14172,7 @@ function updateAgentStatuses(convoy) {
       agent.status = "completed";
       agent.completedAt = (/* @__PURE__ */ new Date()).toISOString();
       updated = true;
-      if (agent.outputFile && existsSync47(agent.outputFile)) {
+      if (agent.outputFile && existsSync49(agent.outputFile)) {
         agent.exitCode = 0;
       } else {
         agent.exitCode = 1;
@@ -13915,30 +14418,30 @@ function registerConvoyCommands(program2) {
 init_esm_shims();
 init_projects();
 import chalk50 from "chalk";
-import { existsSync as existsSync48, readFileSync as readFileSync40, symlinkSync as symlinkSync2, mkdirSync as mkdirSync25, readdirSync as readdirSync19, statSync as statSync9 } from "fs";
-import { join as join46, resolve, dirname as dirname14 } from "path";
+import { existsSync as existsSync50, readFileSync as readFileSync42, symlinkSync as symlinkSync2, mkdirSync as mkdirSync25, 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);
 var __dirname5 = dirname14(__filename5);
-var BUNDLED_HOOKS_DIR = join46(__dirname5, "..", "..", "scripts", "git-hooks");
+var BUNDLED_HOOKS_DIR = join48(__dirname5, "..", "..", "scripts", "git-hooks");
 function installGitHooks(gitDir) {
-  const hooksTarget = join46(gitDir, "hooks");
+  const hooksTarget = join48(gitDir, "hooks");
   let installed = 0;
-  if (!existsSync48(hooksTarget)) {
+  if (!existsSync50(hooksTarget)) {
     mkdirSync25(hooksTarget, { recursive: true });
   }
-  if (!existsSync48(BUNDLED_HOOKS_DIR)) {
+  if (!existsSync50(BUNDLED_HOOKS_DIR)) {
     return 0;
   }
   try {
-    const hooks = readdirSync19(BUNDLED_HOOKS_DIR).filter((f) => {
-      const p = join46(BUNDLED_HOOKS_DIR, f);
-      return existsSync48(p) && statSync9(p).isFile();
+    const hooks = readdirSync20(BUNDLED_HOOKS_DIR).filter((f) => {
+      const p = join48(BUNDLED_HOOKS_DIR, f);
+      return existsSync50(p) && statSync10(p).isFile();
     });
     for (const hook of hooks) {
-      const source = join46(BUNDLED_HOOKS_DIR, hook);
-      const target = join46(hooksTarget, hook);
-      if (existsSync48(target)) {
+      const source = join48(BUNDLED_HOOKS_DIR, hook);
+      const target = join48(hooksTarget, hook);
+      if (existsSync50(target)) {
         try {
           const { readlinkSync: readlinkSync2 } = __require("fs");
           if (readlinkSync2(target) === source) {
@@ -13947,7 +14450,7 @@ function installGitHooks(gitDir) {
         } catch {
         }
       }
-      if (existsSync48(target)) {
+      if (existsSync50(target)) {
         const { renameSync: renameSync4 } = __require("fs");
         renameSync4(target, `${target}.backup`);
       }
@@ -13960,7 +14463,7 @@ function installGitHooks(gitDir) {
 }
 async function projectAddCommand(projectPath, options = {}) {
   const fullPath = resolve(projectPath);
-  if (!existsSync48(fullPath)) {
+  if (!existsSync50(fullPath)) {
     console.log(chalk50.red(`Path does not exist: ${fullPath}`));
     return;
   }
@@ -13975,9 +14478,9 @@ async function projectAddCommand(projectPath, options = {}) {
   }
   let linearTeam = options.linearTeam;
   if (!linearTeam) {
-    const projectToml = join46(fullPath, ".panopticon", "project.toml");
-    if (existsSync48(projectToml)) {
-      const content = readFileSync40(projectToml, "utf-8");
+    const projectToml = join48(fullPath, ".panopticon", "project.toml");
+    if (existsSync50(projectToml)) {
+      const content = readFileSync42(projectToml, "utf-8");
       const match = content.match(/team\s*=\s*"([^"]+)"/);
       if (match) linearTeam = match[1];
     }
@@ -14003,19 +14506,19 @@ async function projectAddCommand(projectPath, options = {}) {
     console.log(chalk50.dim(`  Rally project: ${options.rallyProject}`));
   }
   console.log("");
-  const hasDevcontainer = existsSync48(join46(fullPath, ".devcontainer"));
-  const hasInfra = existsSync48(join46(fullPath, "infra"));
-  const hasDevcontainerTemplate = existsSync48(join46(fullPath, "infra", ".devcontainer-template")) || existsSync48(join46(fullPath, ".devcontainer-template"));
-  const hasRootGit = existsSync48(join46(fullPath, ".git"));
+  const hasDevcontainer = existsSync50(join48(fullPath, ".devcontainer"));
+  const hasInfra = existsSync50(join48(fullPath, "infra"));
+  const hasDevcontainerTemplate = existsSync50(join48(fullPath, "infra", ".devcontainer-template")) || existsSync50(join48(fullPath, ".devcontainer-template"));
+  const hasRootGit = existsSync50(join48(fullPath, ".git"));
   const subRepos = [];
   if (!hasRootGit) {
-    const { readdirSync: readdirSync21, statSync: statSync11 } = await import("fs");
+    const { readdirSync: readdirSync22, statSync: statSync12 } = await import("fs");
     try {
-      const entries = readdirSync21(fullPath);
+      const entries = readdirSync22(fullPath);
       for (const entry of entries) {
-        const entryPath = join46(fullPath, entry);
+        const entryPath = join48(fullPath, entry);
         try {
-          if (statSync11(entryPath).isDirectory() && existsSync48(join46(entryPath, ".git"))) {
+          if (statSync12(entryPath).isDirectory() && existsSync50(join48(entryPath, ".git"))) {
             subRepos.push(entry);
           }
         } catch {
@@ -14027,13 +14530,13 @@ async function projectAddCommand(projectPath, options = {}) {
   const isPolyrepo = !hasRootGit && subRepos.length > 0;
   let hooksInstalled = 0;
   if (hasRootGit) {
-    hooksInstalled = installGitHooks(join46(fullPath, ".git"));
+    hooksInstalled = installGitHooks(join48(fullPath, ".git"));
     if (hooksInstalled > 0) {
       console.log(chalk50.green(`\u2713 Installed ${hooksInstalled} git hook(s) for branch protection`));
     }
   } else if (isPolyrepo) {
     for (const repo of subRepos) {
-      const count = installGitHooks(join46(fullPath, repo, ".git"));
+      const count = installGitHooks(join48(fullPath, repo, ".git"));
       hooksInstalled += count;
     }
     if (hooksInstalled > 0) {
@@ -14105,7 +14608,7 @@ async function projectListCommand(options = {}) {
   }
   console.log(chalk50.bold("\nRegistered Projects:\n"));
   for (const { key, config: config2 } of projects) {
-    const exists = existsSync48(config2.path);
+    const exists = existsSync50(config2.path);
     const statusIcon = exists ? chalk50.green("\u2713") : chalk50.red("\u2717");
     console.log(`${statusIcon} ${chalk50.bold(config2.name)} ${chalk50.dim(`(${key})`)}`);
     console.log(`  ${chalk50.dim(config2.path)}`);
@@ -14139,7 +14642,7 @@ async function projectRemoveCommand(nameOrPath) {
   console.log(chalk50.dim(`Use 'pan project list' to see registered projects.`));
 }
 async function projectInitCommand() {
-  if (existsSync48(PROJECTS_CONFIG_FILE)) {
+  if (existsSync50(PROJECTS_CONFIG_FILE)) {
     console.log(chalk50.yellow(`Config already exists: ${PROJECTS_CONFIG_FILE}`));
     return;
   }
@@ -14173,7 +14676,7 @@ async function projectShowCommand(keyOrName) {
     console.log(chalk50.dim(`Use 'pan project list' to see registered projects.`));
     process.exit(1);
   }
-  const pathExists = existsSync48(found.path);
+  const pathExists = existsSync50(found.path);
   const pathStatus = pathExists ? chalk50.green("\u2713") : chalk50.red("\u2717");
   console.log(chalk50.bold(`
 Project: ${foundKey}
@@ -14205,10 +14708,10 @@ Project: ${foundKey}
 init_esm_shims();
 init_paths();
 import chalk51 from "chalk";
-import { existsSync as existsSync49, readdirSync as readdirSync20, readFileSync as readFileSync41 } from "fs";
+import { existsSync as existsSync51, readdirSync as readdirSync21, readFileSync as readFileSync43 } from "fs";
 import { execSync as execSync6 } from "child_process";
 import { homedir as homedir23 } from "os";
-import { join as join47 } from "path";
+import { join as join49 } from "path";
 function checkCommand3(cmd) {
   try {
     execSync6(`which ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
@@ -14218,12 +14721,12 @@ function checkCommand3(cmd) {
   }
 }
 function checkDirectory(path) {
-  return existsSync49(path);
+  return existsSync51(path);
 }
 function countItems(path) {
-  if (!existsSync49(path)) return 0;
+  if (!existsSync51(path)) return 0;
   try {
-    return readdirSync20(path).length;
+    return readdirSync21(path).length;
   } catch {
     return 0;
   }
@@ -14272,8 +14775,8 @@ async function doctorCommand() {
     }
   }
   if (checkDirectory(CLAUDE_DIR)) {
-    const skillsCount = countItems(join47(CLAUDE_DIR, "skills"));
-    const commandsCount = countItems(join47(CLAUDE_DIR, "commands"));
+    const skillsCount = countItems(join49(CLAUDE_DIR, "skills"));
+    const commandsCount = countItems(join49(CLAUDE_DIR, "commands"));
     checks.push({
       name: "Claude Code Skills",
       status: skillsCount > 0 ? "ok" : "warn",
@@ -14294,8 +14797,8 @@ async function doctorCommand() {
       fix: "Install Claude Code first"
     });
   }
-  const envFile = join47(homedir23(), ".panopticon.env");
-  if (existsSync49(envFile)) {
+  const envFile = join49(homedir23(), ".panopticon.env");
+  if (existsSync51(envFile)) {
     checks.push({ name: "Config File", status: "ok", message: "~/.panopticon.env exists" });
   } else {
     checks.push({
@@ -14307,8 +14810,8 @@ async function doctorCommand() {
   }
   if (process.env.LINEAR_API_KEY) {
     checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in environment" });
-  } else if (existsSync49(envFile)) {
-    const content = readFileSync41(envFile, "utf-8");
+  } else if (existsSync51(envFile)) {
+    const content = readFileSync43(envFile, "utf-8");
     if (content.includes("LINEAR_API_KEY")) {
       checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in config file" });
     } else {
@@ -14376,15 +14879,15 @@ init_esm_shims();
 init_config();
 import { execSync as execSync7 } from "child_process";
 import chalk52 from "chalk";
-import { readFileSync as readFileSync42 } from "fs";
+import { readFileSync as readFileSync44 } from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname15, join as join48 } from "path";
+import { dirname as dirname15, join as join50 } from "path";
 function getCurrentVersion() {
   try {
     const __filename6 = fileURLToPath5(import.meta.url);
     const __dirname6 = dirname15(__filename6);
-    const pkgPath = join48(__dirname6, "..", "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync42(pkgPath, "utf-8"));
+    const pkgPath = join50(__dirname6, "..", "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync44(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "unknown";
@@ -14470,8 +14973,8 @@ init_esm_shims();
 init_projects();
 import chalk53 from "chalk";
 import ora21 from "ora";
-import { existsSync as existsSync50, readFileSync as readFileSync43, writeFileSync as writeFileSync26, mkdirSync as mkdirSync26, statSync as statSync10 } from "fs";
-import { join as join49, dirname as dirname16 } from "path";
+import { existsSync as existsSync52, readFileSync as readFileSync45, writeFileSync as writeFileSync26, mkdirSync as mkdirSync26, 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);
@@ -14533,9 +15036,9 @@ async function snapshotCommand(options) {
 `));
       return;
     }
-    const outputPath = options.output || dbConfig.seed_file || join49(projectConfig.path, "infra", "seed", "seed.sql");
+    const outputPath = options.output || dbConfig.seed_file || join51(projectConfig.path, "infra", "seed", "seed.sql");
     const outputDir = dirname16(outputPath);
-    if (!existsSync50(outputDir)) {
+    if (!existsSync52(outputDir)) {
       mkdirSync26(outputDir, { recursive: true });
     }
     spinner.text = "Running snapshot command...";
@@ -14558,8 +15061,8 @@ async function snapshotCommand(options) {
     try {
       await execAsync20(fullCmd, { timeout: 3e5 });
     } catch (error) {
-      if (existsSync50(outputPath)) {
-        const content2 = readFileSync43(outputPath, "utf-8");
+      if (existsSync52(outputPath)) {
+        const content2 = readFileSync45(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"));
@@ -14572,7 +15075,7 @@ async function snapshotCommand(options) {
         return;
       }
     }
-    const content = readFileSync43(outputPath, "utf-8");
+    const content = readFileSync45(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);
@@ -14586,7 +15089,7 @@ async function snapshotCommand(options) {
       }
     }
     spinner.succeed(`Snapshot saved to ${outputPath}`);
-    const stats = statSync10(outputPath);
+    const stats = statSync11(outputPath);
     const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
     console.log(chalk53.dim(`  Size: ${sizeMB} MB`));
   } catch (error) {
@@ -14604,14 +15107,14 @@ async function seedCommand(workspaceOrIssue, options) {
       spinner.fail("Could not find project workspace configuration");
       return;
     }
-    const workspacePath = join49(projectConfig.path, projectConfig.workspace.workspaces_dir || "workspaces", folderName);
-    if (!existsSync50(workspacePath)) {
+    const workspacePath = join51(projectConfig.path, projectConfig.workspace.workspaces_dir || "workspaces", folderName);
+    if (!existsSync52(workspacePath)) {
       spinner.fail(`Workspace not found: ${workspacePath}`);
       return;
     }
     const dbConfig = projectConfig.workspace.database;
     const seedFile = options.file || dbConfig?.seed_file;
-    if (!seedFile || !existsSync50(seedFile)) {
+    if (!seedFile || !existsSync52(seedFile)) {
       spinner.fail(`Seed file not found: ${seedFile || "(not configured)"}`);
       console.log(chalk53.dim("\nConfigure seed_file in projects.yaml or use --file"));
       return;
@@ -14753,11 +15256,11 @@ async function statusCommand5(workspaceOrIssue) {
 async function cleanCommand(file, options) {
   const spinner = ora21("Cleaning database dump file...").start();
   try {
-    if (!existsSync50(file)) {
+    if (!existsSync52(file)) {
       spinner.fail(`File not found: ${file}`);
       return;
     }
-    const content = readFileSync43(file, "utf-8");
+    const content = readFileSync45(file, "utf-8");
     const lines = content.split("\n");
     const patternsToRemove = [
       /^Defaulted container/,
@@ -14827,7 +15330,7 @@ async function cleanCommand(file, options) {
   }
 }
 async function cleanFile(filePath) {
-  const content = readFileSync43(filePath, "utf-8");
+  const content = readFileSync45(filePath, "utf-8");
   const lines = content.split("\n");
   let startIndex = 0;
   for (let i = 0; i < lines.length; i++) {
@@ -14881,11 +15384,11 @@ async function configCommand(project2) {
     return;
   }
   if (dbConfig.seed_file) {
-    const exists = existsSync50(dbConfig.seed_file);
+    const exists = existsSync52(dbConfig.seed_file);
     console.log(`  Seed file: ${dbConfig.seed_file}`);
     console.log(chalk53.dim(`    Status: ${exists ? chalk53.green("exists") : chalk53.red("not found")}`));
     if (exists) {
-      const stats = statSync10(dbConfig.seed_file);
+      const stats = statSync11(dbConfig.seed_file);
       console.log(chalk53.dim(`    Size: ${(stats.size / 1024 / 1024).toFixed(2)} MB`));
     }
   }
@@ -14910,8 +15413,8 @@ async function configCommand(project2) {
 init_esm_shims();
 import chalk54 from "chalk";
 import ora22 from "ora";
-import { existsSync as existsSync51, readFileSync as readFileSync44 } from "fs";
-import { join as join50 } from "path";
+import { existsSync as existsSync53, readFileSync as readFileSync46 } 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 { platform } from "os";
@@ -14920,7 +15423,7 @@ function detectPlatform2() {
   const os = platform();
   if (os === "linux") {
     try {
-      const release = readFileSync44("/proc/version", "utf8").toLowerCase();
+      const release = readFileSync46("/proc/version", "utf8").toLowerCase();
       if (release.includes("microsoft") || release.includes("wsl")) {
         return "wsl";
       }
@@ -14958,8 +15461,8 @@ async function compactCommand(options) {
     console.log(chalk54.dim("Install beads: https://github.com/steveyegge/beads"));
     process.exit(1);
   }
-  const beadsDir = join50(cwd, ".beads");
-  if (!existsSync51(beadsDir)) {
+  const beadsDir = join52(cwd, ".beads");
+  if (!existsSync53(beadsDir)) {
     console.error(chalk54.red("Error: No .beads directory found in current directory"));
     console.log(chalk54.dim("Run bd init to initialize beads"));
     process.exit(1);
@@ -15018,8 +15521,8 @@ async function statsCommand() {
     console.error(chalk54.red("Error: bd (beads) CLI not found"));
     process.exit(1);
   }
-  const beadsDir = join50(cwd, ".beads");
-  if (!existsSync51(beadsDir)) {
+  const beadsDir = join52(cwd, ".beads");
+  if (!existsSync53(beadsDir)) {
     console.error(chalk54.red("Error: No .beads directory found"));
     process.exit(1);
   }
@@ -15647,8 +16150,8 @@ import chalk59 from "chalk";
 import ora27 from "ora";
 import { exec as exec22 } from "child_process";
 import { promisify as promisify22 } from "util";
-import { existsSync as existsSync52, readFileSync as readFileSync45 } from "fs";
-import { join as join51 } from "path";
+import { existsSync as existsSync54, readFileSync as readFileSync47 } from "fs";
+import { join as join53 } from "path";
 import { homedir as homedir24 } from "os";
 var execAsync22 = promisify22(exec22);
 async function setupCommand() {
@@ -15661,16 +16164,16 @@ async function setupCommand() {
   console.log("");
   console.log(chalk59.bold("  Step 2: SSH Key Configuration"));
   console.log("");
-  const sshDir = join51(homedir24(), ".ssh");
-  const defaultKeyPath = join51(sshDir, "id_ed25519");
-  const rsaKeyPath = join51(sshDir, "id_rsa");
+  const sshDir = join53(homedir24(), ".ssh");
+  const defaultKeyPath = join53(sshDir, "id_ed25519");
+  const rsaKeyPath = join53(sshDir, "id_rsa");
   let sshKeyExists = false;
   let keyPath = "";
-  if (existsSync52(defaultKeyPath)) {
+  if (existsSync54(defaultKeyPath)) {
     sshKeyExists = true;
     keyPath = defaultKeyPath;
     console.log(`  ${chalk59.green("\u2713")} SSH key found: ${chalk59.dim(defaultKeyPath)}`);
-  } else if (existsSync52(rsaKeyPath)) {
+  } else if (existsSync54(rsaKeyPath)) {
     sshKeyExists = true;
     keyPath = rsaKeyPath;
     console.log(`  ${chalk59.green("\u2713")} SSH key found: ${chalk59.dim(rsaKeyPath)}`);
@@ -15684,8 +16187,8 @@ async function setupCommand() {
   }
   if (sshKeyExists) {
     const pubKeyPath = `${keyPath}.pub`;
-    if (existsSync52(pubKeyPath)) {
-      const pubKey = readFileSync45(pubKeyPath, "utf8").trim();
+    if (existsSync54(pubKeyPath)) {
+      const pubKey = readFileSync47(pubKeyPath, "utf8").trim();
       console.log("");
       console.log("  Your public key (add this to exe.dev if not already):");
       console.log("");
@@ -15712,8 +16215,8 @@ async function setupCommand() {
     console.log("  Your public key to add:");
     if (sshKeyExists) {
       const pubKeyPath = `${keyPath}.pub`;
-      if (existsSync52(pubKeyPath)) {
-        const pubKey = readFileSync45(pubKeyPath, "utf8").trim();
+      if (existsSync54(pubKeyPath)) {
+        const pubKey = readFileSync47(pubKeyPath, "utf8").trim();
         console.log(chalk59.dim(`    ${pubKey}`));
       }
     } else {
@@ -15798,9 +16301,9 @@ import chalk60 from "chalk";
 
 // src/lib/env-loader.ts
 init_esm_shims();
-import { join as join52 } from "path";
+import { join as join54 } from "path";
 import { homedir as homedir25 } from "os";
-var ENV_FILE_PATH = join52(homedir25(), ".panopticon.env");
+var ENV_FILE_PATH = join54(homedir25(), ".panopticon.env");
 function getShadowModeFromEnv() {
   const value = process.env.SHADOW_MODE;
   if (!value) return false;
@@ -15895,10 +16398,10 @@ Shadowed issues: ${shadowedIssues.length}`));
 }
 
 // src/cli/index.ts
-var PANOPTICON_ENV_FILE = join53(homedir26(), ".panopticon.env");
-if (existsSync53(PANOPTICON_ENV_FILE)) {
+var PANOPTICON_ENV_FILE = join55(homedir26(), ".panopticon.env");
+if (existsSync55(PANOPTICON_ENV_FILE)) {
   try {
-    const envContent = readFileSync46(PANOPTICON_ENV_FILE, "utf-8");
+    const envContent = readFileSync48(PANOPTICON_ENV_FILE, "utf-8");
     for (const line of envContent.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -15915,7 +16418,7 @@ if (existsSync53(PANOPTICON_ENV_FILE)) {
   }
 }
 var program = new Command();
-program.name("pan").description("Multi-agent orchestration for AI coding assistants").version(JSON.parse(readFileSync46(join53(import.meta.dirname, "../../package.json"), "utf-8")).version);
+program.name("pan").description("Multi-agent orchestration for AI coding assistants").version(JSON.parse(readFileSync48(join55(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);
@@ -15936,24 +16439,24 @@ registerBeadsCommands(program);
 registerRemoteCommands(program);
 registerConfigCommand(program);
 program.command("migrate-config").description("Migrate from settings.json to config.yaml").option("--force", "Force migration even if config.yaml exists").option("--preview", "Preview migration without applying changes").option("--no-backup", "Do not back up settings.json").option("--delete-legacy", "Delete settings.json after migration").action(migrateConfigCommand);
-program.command("status").description("Show running agents (shorthand for work status)").option("--json", "Output as JSON").action(statusCommand);
+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, execSync: execSync9 } = await import("child_process");
-  const { join: join54, dirname: dirname17 } = await import("path");
+  const { spawn: spawn2, execSync: execSync9 } = await import("child_process");
+  const { join: join56, dirname: dirname17 } = await import("path");
   const { fileURLToPath: fileURLToPath6 } = await import("url");
-  const { readFileSync: readFileSync47, existsSync: existsSync54 } = await import("fs");
+  const { readFileSync: readFileSync49, existsSync: existsSync56 } = await import("fs");
   const { parse } = await import("@iarna/toml");
   const __dirname6 = dirname17(fileURLToPath6(import.meta.url));
-  const bundledServer = join54(__dirname6, "..", "dashboard", "server.js");
-  const srcDashboard = join54(__dirname6, "..", "..", "src", "dashboard");
-  const configFile = join54(process.env.HOME || "", ".panopticon", "config.toml");
+  const bundledServer = join56(__dirname6, "..", "dashboard", "server.js");
+  const srcDashboard = join56(__dirname6, "..", "..", "src", "dashboard");
+  const configFile = join56(process.env.HOME || "", ".panopticon", "config.toml");
   let traefikEnabled = false;
   let traefikDomain = "pan.localhost";
   let dashboardPort = 3010;
   let dashboardApiPort = 3011;
-  if (existsSync54(configFile)) {
+  if (existsSync56(configFile)) {
     try {
-      const configContent = readFileSync47(configFile, "utf-8");
+      const configContent = readFileSync49(configFile, "utf-8");
       const config2 = parse(configContent);
       traefikEnabled = config2.traefik?.enabled === true;
       traefikDomain = config2.traefik?.domain || "pan.localhost";
@@ -15966,7 +16469,7 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
   console.log(chalk61.bold("Starting Panopticon...\n"));
   if (traefikEnabled && !options.skipTraefik) {
     try {
-      const { generatePanopticonTraefikConfig: generatePanopticonTraefikConfig2, ensureProjectCerts: ensureProjectCerts2, generateTlsConfig: generateTlsConfig2, cleanupStaleTlsSections } = await import("../traefik-QX4ZV4YG.js");
+      const { generatePanopticonTraefikConfig: generatePanopticonTraefikConfig2, ensureProjectCerts: ensureProjectCerts2, generateTlsConfig: generateTlsConfig2, cleanupStaleTlsSections } = await import("../traefik-QN7R5I6V.js");
       cleanupStaleTlsSections();
       if (generatePanopticonTraefikConfig2()) {
         console.log(chalk61.dim("  Regenerated Traefik config from template"));
@@ -15983,7 +16486,7 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
     }
     try {
       const { ensureBaseDomain: ensureBaseDomain2, detectDnsSyncMethod: detectDnsSyncMethod2, syncDnsToWindows: syncDnsToWindows2 } = await import("../dns-7BDJSD3E.js");
-      const dnsMethod = (existsSync54(configFile) ? parse(readFileSync47(configFile, "utf-8")).traefik?.dns_sync_method : null) || detectDnsSyncMethod2();
+      const dnsMethod = (existsSync56(configFile) ? parse(readFileSync49(configFile, "utf-8")).traefik?.dns_sync_method : null) || detectDnsSyncMethod2();
       ensureBaseDomain2(dnsMethod, traefikDomain);
       if (dnsMethod === "wsl2hosts") {
         syncDnsToWindows2().catch(() => {
@@ -16006,12 +16509,12 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
     }
   }
   if (traefikEnabled && !options.skipTraefik) {
-    const traefikDir = join54(process.env.HOME || "", ".panopticon", "traefik");
-    if (existsSync54(traefikDir)) {
+    const traefikDir = join56(process.env.HOME || "", ".panopticon", "traefik");
+    if (existsSync56(traefikDir)) {
       try {
-        const composeFile = join54(traefikDir, "docker-compose.yml");
-        if (existsSync54(composeFile)) {
-          const content = readFileSync47(composeFile, "utf-8");
+        const composeFile = join56(traefikDir, "docker-compose.yml");
+        if (existsSync56(composeFile)) {
+          const content = readFileSync49(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/,
@@ -16036,8 +16539,8 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
       }
     }
   }
-  const isProduction = existsSync54(bundledServer);
-  const isDevelopment = existsSync54(srcDashboard);
+  const isProduction = existsSync56(bundledServer);
+  const isDevelopment = existsSync56(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."));
@@ -16058,11 +16561,11 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
     console.log(chalk61.dim("Starting dashboard (development mode)..."));
   }
   if (options.detach) {
-    const child = isProduction ? spawn("node", [bundledServer], {
+    const child = isProduction ? spawn2("node", [bundledServer], {
       detached: true,
       stdio: "ignore",
       env: { ...process.env, DASHBOARD_PORT: String(dashboardPort) }
-    }) : spawn("npm", ["run", "dev"], {
+    }) : spawn2("npm", ["run", "dev"], {
       cwd: srcDashboard,
       detached: true,
       stdio: "ignore",
@@ -16096,10 +16599,10 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
       console.log(`  API:      ${chalk61.cyan(`http://localhost:${dashboardApiPort}`)}`);
     }
     console.log(chalk61.dim("\nPress Ctrl+C to stop\n"));
-    const child = isProduction ? spawn("node", [bundledServer], {
+    const child = isProduction ? spawn2("node", [bundledServer], {
       stdio: "inherit",
       env: { ...process.env, DASHBOARD_PORT: String(dashboardPort) }
-    }) : spawn("npm", ["run", "dev"], {
+    }) : spawn2("npm", ["run", "dev"], {
       cwd: srcDashboard,
       stdio: "inherit",
       shell: true
@@ -16112,8 +16615,8 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
   try {
     const { getTldrDaemonService: getTldrDaemonService2 } = await import("../tldr-daemon-T3THOUGT.js");
     const projectRoot = process.cwd();
-    const venvPath = join54(projectRoot, ".venv");
-    if (existsSync54(venvPath)) {
+    const venvPath = join56(projectRoot, ".venv");
+    if (existsSync56(venvPath)) {
       console.log(chalk61.dim("\nStarting TLDR daemon for project root..."));
       const tldrService = getTldrDaemonService2(projectRoot, venvPath);
       await tldrService.start(true);
@@ -16129,17 +16632,17 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
 });
 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: join54 } = await import("path");
-  const { readFileSync: readFileSync47, existsSync: existsSync54 } = await import("fs");
+  const { join: join56 } = await import("path");
+  const { readFileSync: readFileSync49, existsSync: existsSync56 } = await import("fs");
   const { parse } = await import("@iarna/toml");
   console.log(chalk61.bold("Stopping Panopticon...\n"));
-  const configFile = join54(process.env.HOME || "", ".panopticon", "config.toml");
+  const configFile = join56(process.env.HOME || "", ".panopticon", "config.toml");
   let traefikEnabled = false;
   let dashboardPort = 3010;
   let dashboardApiPort = 3011;
-  if (existsSync54(configFile)) {
+  if (existsSync56(configFile)) {
     try {
-      const configContent = readFileSync47(configFile, "utf-8");
+      const configContent = readFileSync49(configFile, "utf-8");
       const config2 = parse(configContent);
       traefikEnabled = config2.traefik?.enabled === true;
       dashboardPort = config2.dashboard?.port || 3010;
@@ -16156,8 +16659,8 @@ program.command("down").description("Stop dashboard (and Traefik if enabled)").o
     console.log(chalk61.dim("  No dashboard processes found"));
   }
   if (traefikEnabled && !options.skipTraefik) {
-    const traefikDir = join54(process.env.HOME || "", ".panopticon", "traefik");
-    if (existsSync54(traefikDir)) {
+    const traefikDir = join56(process.env.HOME || "", ".panopticon", "traefik");
+    if (existsSync56(traefikDir)) {
       console.log(chalk61.dim("Stopping Traefik..."));
       try {
         execSync9("docker compose down", {
@@ -16176,8 +16679,8 @@ program.command("down").description("Stop dashboard (and Traefik if enabled)").o
     const { promisify: promisify23 } = await import("util");
     const execAsync23 = promisify23(exec23);
     const projectRoot = process.cwd();
-    const venvPath = join54(projectRoot, ".venv");
-    if (existsSync54(venvPath)) {
+    const venvPath = join56(projectRoot, ".venv");
+    if (existsSync56(venvPath)) {
       console.log(chalk61.dim("\nStopping TLDR daemon..."));
       const tldrService = getTldrDaemonService2(projectRoot, venvPath);
       await tldrService.stop();