panopticon-cli 0.5.9 → 0.5.11

package/dist/cli/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   closeIssue
-} from "../chunk-OJF4QS3S.js";
-import "../chunk-MJXYTGK5.js";
+} from "../chunk-GIW2TUWI.js";
+import "../chunk-JZWCL5S5.js";
 import {
   cleanupTemplateFiles,
   ensureProjectCerts,
@@ -54,28 +54,32 @@ import {
   getTmuxSessionName,
   getWeeklySummary,
   init_cost,
+  init_io,
   init_jsonl_parser,
   init_specialists,
   parseClaudeSession,
   readIssueCosts,
   readTodayCosts,
+  readWorkspacePlan,
   recordWake,
   setSessionId,
   spawnEphemeralSpecialist,
   summarizeCosts,
+  updateItemStatus,
+  updateSubItemStatus,
   wakeSpecialistOrQueue
-} from "../chunk-3WDSD2VK.js";
+} from "../chunk-NLN3ZLCN.js";
 import "../chunk-JQBV3Q2W.js";
 import {
   archivePlanning,
   findWorkspacePath
-} from "../chunk-6OYUJ4AJ.js";
-import "../chunk-WEQW3EAT.js";
+} from "../chunk-R47UJWF6.js";
+import "../chunk-F4XS2FQN.js";
 import {
   stepFailed,
   stepOk,
   stepSkipped
-} from "../chunk-R4KPLLRB.js";
+} from "../chunk-SFX3BG6N.js";
 import {
   getTldrDaemonService,
   getTldrMetrics,
@@ -88,7 +92,7 @@ import {
   init_workspace_manager,
   mergeSkillsIntoWorkspace,
   removeWorkspace
-} from "../chunk-KPGVCGST.js";
+} from "../chunk-S7EJ2OLR.js";
 import {
   detectDnsSyncMethod,
   detectPlatform,
@@ -130,7 +134,7 @@ import {
   saveSessionId,
   spawnAgent,
   stopAgent
-} from "../chunk-QQ27EVBD.js";
+} from "../chunk-OMOEGJDB.js";
 import {
   checkHook,
   clearHook,
@@ -141,7 +145,7 @@ import {
   popFromHook,
   pushToHook,
   sendMail
-} from "../chunk-4R6ATXYI.js";
+} from "../chunk-PFA5XE2V.js";
 import {
   createShadowState,
   getPendingSyncCount,
@@ -163,14 +167,14 @@ import {
   getAliasInstructions,
   getShellRcFile,
   listBackups,
-  migrateFromPersonalSymlinks,
+  migrateStalePersonalContent,
   planHooksSync,
   planSync,
   refreshCache,
   restoreBackup,
   syncHooks,
   syncStatusline
-} from "../chunk-GM22HPYS.js";
+} from "../chunk-H7T35QDO.js";
 import "../chunk-AQXETQHW.js";
 import {
   init_settings,
@@ -247,8 +251,8 @@ import {
 
 // src/cli/index.ts
 init_esm_shims();
-import { readFileSync as readFileSync47, existsSync as existsSync53 } from "fs";
-import { join as join53 } from "path";
+import { readFileSync as readFileSync48, existsSync as existsSync54 } from "fs";
+import { join as join54 } from "path";
 import { homedir as homedir24 } from "os";
 import { Command as Command2 } from "commander";
 import chalk63 from "chalk";
@@ -594,7 +598,7 @@ async function syncCommand(options) {
   if (cleanupResult.cleaned.length > 0) {
     console.log(chalk2.dim(`Removed ${cleanupResult.total} legacy runtime symlink(s): ${cleanupResult.cleaned.join(", ")}`));
   }
-  const migration = migrateFromPersonalSymlinks();
+  const migration = migrateStalePersonalContent();
   if (migration.removedSymlinks.length > 0) {
     console.log(chalk2.cyan(`Migrated: removed ${migration.removedSymlinks.length} Panopticon symlink(s) from ~/.claude/`));
     if (migration.preservedUserContent.length > 0) {
@@ -1119,6 +1123,31 @@ This workspace was created by Panopticon. Use \`bd\` commands to track your work
 
 // src/lib/cloister/work-agent-prompt.ts
 init_projects();
+init_io();
+
+// src/lib/vbrief/acceptance-criteria.ts
+init_esm_shims();
+init_io();
+function extractACFromDocument(doc) {
+  const criteria = [];
+  for (const item of doc.plan.items) {
+    if (!item.subItems) continue;
+    for (const sub of item.subItems) {
+      if (sub.metadata?.kind === "acceptance_criterion") {
+        criteria.push({
+          itemId: item.id,
+          itemTitle: item.title,
+          subItemId: sub.id,
+          title: sub.title,
+          status: sub.status
+        });
+      }
+    }
+  }
+  return criteria;
+}
+
+// src/lib/cloister/work-agent-prompt.ts
 init_config();
 init_factory();
 init_interface();
@@ -1368,6 +1397,7 @@ function readBeadsTasks(workspacePath, projectRoot, issueId) {
   const normalizedId = issueId.toLowerCase();
   const stateContent = readPlanningContext(workspacePath);
   const beadsIds = stateContent ? extractBeadsIdsFromState(stateContent) : [];
+  const acByTitle = buildACLookupByTitle(workspacePath);
   const beadsPaths = [
     join7(workspacePath, ".beads", "issues.jsonl"),
     join7(projectRoot, ".beads", "issues.jsonl")
@@ -1382,11 +1412,16 @@ function readBeadsTasks(workspacePath, projectRoot, issueId) {
         try {
           const task = JSON.parse(line);
           if (seenIds.has(task.id)) continue;
-          const tags = task.tags || [];
-          const isMatch = beadsIds.includes(task.id) || tags.some((t) => t.toLowerCase().includes(normalizedId)) || task.title?.toLowerCase().includes(normalizedId);
+          const labels = task.labels || task.tags || [];
+          const isMatch = beadsIds.includes(task.id) || labels.some((t) => t.toLowerCase().includes(normalizedId)) || task.title?.toLowerCase().includes(normalizedId);
           if (isMatch) {
             seenIds.add(task.id);
             tasks.push(`- [${task.status || "open"}] ${task.title} (${task.id})`);
+            const beadAC = matchBeadToAC(task.title, acByTitle);
+            for (const ac of beadAC) {
+              const check = ac.status === "completed" ? "x" : " ";
+              tasks.push(`  - [${check}] AC: ${ac.title}`);
+            }
           }
         } catch {
         }
@@ -1396,6 +1431,27 @@ function readBeadsTasks(workspacePath, projectRoot, issueId) {
   }
   return tasks;
 }
+function buildACLookupByTitle(workspacePath) {
+  const lookup = /* @__PURE__ */ new Map();
+  const doc = readWorkspacePlan(workspacePath);
+  if (!doc) return lookup;
+  const criteria = extractACFromDocument(doc);
+  for (const ac of criteria) {
+    const key = ac.itemTitle.toLowerCase();
+    let list = lookup.get(key);
+    if (!list) {
+      list = [];
+      lookup.set(key, list);
+    }
+    list.push({ title: ac.title, status: ac.status });
+  }
+  return lookup;
+}
+function matchBeadToAC(beadTitle, acByTitle) {
+  if (acByTitle.size === 0 || !beadTitle) return [];
+  const stripped = beadTitle.replace(/^[A-Z]+-\d+:\s*/, "");
+  return acByTitle.get(stripped.toLowerCase()) || [];
+}
 function buildPolyrepoContext(issueId, workspacePath) {
   const teamPrefix = extractTeamPrefix(issueId);
   const projectConfig = teamPrefix ? findProjectByTeam(teamPrefix) : null;
@@ -1688,8 +1744,8 @@ function findProjectRoot(issueId, labels = []) {
 }
 function hasBeadsTasks(workspacePath) {
   try {
-    const { execSync: execSync10 } = __require("child_process");
-    const output = execSync10("bd list --json --limit 1", {
+    const { execSync: execSync9 } = __require("child_process");
+    const output = execSync9("bd list --json --limit 1", {
       cwd: workspacePath,
       encoding: "utf-8",
       timeout: 1e4,
@@ -1756,23 +1812,46 @@ async function issueCommand(id, options) {
       process.exit(1);
     }
     try {
-      const { execSync: execSync10 } = await import("child_process");
-      const branch = execSync10("git branch --show-current", {
+      const { execSync: execSync9 } = await import("child_process");
+      const branch = execSync9("git branch --show-current", {
         cwd: workspace,
         encoding: "utf8"
       }).trim();
       if (branch === "main" || branch === "master") {
-        spinner.fail(`Workspace is on ${branch} branch`);
-        console.log("");
-        console.log(chalk6.red("CRITICAL: Work agents must NOT run on main/master branch."));
-        console.log(chalk6.red("This bypasses the entire review/test/merge workflow."));
-        console.log("");
-        console.log(chalk6.bold("To fix:"));
-        console.log(`  1. Create a proper workspace: ${chalk6.cyan(`pan workspace ${id}`)}`);
-        console.log(`  2. Or checkout a feature branch: ${chalk6.cyan(`git checkout -b feature/${normalizedId}`)}`);
-        process.exit(1);
+        const { readdirSync: readdirSync22, statSync: statSync12 } = await import("fs");
+        let hasFeatureBranch = false;
+        try {
+          const entries = readdirSync22(workspace);
+          for (const entry of entries) {
+            const subPath = join8(workspace, entry);
+            if (statSync12(subPath).isDirectory() && existsSync8(join8(subPath, ".git"))) {
+              const subBranch = execSync9("git branch --show-current", {
+                cwd: subPath,
+                encoding: "utf8"
+              }).trim();
+              if (subBranch !== "main" && subBranch !== "master" && subBranch.length > 0) {
+                hasFeatureBranch = true;
+                spinner.text = `Found polyrepo workspace \u2014 sub-repo ${entry} on branch: ${subBranch}`;
+                break;
+              }
+            }
+          }
+        } catch {
+        }
+        if (!hasFeatureBranch) {
+          spinner.fail(`Workspace is on ${branch} branch`);
+          console.log("");
+          console.log(chalk6.red("CRITICAL: Work agents must NOT run on main/master branch."));
+          console.log(chalk6.red("This bypasses the entire review/test/merge workflow."));
+          console.log("");
+          console.log(chalk6.bold("To fix:"));
+          console.log(`  1. Create a proper workspace: ${chalk6.cyan(`pan workspace ${id}`)}`);
+          console.log(`  2. Or checkout a feature branch: ${chalk6.cyan(`git checkout -b feature/${normalizedId}`)}`);
+          process.exit(1);
+        }
+      } else {
+        spinner.text = `Found workspace on branch: ${branch}`;
       }
-      spinner.text = `Found workspace on branch: ${branch}`;
     } catch (e) {
       spinner.warn("Could not verify branch - ensure you are NOT on main");
     }
@@ -1806,8 +1885,8 @@ async function issueCommand(id, options) {
       if (!hasPlanningDir) {
         spinner.text = `Auto-creating bead for simple issue ${id}...`;
         try {
-          const { execSync: execSync10 } = __require("child_process");
-          execSync10(`bd create "${id}: Implement issue" --type task -l "${id.toLowerCase()},difficulty:simple"`, {
+          const { execSync: execSync9 } = __require("child_process");
+          execSync9(`bd create "${id}: Implement issue" --type task -l "${id.toLowerCase()},difficulty:simple"`, {
             cwd: workspace,
             encoding: "utf-8",
             timeout: 1e4,
@@ -2348,11 +2427,94 @@ init_agents();
 init_paths();
 import chalk12 from "chalk";
 import ora6 from "ora";
-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 { existsSync as existsSync13, writeFileSync as writeFileSync4, readFileSync as readFileSync11, mkdirSync as mkdirSync4, readdirSync as readdirSync11 } from "fs";
+import { join as join13 } from "path";
 import { homedir as homedir5 } from "os";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/lib/vbrief/beads.ts
+init_esm_shims();
+init_io();
 import { exec } from "child_process";
 import { promisify } from "util";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { join as join12 } from "path";
+var execAsync = promisify(exec);
+function syncBeadStatusToVBrief(beadId, workspacePath, status = "completed") {
+  try {
+    const doc = readWorkspacePlan(workspacePath);
+    if (!doc) return null;
+    const beadsFile = join12(workspacePath, ".beads", "issues.jsonl");
+    if (!existsSync12(beadsFile)) return null;
+    const lines = readFileSync10(beadsFile, "utf-8").split("\n").filter(Boolean);
+    let beadTitle = null;
+    for (const line of lines) {
+      try {
+        const bead = JSON.parse(line);
+        if (bead.id === beadId && bead.title) {
+          beadTitle = bead.title;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!beadTitle) return null;
+    const planId = doc.plan.id;
+    const prefix = `${planId}: `;
+    const itemTitle = beadTitle.startsWith(prefix) ? beadTitle.slice(prefix.length) : beadTitle;
+    const itemTitleLower = itemTitle.toLowerCase();
+    const matchingItem = doc.plan.items.find(
+      (i) => i.title.toLowerCase() === itemTitleLower
+    );
+    if (!matchingItem) return null;
+    updateItemStatus(workspacePath, matchingItem.id, status);
+    if (status === "completed" && matchingItem.subItems) {
+      for (const sub of matchingItem.subItems) {
+        if (sub.metadata?.kind === "acceptance_criterion" && sub.status !== "completed") {
+          updateSubItemStatus(workspacePath, matchingItem.id, sub.id, "completed");
+        }
+      }
+    }
+    console.log(`[vbrief-sync] Updated item "${matchingItem.id}" to "${status}" from bead ${beadId}`);
+    return matchingItem.id;
+  } catch (err) {
+    console.warn(`[vbrief-sync] Failed to sync bead ${beadId}: ${err.message}`);
+    return null;
+  }
+}
+function getVBriefACStatus(workspacePath) {
+  const doc = readWorkspacePlan(workspacePath);
+  if (!doc) return null;
+  const allCriteria = extractACFromDocument(doc);
+  if (allCriteria.length === 0) return null;
+  const itemMap = /* @__PURE__ */ new Map();
+  for (const ac of allCriteria) {
+    let item = itemMap.get(ac.itemId);
+    if (!item) {
+      item = { itemId: ac.itemId, itemTitle: ac.itemTitle, completed: 0, pending: 0, total: 0, criteria: [] };
+      itemMap.set(ac.itemId, item);
+    }
+    item.total++;
+    item.criteria.push(ac);
+    if (ac.status === "completed" || ac.status === "cancelled") {
+      item.completed++;
+    } else {
+      item.pending++;
+    }
+  }
+  const items = Array.from(itemMap.values());
+  const totalCompleted = items.reduce((sum, i) => sum + i.completed, 0);
+  const totalPending = items.reduce((sum, i) => sum + i.pending, 0);
+  const totalCount = totalCompleted + totalPending;
+  return {
+    allCompleted: totalPending === 0,
+    items,
+    totalCompleted,
+    totalPending,
+    totalCount
+  };
+}
 
 // src/core/state-mapping.ts
 init_esm_shims();
@@ -2484,11 +2646,11 @@ function cleanupWorkflowLabels(currentLabels, targetState) {
 }
 
 // src/cli/commands/work/done.ts
-var execAsync = promisify(exec);
+var execAsync2 = promisify2(exec2);
 function getLinearApiKey3() {
-  const envFile = join12(homedir5(), ".panopticon.env");
-  if (existsSync12(envFile)) {
-    const content = readFileSync10(envFile, "utf-8");
+  const envFile = join13(homedir5(), ".panopticon.env");
+  if (existsSync13(envFile)) {
+    const content = readFileSync11(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -2529,9 +2691,9 @@ ${comment}`
   }
 }
 function getGitHubConfig() {
-  const envFile = join12(homedir5(), ".panopticon.env");
-  if (!existsSync12(envFile)) return null;
-  const content = readFileSync10(envFile, "utf-8");
+  const envFile = join13(homedir5(), ".panopticon.env");
+  if (!existsSync13(envFile)) return null;
+  const content = readFileSync11(envFile, "utf-8");
   const tokenMatch = content.match(/GITHUB_TOKEN=(.+)/);
   if (!tokenMatch) return null;
   const token = tokenMatch[1].trim();
@@ -2587,13 +2749,13 @@ 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-M2ZOZL3P.js");
+    const { getAgentState: getAgentState2 } = await import("../agents-RL2KUSP3.js");
     const agentState = getAgentState2(agentId);
     const workspacePath = agentState?.workspace;
-    if (workspacePath && existsSync12(workspacePath)) {
+    if (workspacePath && existsSync13(workspacePath)) {
       const failures = [];
       try {
-        const { stdout } = await execAsync(
+        const { stdout } = await execAsync2(
           `bd list --status open -l "${issueId.toLowerCase()}" --limit 0 --json`,
           { cwd: workspacePath }
         );
@@ -2608,10 +2770,10 @@ async function doneCommand(id, options = {}) {
         }
       } catch {
       }
-      const hasTopLevelGit = existsSync12(join12(workspacePath, ".git"));
+      const hasTopLevelGit = existsSync13(join13(workspacePath, ".git"));
       if (hasTopLevelGit) {
         try {
-          const { stdout } = await execAsync("git status --porcelain", { cwd: workspacePath });
+          const { stdout } = await execAsync2("git status --porcelain", { cwd: workspacePath });
           if (stdout.trim()) {
             failures.push("  Uncommitted changes:");
             for (const line of stdout.trim().split("\n")) {
@@ -2625,10 +2787,10 @@ async function doneCommand(id, options = {}) {
           const entries = readdirSync11(workspacePath, { withFileTypes: true });
           for (const entry of entries) {
             if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-            const subPath = join12(workspacePath, entry.name);
-            if (!existsSync12(join12(subPath, ".git"))) continue;
+            const subPath = join13(workspacePath, entry.name);
+            if (!existsSync13(join13(subPath, ".git"))) continue;
             try {
-              const { stdout } = await execAsync("git status --porcelain", { cwd: subPath });
+              const { stdout } = await execAsync2("git status --porcelain", { cwd: subPath });
               if (stdout.trim()) {
                 failures.push(`  Uncommitted changes in ${entry.name}/:`);
                 for (const line of stdout.trim().split("\n")) {
@@ -2641,6 +2803,22 @@ async function doneCommand(id, options = {}) {
         } catch {
         }
       }
+      try {
+        const acStatus = getVBriefACStatus(workspacePath);
+        if (acStatus && !acStatus.allCompleted) {
+          failures.push(`  Incomplete acceptance criteria (${acStatus.totalPending}/${acStatus.totalCount}):`);
+          for (const item of acStatus.items) {
+            if (item.pending > 0) {
+              for (const ac of item.criteria) {
+                if (ac.status !== "completed" && ac.status !== "cancelled") {
+                  failures.push(`    - [ ] ${ac.title} (${item.itemTitle})`);
+                }
+              }
+            }
+          }
+        }
+      } catch {
+      }
       if (failures.length > 0) {
         console.error(chalk12.red(`
 \u2716 Work completion checks failed for ${issueId}:
@@ -2656,6 +2834,31 @@ async function doneCommand(id, options = {}) {
       }
     }
   }
+  {
+    const { getAgentState: getAgentState2 } = await import("../agents-RL2KUSP3.js");
+    const agentState = getAgentState2(`agent-${issueId.toLowerCase()}`);
+    const workspacePath = agentState?.workspace;
+    if (workspacePath && existsSync13(workspacePath)) {
+      try {
+        const { stdout } = await execAsync2(
+          `bd list --status closed -l "${issueId.toLowerCase()}" --json --limit 0`,
+          { cwd: workspacePath, encoding: "utf-8" }
+        );
+        const closedBeads = JSON.parse(stdout || "[]");
+        let synced = 0;
+        for (const bead of closedBeads) {
+          if (bead.id) {
+            const itemId = syncBeadStatusToVBrief(bead.id, workspacePath, "completed");
+            if (itemId) synced++;
+          }
+        }
+        if (synced > 0) {
+          console.log(chalk12.dim(`  Synced ${synced} closed bead(s) to vBRIEF AC status`));
+        }
+      } catch {
+      }
+    }
+  }
   const spinner = ora6("Marking work as done...").start();
   try {
     let trackerUpdated = false;
@@ -2689,7 +2892,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-M2ZOZL3P.js");
+    const { getAgentState: getAgentState2, saveAgentState: saveAgentState2 } = await import("../agents-RL2KUSP3.js");
     const existingState = getAgentState2(agentId);
     if (existingState) {
       existingState.status = "stopped";
@@ -2700,8 +2903,8 @@ async function doneCommand(id, options = {}) {
       state: "idle",
       lastActivity: (/* @__PURE__ */ new Date()).toISOString()
     });
-    mkdirSync4(join12(AGENTS_DIR, agentId), { recursive: true });
-    const completedFile = join12(AGENTS_DIR, agentId, "completed");
+    mkdirSync4(join13(AGENTS_DIR, agentId), { recursive: true });
+    const completedFile = join13(AGENTS_DIR, agentId, "completed");
     writeFileSync4(completedFile, JSON.stringify({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       trackerUpdated,
@@ -2828,18 +3031,18 @@ init_esm_shims();
 import chalk13 from "chalk";
 import ora7 from "ora";
 import inquirer2 from "inquirer";
-import { readFileSync as readFileSync12, existsSync as existsSync14 } from "fs";
-import { join as join14, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync13, existsSync as existsSync15 } from "fs";
+import { join as join15, dirname as dirname5 } from "path";
 import { homedir as homedir6 } from "os";
 
 // 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";
+import { existsSync as existsSync14, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join14 } from "path";
+import { exec as exec3, spawn } from "child_process";
+import { promisify as promisify3 } from "util";
 init_paths();
-var execAsync2 = promisify2(exec2);
+var execAsync3 = promisify3(exec3);
 async function findPRDFiles(issueId, cwd) {
   const found = [];
   const searchRoot = cwd || process.cwd();
@@ -2847,19 +3050,19 @@ async function findPRDFiles(issueId, cwd) {
     found.push(getPRDDraftPath(issueId));
   }
   const searchPaths = [
-    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"),
+    join14(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR),
+    join14(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, "planned"),
+    join14(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR),
+    join14(PROJECT_DOCS_SUBDIR, "prd"),
     PROJECT_PRDS_SUBDIR,
     PROJECT_DOCS_SUBDIR
   ];
   const issueIdLower = issueId.toLowerCase();
   for (const searchPath of searchPaths) {
-    const fullPath = join13(searchRoot, searchPath);
-    if (!existsSync13(fullPath)) continue;
+    const fullPath = join14(searchRoot, searchPath);
+    if (!existsSync14(fullPath)) continue;
     try {
-      const { stdout: result } = await execAsync2(
+      const { stdout: result } = await execAsync3(
         `find "${fullPath}" -type f -name "*.md" 2>/dev/null | xargs grep -l -i "${issueIdLower}" 2>/dev/null || true`,
         { encoding: "utf-8" }
       );
@@ -2991,139 +3194,29 @@ function generateStateContent(issue, decisions, tasks) {
   lines.push("");
   return lines.join("\n");
 }
-function generateWorkspaceContent(issue, prdFiles, cwd) {
-  const searchRoot = cwd || process.cwd();
-  const lines = [
-    `# Workspace: ${issue.identifier}`,
-    "",
-    `> ${issue.title}`,
-    "",
-    "## Quick Links",
-    "",
-    `- [Linear Issue](${issue.url})`
-  ];
-  for (const prd of prdFiles) {
-    const relativePath = prd.replace(searchRoot + "/", "");
-    lines.push(`- [PRD](${relativePath})`);
-  }
-  lines.push("");
-  lines.push("## Context Files");
-  lines.push("");
-  lines.push("- `STATE.md` - Current progress and decisions");
-  lines.push("- `WORKSPACE.md` - This file");
-  lines.push("");
-  lines.push("## Beads");
-  lines.push("");
-  lines.push("Check current task status:");
-  lines.push("```bash");
-  lines.push("bd ready  # Next actionable task");
-  lines.push(`bd list --tag ${issue.identifier}  # All tasks for this issue`);
-  lines.push("```");
-  lines.push("");
-  lines.push("## Agent Instructions");
-  lines.push("");
-  lines.push("1. Run `bd ready` to get next task");
-  lines.push("2. Complete the task following relevant skills");
-  lines.push('3. Run `bd close "<task name>" --reason "..."` when done');
-  lines.push("4. Update STATE.md with progress");
-  lines.push("5. Repeat until all tasks complete");
-  lines.push("");
-  lines.push("## CRITICAL: Work Completion Requirements");
-  lines.push("");
-  lines.push("**You are NOT done until ALL of these are true:**");
-  lines.push("");
-  lines.push("1. **Tests pass** - Run the full test suite");
-  lines.push('2. **All changes committed** - `git status` shows "nothing to commit"');
-  lines.push("3. **Pushed to remote** - `git push`");
-  lines.push("");
-  lines.push("**Uncommitted changes = NOT COMPLETE.**");
-  lines.push("");
-  return lines.join("\n");
-}
-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";
-  const complexPatterns = ["refactor", "migration", "overhaul", "rewrite", "integrate", "multi-system"];
-  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");
+function writePlanFiles(projectPath, stateContent) {
+  const planningDir = join14(projectPath, ".planning");
   mkdirSync5(planningDir, { recursive: true });
-  const statePath = join13(planningDir, "STATE.md");
-  const workspacePath = join13(planningDir, "WORKSPACE.md");
+  const statePath = join14(planningDir, "STATE.md");
   writeFileSync5(statePath, stateContent);
-  writeFileSync5(workspacePath, workspaceContent);
-  return { statePath, workspacePath };
+  return { statePath };
 }
 async function copyToPRDDirectory(projectPath, issue, content, options) {
-  const prdDir = join13(projectPath, PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR);
+  const prdDir = join14(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);
+    const prdPath = join14(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" });
+        const relativePrdPath = join14(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR, filename);
+        await execAsync3(`git add ${relativePrdPath}`, { cwd: projectPath, encoding: "utf-8" });
         try {
-          await execAsync2("git diff --cached --quiet", { cwd: projectPath, encoding: "utf-8" });
+          await execAsync3("git diff --cached --quiet", { cwd: projectPath, encoding: "utf-8" });
         } catch {
-          await execAsync2(`git commit -m "docs: add ${issue.identifier} PRD to active"`, {
+          await execAsync3(`git commit -m "docs: add ${issue.identifier} PRD to active"`, {
             cwd: projectPath,
             encoding: "utf-8"
           });
@@ -3141,33 +3234,28 @@ async function copyToPRDDirectory(projectPath, issue, content, options) {
   }
 }
 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 { statePath } = writePlanFiles(projectPath, stateContent);
   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
+    prdCommitted: committed
   };
 }
 
 // src/cli/commands/work/plan.ts
 function getLinearApiKey4() {
-  const envFile = join14(homedir6(), ".panopticon.env");
-  if (existsSync14(envFile)) {
-    const content = readFileSync12(envFile, "utf-8");
+  const envFile = join15(homedir6(), ".panopticon.env");
+  if (existsSync15(envFile)) {
+    const content = readFileSync13(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -3473,16 +3561,6 @@ async function planCommand(id, options = {}) {
       prdFiles
     });
     spinnerCreate.succeed("Context files created");
-    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}`));
-        }
-      }
-    }
     if (result.files.prd) {
       console.log(chalk13.dim(`Plan copied to: ${result.files.prd.replace(process.cwd() + "/", "")}`));
     }
@@ -3492,8 +3570,7 @@ async function planCommand(id, options = {}) {
         complexity,
         tasks,
         decisions,
-        files: result.files,
-        beads: result.beads
+        files: result.files
       }, null, 2));
       return;
     }
@@ -3504,9 +3581,8 @@ async function planCommand(id, options = {}) {
     console.log("");
     console.log(chalk13.bold("Files created:"));
     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:"));
+    console.log(chalk13.bold("Tasks:"));
     for (const task of tasks) {
       console.log(`  ${chalk13.dim("\u25CB")} ${issueData.identifier}: ${task.name}`);
     }
@@ -3739,8 +3815,8 @@ init_esm_shims();
 init_config();
 import chalk15 from "chalk";
 import ora9 from "ora";
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync6, existsSync as existsSync15, mkdirSync as mkdirSync6 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync6, existsSync as existsSync16, mkdirSync as mkdirSync6 } from "fs";
+import { join as join16 } from "path";
 import { homedir as homedir7 } from "os";
 function getTrackerConfig2(trackerType) {
   const config2 = loadConfig();
@@ -3759,13 +3835,13 @@ function getTrackerConfig2(trackerType) {
   };
 }
 function getTriageStatePath() {
-  return join15(homedir7(), ".panopticon", "triage-state.json");
+  return join16(homedir7(), ".panopticon", "triage-state.json");
 }
 function loadTriageState() {
   const path = getTriageStatePath();
-  if (existsSync15(path)) {
+  if (existsSync16(path)) {
     try {
-      return JSON.parse(readFileSync13(path, "utf-8"));
+      return JSON.parse(readFileSync14(path, "utf-8"));
     } catch {
       return { dismissed: [], created: {} };
     }
@@ -3773,8 +3849,8 @@ function loadTriageState() {
   return { dismissed: [], created: {} };
 }
 function saveTriageState(state) {
-  const dir = join15(homedir7(), ".panopticon");
-  if (!existsSync15(dir)) {
+  const dir = join16(homedir7(), ".panopticon");
+  if (!existsSync16(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
   const path = getTriageStatePath();
@@ -4159,23 +4235,23 @@ import chalk19 from "chalk";
 // src/lib/context.ts
 init_esm_shims();
 init_paths();
-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";
+import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync7, appendFileSync, readdirSync as readdirSync12 } from "fs";
+import { join as join17 } from "path";
 function getStateFile(agentId) {
-  return join16(AGENTS_DIR, agentId, "STATE.md");
+  return join17(AGENTS_DIR, agentId, "STATE.md");
 }
 function readAgentState(agentId) {
   const stateFile = getStateFile(agentId);
-  if (!existsSync16(stateFile)) return null;
+  if (!existsSync17(stateFile)) return null;
   try {
-    const content = readFileSync14(stateFile, "utf-8");
+    const content = readFileSync15(stateFile, "utf-8");
     return parseStateMd(content);
   } catch {
     return null;
   }
 }
 function writeAgentState(agentId, state) {
-  const dir = join16(AGENTS_DIR, agentId);
+  const dir = join17(AGENTS_DIR, agentId);
   mkdirSync7(dir, { recursive: true });
   const content = generateStateMd(state);
   writeFileSync7(getStateFile(agentId), content);
@@ -4252,14 +4328,14 @@ function parseStateMd(content) {
   return state;
 }
 function getSummaryFile(agentId) {
-  return join16(AGENTS_DIR, agentId, "SUMMARY.md");
+  return join17(AGENTS_DIR, agentId, "SUMMARY.md");
 }
 function appendSummary(agentId, summary) {
-  const dir = join16(AGENTS_DIR, agentId);
+  const dir = join17(AGENTS_DIR, agentId);
   mkdirSync7(dir, { recursive: true });
   const summaryFile = getSummaryFile(agentId);
   const content = generateSummaryEntry(summary);
-  if (existsSync16(summaryFile)) {
+  if (existsSync17(summaryFile)) {
     appendFileSync(summaryFile, "\n---\n\n" + content);
   } else {
     writeFileSync7(summaryFile, "# Work Summaries\n\n" + content);
@@ -4300,14 +4376,14 @@ function generateSummaryEntry(summary) {
   return lines.join("\n");
 }
 function getHistoryDir(agentId) {
-  return join16(AGENTS_DIR, agentId, "history");
+  return join17(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 = join16(historyDir, `${dateStr}.log`);
+  const historyFile = join17(historyDir, `${dateStr}.log`);
   const timestamp = date.toISOString();
   const detailsStr = details ? ` ${JSON.stringify(details)}` : "";
   const logLine = `[${timestamp}] ${action}${detailsStr}
@@ -4316,13 +4392,13 @@ function logHistory(agentId, action, details) {
 }
 function searchHistory(agentId, pattern) {
   const historyDir = getHistoryDir(agentId);
-  if (!existsSync16(historyDir)) return [];
+  if (!existsSync17(historyDir)) return [];
   const results = [];
   const regex = new RegExp(pattern, "i");
   const files = readdirSync12(historyDir).filter((f) => f.endsWith(".log"));
   files.sort().reverse();
   for (const file of files) {
-    const content = readFileSync14(join16(historyDir, file), "utf-8");
+    const content = readFileSync15(join17(historyDir, file), "utf-8");
     const lines = content.split("\n");
     for (const line of lines) {
       if (regex.test(line)) {
@@ -4334,13 +4410,13 @@ function searchHistory(agentId, pattern) {
 }
 function getRecentHistory(agentId, limit = 20) {
   const historyDir = getHistoryDir(agentId);
-  if (!existsSync16(historyDir)) return [];
+  if (!existsSync17(historyDir)) return [];
   const results = [];
   const files = readdirSync12(historyDir).filter((f) => f.endsWith(".log"));
   files.sort().reverse();
   for (const file of files) {
     if (results.length >= limit) break;
-    const content = readFileSync14(join16(historyDir, file), "utf-8");
+    const content = readFileSync15(join17(historyDir, file), "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     for (const line of lines.reverse()) {
       if (results.length >= limit) break;
@@ -4353,28 +4429,28 @@ function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 function getMaterializedDir(agentId) {
-  return join16(AGENTS_DIR, agentId, "materialized");
+  return join17(AGENTS_DIR, agentId, "materialized");
 }
 function listMaterialized(agentId) {
   const dir = getMaterializedDir(agentId);
-  if (!existsSync16(dir)) return [];
+  if (!existsSync17(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: join16(dir, f)
+      file: join17(dir, f)
     };
   }).filter(Boolean);
 }
 function readMaterialized(filepath) {
-  if (!existsSync16(filepath)) return null;
-  return readFileSync14(filepath, "utf-8");
+  if (!existsSync17(filepath)) return null;
+  return readFileSync15(filepath, "utf-8");
 }
 
 // src/cli/commands/work/context.ts
-import { readFileSync as readFileSync15, existsSync as existsSync17 } from "fs";
+import { readFileSync as readFileSync16, existsSync as existsSync18 } from "fs";
 async function contextCommand(action, arg1, arg2, options = {}) {
   const agentId = process.env.PANOPTICON_AGENT_ID || arg1 || "default";
   switch (action) {
@@ -4490,7 +4566,7 @@ History matches for "${pattern}":
     }
     case "materialize": {
       const filepath = arg1;
-      if (filepath && existsSync17(filepath)) {
+      if (filepath && existsSync18(filepath)) {
         const content = readMaterialized(filepath);
         if (content) {
           console.log(content);
@@ -4518,8 +4594,8 @@ History matches for "${pattern}":
         return;
       }
       let text = target;
-      if (existsSync17(target)) {
-        text = readFileSync15(target, "utf-8");
+      if (existsSync18(target)) {
+        text = readFileSync16(target, "utf-8");
       }
       const tokens = estimateTokens(text);
       console.log(`Estimated tokens: ${chalk19.cyan(tokens.toLocaleString())}`);
@@ -4547,17 +4623,17 @@ import chalk20 from "chalk";
 init_esm_shims();
 init_paths();
 init_agents();
-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);
+import { existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
+import { join as join18 } from "path";
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execAsync4 = promisify4(exec4);
 var DEFAULT_PING_TIMEOUT_MS = 30 * 1e3;
 var DEFAULT_CONSECUTIVE_FAILURES = 3;
 var DEFAULT_COOLDOWN_MS = 5 * 60 * 1e3;
 var DEFAULT_CHECK_INTERVAL_MS = 30 * 1e3;
 function getHealthFile(agentId) {
-  return join17(AGENTS_DIR, agentId, "health.json");
+  return join18(AGENTS_DIR, agentId, "health.json");
 }
 function getAgentHealth(agentId) {
   const healthFile = getHealthFile(agentId);
@@ -4569,9 +4645,9 @@ function getAgentHealth(agentId) {
     recoveryCount: 0,
     inCooldown: false
   };
-  if (existsSync18(healthFile)) {
+  if (existsSync19(healthFile)) {
     try {
-      const stored = JSON.parse(readFileSync16(healthFile, "utf-8"));
+      const stored = JSON.parse(readFileSync17(healthFile, "utf-8"));
       return { ...defaultHealth, ...stored };
     } catch {
     }
@@ -4579,13 +4655,13 @@ function getAgentHealth(agentId) {
   return defaultHealth;
 }
 function saveAgentHealth(health) {
-  const dir = join17(AGENTS_DIR, health.agentId);
+  const dir = join18(AGENTS_DIR, health.agentId);
   mkdirSync8(dir, { recursive: true });
   writeFileSync8(getHealthFile(health.agentId), JSON.stringify(health, null, 2));
 }
 async function isAgentAlive(agentId) {
   try {
-    await execAsync3(`tmux has-session -t "${agentId}" 2>/dev/null`, { encoding: "utf-8" });
+    await execAsync4(`tmux has-session -t "${agentId}" 2>/dev/null`, { encoding: "utf-8" });
     return true;
   } catch {
     return false;
@@ -4695,14 +4771,14 @@ async function runHealthCheck(config2 = {
   };
   let sessions = [];
   try {
-    const { stdout: output } = await execAsync3(
+    const { stdout: output } = await execAsync4(
       'tmux list-sessions -F "#{session_name}" 2>/dev/null || true',
       { encoding: "utf-8" }
     );
     sessions = output.trim().split("\n").filter((s) => s.startsWith("agent-"));
   } catch {
   }
-  if (existsSync18(AGENTS_DIR)) {
+  if (existsSync19(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) {
@@ -4940,15 +5016,15 @@ init_esm_shims();
 import chalk21 from "chalk";
 import ora11 from "ora";
 import inquirer3 from "inquirer";
-import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
-import { join as join19, dirname as dirname6 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
+import { join as join20, 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 existsSync19, readFileSync as readFileSync17, appendFileSync as appendFileSync2 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync18, appendFileSync as appendFileSync2 } from "fs";
+import { join as join19 } from "path";
 
 // src/dashboard/server/review-status.ts
 init_esm_shims();
@@ -5014,9 +5090,9 @@ function reopenWorkspaceState(issueId, workspacePath, options = {}) {
       result.queueItemsRemoved[specialistName] = removed;
     }
   }
-  const statePath = join18(workspacePath, ".planning", "STATE.md");
-  if (existsSync19(statePath)) {
-    const previousContent = readFileSync17(statePath, "utf-8");
+  const statePath = join19(workspacePath, ".planning", "STATE.md");
+  if (existsSync20(statePath)) {
+    const previousContent = readFileSync18(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);
@@ -5052,9 +5128,9 @@ function reopenWorkspaceState(issueId, workspacePath, options = {}) {
 // src/cli/commands/work/reopen.ts
 init_projects();
 function getLinearApiKey5() {
-  const envFile = join19(homedir8(), ".panopticon.env");
-  if (existsSync20(envFile)) {
-    const content = readFileSync18(envFile, "utf-8");
+  const envFile = join20(homedir8(), ".panopticon.env");
+  if (existsSync21(envFile)) {
+    const content = readFileSync19(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -5127,15 +5203,15 @@ function findLocalWorkspace2(issueId, startDir) {
   const normalizedId = issueId.toLowerCase();
   const resolved = resolveProjectFromIssue(issueId, []);
   if (resolved) {
-    const workspacePath = join19(resolved.projectPath, "workspaces", `feature-${normalizedId}`);
-    if (existsSync20(workspacePath)) return workspacePath;
+    const workspacePath = join20(resolved.projectPath, "workspaces", `feature-${normalizedId}`);
+    if (existsSync21(workspacePath)) return workspacePath;
   }
   let dir = startDir ?? process.cwd();
   for (let i = 0; i < 10; i++) {
-    const workspacesDir = join19(dir, "workspaces");
-    if (existsSync20(workspacesDir)) {
-      const workspacePath = join19(workspacesDir, `feature-${normalizedId}`);
-      if (existsSync20(workspacePath)) return workspacePath;
+    const workspacesDir = join20(dir, "workspaces");
+    if (existsSync21(workspacesDir)) {
+      const workspacePath = join20(workspacesDir, `feature-${normalizedId}`);
+      if (existsSync21(workspacePath)) return workspacePath;
     }
     const parent = dirname6(dir);
     if (parent === dir) break;
@@ -5262,7 +5338,7 @@ Previous state: ${issue.state}`
     console.log(chalk21.green(`\u2713 ${issue.identifier} reopened and ready for re-work`));
     console.log("");
     try {
-      const { getAgentState: getAgentState2 } = await import("../agents-M2ZOZL3P.js");
+      const { getAgentState: getAgentState2 } = await import("../agents-RL2KUSP3.js");
       const agentId = `agent-${id.toLowerCase()}`;
       const agentState = getAgentState2(agentId);
       const agentRunning = agentState?.status === "running" || agentState?.status === "starting";
@@ -5379,12 +5455,12 @@ init_agents();
 init_tmux();
 import chalk24 from "chalk";
 import { homedir as homedir9 } from "os";
-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";
+import { join as join21 } from "path";
+import { existsSync as existsSync22, rmSync, readFileSync as readFileSync20 } from "fs";
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
 init_config();
-var execAsync4 = promisify4(exec4);
+var execAsync5 = promisify5(exec5);
 async function wipeCommand(issueId, options) {
   const issueLower = issueId.toLowerCase();
   const cleanupLog = [];
@@ -5470,10 +5546,10 @@ async function wipeCommand(issueId, options) {
     }
   }
   const agentDirs = [
-    join20(homedir9(), ".panopticon", "agents", `agent-${issueLower}`)
+    join21(homedir9(), ".panopticon", "agents", `agent-${issueLower}`)
   ];
   for (const dir of agentDirs) {
-    if (existsSync21(dir)) {
+    if (existsSync22(dir)) {
       rmSync(dir, { recursive: true, force: true });
       cleanupLog.push(`Deleted agent state: ${dir}`);
       console.log(chalk24.green(`  \u2713 Deleted agent state: ${dir.replace(homedir9(), "~")}`));
@@ -5481,11 +5557,11 @@ async function wipeCommand(issueId, options) {
   }
   let projectPath;
   const prefix = issueId.split("-")[0].toUpperCase();
-  const projectsYamlPath = join20(homedir9(), ".panopticon", "projects.yaml");
-  if (existsSync21(projectsYamlPath)) {
+  const projectsYamlPath = join21(homedir9(), ".panopticon", "projects.yaml");
+  if (existsSync22(projectsYamlPath)) {
     try {
       const yaml2 = await import("js-yaml");
-      const projectsConfig = yaml2.load(readFileSync19(projectsYamlPath, "utf-8"));
+      const projectsConfig = yaml2.load(readFileSync20(projectsYamlPath, "utf-8"));
       for (const [, config2] of Object.entries(projectsConfig.projects || {})) {
         const projConfig = config2;
         if (projConfig.linear_team?.toUpperCase() === prefix) {
@@ -5496,20 +5572,72 @@ async function wipeCommand(issueId, options) {
     } catch (e) {
     }
   }
+  if (projectPath) {
+    const workspacePath = join21(projectPath, "workspaces", `feature-${issueLower}`);
+    const workspaceBeadsDir = join21(workspacePath, ".beads");
+    if (existsSync22(workspaceBeadsDir)) {
+      try {
+        const { stdout: listOutput } = await execAsync5(
+          `bd list --json -l "${issueLower}" --limit 0`,
+          { encoding: "utf-8", cwd: workspacePath, timeout: 15e3 }
+        );
+        const beads = JSON.parse(listOutput || "[]");
+        if (Array.isArray(beads) && beads.length > 0) {
+          const ids = beads.map((b) => b.id).filter(Boolean);
+          for (const id of ids) {
+            try {
+              await execAsync5(`bd delete ${id} --force`, { encoding: "utf-8", cwd: workspacePath, timeout: 1e4 });
+            } catch {
+            }
+          }
+          cleanupLog.push(`Deleted ${ids.length} beads for ${issueLower}`);
+          console.log(chalk24.green(`  \u2713 Deleted ${ids.length} beads for ${issueLower}`));
+        }
+      } catch {
+      }
+    }
+    const projJsonl = join21(projectPath, ".beads", "issues.jsonl");
+    if (existsSync22(projJsonl)) {
+      try {
+        const content = readFileSync20(projJsonl, "utf-8");
+        const lines = content.split("\n");
+        const issueUpper = issueLower.toUpperCase();
+        const filtered = lines.filter((line) => {
+          if (!line.trim()) return true;
+          try {
+            const entry = JSON.parse(line);
+            const title = (entry.title || "").toUpperCase();
+            const issue = (entry.issue || "").toUpperCase();
+            return !title.includes(issueUpper) && issue !== issueUpper;
+          } catch {
+            return true;
+          }
+        });
+        const removed = lines.length - filtered.length;
+        if (removed > 0) {
+          const { writeFileSync: writeFileSync27 } = await import("fs");
+          writeFileSync27(projJsonl, filtered.join("\n"));
+          cleanupLog.push(`Removed ${removed} beads entries from project JSONL`);
+          console.log(chalk24.green(`  \u2713 Removed ${removed} beads entries from project JSONL`));
+        }
+      } catch {
+      }
+    }
+  }
   if (options.workspace && projectPath) {
-    const workspacePath = join20(projectPath, "workspaces", `feature-${issueLower}`);
-    if (existsSync21(workspacePath)) {
+    const workspacePath = join21(projectPath, "workspaces", `feature-${issueLower}`);
+    if (existsSync22(workspacePath)) {
       try {
         const gitDirs = ["api", "frontend", "fe", "."];
         for (const gitDir of gitDirs) {
-          const gitPath = join20(projectPath, gitDir);
-          if (existsSync21(join20(gitPath, ".git"))) {
-            await execAsync4(`cd "${gitPath}" && git worktree remove "${workspacePath}" --force 2>/dev/null || true`);
+          const gitPath = join21(projectPath, gitDir);
+          if (existsSync22(join21(gitPath, ".git"))) {
+            await execAsync5(`cd "${gitPath}" && git worktree remove "${workspacePath}" --force 2>/dev/null || true`);
           }
         }
       } catch (e) {
       }
-      if (existsSync21(workspacePath)) {
+      if (existsSync22(workspacePath)) {
         rmSync(workspacePath, { recursive: true, force: true });
       }
       cleanupLog.push(`Deleted workspace: ${workspacePath}`);
@@ -5567,14 +5695,14 @@ import ora12 from "ora";
 
 // src/lib/shadow-utils.ts
 init_esm_shims();
-import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
+import { join as join22 } from "path";
 import { homedir as homedir10 } from "os";
 import chalk25 from "chalk";
 function getLinearApiKey6() {
-  const envFile = join21(homedir10(), ".panopticon.env");
-  if (existsSync22(envFile)) {
-    const content = readFileSync20(envFile, "utf-8");
+  const envFile = join22(homedir10(), ".panopticon.env");
+  if (existsSync23(envFile)) {
+    const content = readFileSync21(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -5673,10 +5801,10 @@ init_esm_shims();
 import chalk27 from "chalk";
 import ora13 from "ora";
 import inquirer4 from "inquirer";
-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 { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9 } from "fs";
+import { join as join23, dirname as dirname7 } from "path";
 import { homedir as homedir11 } from "os";
-var SYNC_QUEUE_FILE = join22(homedir11(), ".panopticon", "sync-queue.json");
+var SYNC_QUEUE_FILE = join23(homedir11(), ".panopticon", "sync-queue.json");
 async function syncToLinear(apiKey, issueId, targetState) {
   try {
     const { LinearClient: LinearClient2 } = await import("@linear/sdk");
@@ -5847,11 +5975,11 @@ async function syncCommand2(id, options = {}) {
   }
 }
 function loadSyncQueue() {
-  if (!existsSync23(SYNC_QUEUE_FILE)) {
+  if (!existsSync24(SYNC_QUEUE_FILE)) {
     return [];
   }
   try {
-    const content = readFileSync21(SYNC_QUEUE_FILE, "utf-8");
+    const content = readFileSync22(SYNC_QUEUE_FILE, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     console.error(chalk27.yellow("Warning: Failed to load sync queue"));
@@ -5860,7 +5988,7 @@ function loadSyncQueue() {
 }
 function saveSyncQueue(queue) {
   const dir = dirname7(SYNC_QUEUE_FILE);
-  if (!existsSync23(dir)) {
+  if (!existsSync24(dir)) {
     mkdirSync9(dir, { recursive: true });
   }
   try {
@@ -5987,8 +6115,8 @@ async function refreshCommand(id, options = {}) {
 init_esm_shims();
 init_tldr_daemon();
 import chalk29 from "chalk";
-import { existsSync as existsSync24, readdirSync as readdirSync14, readFileSync as readFileSync22, statSync as statSync5 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync14, readFileSync as readFileSync23, statSync as statSync5 } from "fs";
+import { join as join24 } from "path";
 async function tldrCommand(action, workspace, options = {}) {
   switch (action) {
     case "status":
@@ -6011,19 +6139,19 @@ async function tldrCommand(action, workspace, options = {}) {
 }
 async function statusCommand2(options) {
   const projectRoot = process.cwd();
-  const venvPath = join23(projectRoot, ".venv");
+  const venvPath = join24(projectRoot, ".venv");
   const results = [];
-  if (existsSync24(venvPath)) {
+  if (existsSync25(venvPath)) {
     const service = getTldrDaemonService(projectRoot, venvPath);
     const status = await service.getStatus();
-    const tldrPath = join23(projectRoot, ".tldr");
+    const tldrPath = join24(projectRoot, ".tldr");
     let indexAge = "N/A";
     let fileCount = "N/A";
-    if (existsSync24(tldrPath)) {
+    if (existsSync25(tldrPath)) {
       try {
-        const langPath = join23(tldrPath, "languages.json");
-        if (existsSync24(langPath)) {
-          const langData = JSON.parse(readFileSync22(langPath, "utf-8"));
+        const langPath = join24(tldrPath, "languages.json");
+        if (existsSync25(langPath)) {
+          const langData = JSON.parse(readFileSync23(langPath, "utf-8"));
           if (langData.timestamp) {
             const ageMs = Date.now() - langData.timestamp * 1e3;
             const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
@@ -6036,9 +6164,9 @@ async function statusCommand2(options) {
           const ageDays = Math.floor(ageMs / (1e3 * 60 * 60 * 24));
           indexAge = ageDays === 0 ? "today" : `${ageDays}d ago`;
         }
-        const cgPath = join23(tldrPath, "cache", "call_graph.json");
-        if (existsSync24(cgPath)) {
-          const cg = JSON.parse(readFileSync22(cgPath, "utf-8"));
+        const cgPath = join24(tldrPath, "cache", "call_graph.json");
+        if (existsSync25(cgPath)) {
+          const cg = JSON.parse(readFileSync23(cgPath, "utf-8"));
           if (Array.isArray(cg.edges)) {
             const files = /* @__PURE__ */ new Set();
             for (const e of cg.edges) {
@@ -6060,23 +6188,23 @@ async function statusCommand2(options) {
       fileCount
     });
   }
-  const workspacesDir = join23(projectRoot, "workspaces");
-  if (existsSync24(workspacesDir)) {
+  const workspacesDir = join24(projectRoot, "workspaces");
+  if (existsSync25(workspacesDir)) {
     const workspaces = readdirSync14(workspacesDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("feature-"));
     for (const ws of workspaces) {
-      const wsPath = join23(workspacesDir, ws.name);
-      const wsVenvPath = join23(wsPath, ".venv");
-      if (existsSync24(wsVenvPath)) {
+      const wsPath = join24(workspacesDir, ws.name);
+      const wsVenvPath = join24(wsPath, ".venv");
+      if (existsSync25(wsVenvPath)) {
         const service = getTldrDaemonService(wsPath, wsVenvPath);
         const status = await service.getStatus();
-        const tldrPath = join23(wsPath, ".tldr");
+        const tldrPath = join24(wsPath, ".tldr");
         let indexAge = "N/A";
         let fileCount = "N/A";
-        if (existsSync24(tldrPath)) {
+        if (existsSync25(tldrPath)) {
           try {
-            const langPath = join23(tldrPath, "languages.json");
-            if (existsSync24(langPath)) {
-              const langData = JSON.parse(readFileSync22(langPath, "utf-8"));
+            const langPath = join24(tldrPath, "languages.json");
+            if (existsSync25(langPath)) {
+              const langData = JSON.parse(readFileSync23(langPath, "utf-8"));
               if (langData.timestamp) {
                 const ageMs = Date.now() - langData.timestamp * 1e3;
                 const ageHours = Math.floor(ageMs / (1e3 * 60 * 60));
@@ -6089,9 +6217,9 @@ async function statusCommand2(options) {
               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 = join23(tldrPath, "cache", "call_graph.json");
-            if (existsSync24(cgPath)) {
-              const cg = JSON.parse(readFileSync22(cgPath, "utf-8"));
+            const cgPath = join24(tldrPath, "cache", "call_graph.json");
+            if (existsSync25(cgPath)) {
+              const cg = JSON.parse(readFileSync23(cgPath, "utf-8"));
               if (Array.isArray(cg.edges)) {
                 const files = /* @__PURE__ */ new Set();
                 for (const e of cg.edges) {
@@ -6141,13 +6269,13 @@ async function statusCommand2(options) {
 async function startCommand(workspace, options) {
   const projectRoot = process.cwd();
   if (workspace) {
-    const wsPath = join23(projectRoot, "workspaces", workspace);
-    const venvPath = join23(wsPath, ".venv");
-    if (!existsSync24(wsPath)) {
+    const wsPath = join24(projectRoot, "workspaces", workspace);
+    const venvPath = join24(wsPath, ".venv");
+    if (!existsSync25(wsPath)) {
       console.error(chalk29.red(`Error: Workspace not found: ${workspace}`));
       process.exit(1);
     }
-    if (!existsSync24(venvPath)) {
+    if (!existsSync25(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);
@@ -6158,8 +6286,8 @@ async function startCommand(workspace, options) {
       console.log(chalk29.green(`\u2713 Started TLDR daemon for ${workspace}`));
     }
   } else {
-    const venvPath = join23(projectRoot, ".venv");
-    if (!existsSync24(venvPath)) {
+    const venvPath = join24(projectRoot, ".venv");
+    if (!existsSync25(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);
@@ -6174,13 +6302,13 @@ async function startCommand(workspace, options) {
 async function stopCommand(workspace, options) {
   const projectRoot = process.cwd();
   if (workspace) {
-    const wsPath = join23(projectRoot, "workspaces", workspace);
-    const venvPath = join23(wsPath, ".venv");
-    if (!existsSync24(wsPath)) {
+    const wsPath = join24(projectRoot, "workspaces", workspace);
+    const venvPath = join24(wsPath, ".venv");
+    if (!existsSync25(wsPath)) {
       console.error(chalk29.red(`Error: Workspace not found: ${workspace}`));
       process.exit(1);
     }
-    if (!existsSync24(venvPath)) {
+    if (!existsSync25(venvPath)) {
       console.error(chalk29.red(`Error: No .venv found in workspace: ${workspace}`));
       process.exit(1);
     }
@@ -6190,8 +6318,8 @@ async function stopCommand(workspace, options) {
       console.log(chalk29.green(`\u2713 Stopped TLDR daemon for ${workspace}`));
     }
   } else {
-    const venvPath = join23(projectRoot, ".venv");
-    if (!existsSync24(venvPath)) {
+    const venvPath = join24(projectRoot, ".venv");
+    if (!existsSync25(venvPath)) {
       console.error(chalk29.red("Error: No .venv found in project root"));
       process.exit(1);
     }
@@ -6205,13 +6333,13 @@ async function stopCommand(workspace, options) {
 async function warmCommand(workspace, options) {
   const projectRoot = process.cwd();
   if (workspace) {
-    const wsPath = join23(projectRoot, "workspaces", workspace);
-    const venvPath = join23(wsPath, ".venv");
-    if (!existsSync24(wsPath)) {
+    const wsPath = join24(projectRoot, "workspaces", workspace);
+    const venvPath = join24(wsPath, ".venv");
+    if (!existsSync25(wsPath)) {
       console.error(chalk29.red(`Error: Workspace not found: ${workspace}`));
       process.exit(1);
     }
-    if (!existsSync24(venvPath)) {
+    if (!existsSync25(venvPath)) {
       console.error(chalk29.red(`Error: No .venv found in workspace: ${workspace}`));
       process.exit(1);
     }
@@ -6225,8 +6353,8 @@ async function warmCommand(workspace, options) {
       console.log(chalk29.green(`\u2713 Index warming complete for ${workspace}`));
     }
   } else {
-    const venvPath = join23(projectRoot, ".venv");
-    if (!existsSync24(venvPath)) {
+    const venvPath = join24(projectRoot, ".venv");
+    if (!existsSync25(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);
@@ -6309,8 +6437,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 readFileSync24 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync25 } from "fs";
+import { join as join27 } from "path";
 import { homedir as homedir12 } from "os";
 
 // src/lib/lifecycle/index.ts
@@ -6320,11 +6448,11 @@ init_esm_shims();
 init_esm_shims();
 init_paths();
 init_tmux();
-import { existsSync as existsSync25, rmSync as rmSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join24, basename as basename5 } from "path";
-import { exec as exec5 } from "child_process";
-import { promisify as promisify5 } from "util";
-var execAsync5 = promisify5(exec5);
+import { existsSync as existsSync26, rmSync as rmSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join25, basename as basename5 } from "path";
+import { exec as exec6 } from "child_process";
+import { promisify as promisify6 } from "util";
+var execAsync6 = promisify6(exec6);
 async function killTmuxSessions(issueLower) {
   const step = "teardown:tmux-sessions";
   const patterns = [
@@ -6338,7 +6466,7 @@ async function killTmuxSessions(issueLower) {
   for (const session of patterns) {
     if (sessionExists(session)) {
       try {
-        await execAsync5(`tmux kill-session -t ${session}`);
+        await execAsync6(`tmux kill-session -t ${session}`);
         killed++;
       } catch {
       }
@@ -6351,8 +6479,8 @@ async function killTmuxSessions(issueLower) {
 }
 async function stopTldrDaemon(workspacePath) {
   const step = "teardown:tldr-daemon";
-  const venvPath = join24(workspacePath, ".venv");
-  if (!existsSync25(venvPath)) {
+  const venvPath = join25(workspacePath, ".venv");
+  if (!existsSync26(venvPath)) {
     return stepSkipped(step, ["No .venv found"]);
   }
   try {
@@ -6367,20 +6495,95 @@ async function stopTldrDaemon(workspacePath) {
 async function stopDocker(workspacePath, projectName, issueLower) {
   const step = "teardown:docker";
   try {
-    const { stopWorkspaceDocker } = await import("../workspace-manager-OWHLR5BL.js");
+    const { stopWorkspaceDocker } = await import("../workspace-manager-6RP5A5HF.js");
     await stopWorkspaceDocker(workspacePath, projectName, issueLower);
     return stepOk(step, ["Stopped Docker containers"]);
   } catch {
     return stepSkipped(step, ["Docker cleanup skipped (not running or failed)"]);
   }
 }
+async function syncWorkspaceBeads(projectPath, workspacePath, issueLower) {
+  const step = "teardown:sync-beads";
+  const workspaceBeadsDir = join25(workspacePath, ".beads");
+  if (!existsSync26(workspaceBeadsDir)) {
+    return stepSkipped(step, ["No .beads directory in workspace"]);
+  }
+  try {
+    const { stdout: exportOutput } = await execAsync6(
+      "bd export --output .beads/issues-export.jsonl 2>&1 || true",
+      { cwd: workspacePath, encoding: "utf-8", timeout: 15e3 }
+    );
+    const exportPath = join25(workspacePath, ".beads", "issues-export.jsonl");
+    if (!existsSync26(exportPath)) {
+      await execAsync6("bd sync 2>&1 || true", { cwd: workspacePath, encoding: "utf-8", timeout: 15e3 });
+    }
+    try {
+      await execAsync6(
+        `bd import "${join25(workspacePath, ".beads", "issues.jsonl")}" 2>&1 || true`,
+        { cwd: projectPath, encoding: "utf-8", timeout: 15e3 }
+      );
+      return stepOk(step, [`Synced workspace beads to project root for ${issueLower}`]);
+    } catch {
+      const { readFileSync: readFileSync49, appendFileSync: appendFileSync4 } = await import("fs");
+      const wsJsonl = join25(workspacePath, ".beads", "issues.jsonl");
+      const projJsonl = join25(projectPath, ".beads", "issues.jsonl");
+      if (existsSync26(wsJsonl) && existsSync26(projJsonl)) {
+        const wsContent = readFileSync49(wsJsonl, "utf-8");
+        const issuePattern = issueLower.replace("-", "[-_]");
+        const relevantLines = wsContent.split("\n").filter(
+          (line) => line.trim() && new RegExp(issuePattern, "i").test(line)
+        );
+        if (relevantLines.length > 0) {
+          appendFileSync4(projJsonl, "\n" + relevantLines.join("\n"));
+          return stepOk(step, [`Appended ${relevantLines.length} beads entries for ${issueLower} to project JSONL`]);
+        }
+      }
+      return stepSkipped(step, ["No beads to sync or import not available"]);
+    }
+  } catch (err) {
+    return stepFailed(step, `Failed to sync workspace beads: ${err.message}`);
+  }
+}
+async function clearProjectBeads(projectPath, issueLower) {
+  const step = "teardown:clear-beads";
+  const projJsonl = join25(projectPath, ".beads", "issues.jsonl");
+  if (!existsSync26(projJsonl)) {
+    return stepSkipped(step, ["No .beads/issues.jsonl in project root"]);
+  }
+  try {
+    const { readFileSync: readFileSync49, writeFileSync: writeFileSync27 } = await import("fs");
+    const content = readFileSync49(projJsonl, "utf-8");
+    const lines = content.split("\n");
+    const issueUpper = issueLower.toUpperCase();
+    const before = lines.length;
+    const filtered = lines.filter((line) => {
+      if (!line.trim()) return true;
+      try {
+        const entry = JSON.parse(line);
+        const title = (entry.title || "").toUpperCase();
+        const issue = (entry.issue || "").toUpperCase();
+        return !title.includes(issueUpper) && issue !== issueUpper;
+      } catch {
+        return true;
+      }
+    });
+    const removed = before - filtered.length;
+    if (removed > 0) {
+      writeFileSync27(projJsonl, filtered.join("\n"));
+      return stepOk(step, [`Removed ${removed} beads entries for ${issueLower} from project JSONL`]);
+    }
+    return stepSkipped(step, [`No beads entries found for ${issueLower}`]);
+  } catch (err) {
+    return stepFailed(step, `Failed to clear beads: ${err.message}`);
+  }
+}
 async function removeWorktree(projectPath, workspacePath) {
   const step = "teardown:worktree";
-  if (!existsSync25(workspacePath)) {
+  if (!existsSync26(workspacePath)) {
     return stepSkipped(step, ["Workspace directory does not exist"]);
   }
   try {
-    await execAsync5(`git worktree remove "${workspacePath}" --force`, { cwd: projectPath });
+    await execAsync6(`git worktree remove "${workspacePath}" --force`, { cwd: projectPath });
     return stepOk(step, ["Removed git worktree"]);
   } catch {
     try {
@@ -6394,12 +6597,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}`)
+    join25(AGENTS_DIR, `agent-${issueLower}`),
+    join25(AGENTS_DIR, `planning-${issueLower}`)
   ];
   let removed = 0;
   for (const dir of dirs) {
-    if (existsSync25(dir)) {
+    if (existsSync26(dir)) {
       rmSync2(dir, { recursive: true, force: true });
       removed++;
     }
@@ -6414,13 +6617,13 @@ async function deleteBranches(projectPath, issueLower) {
   const branchName = `feature/${issueLower}`;
   const details = [];
   try {
-    await execAsync5(`git branch -D "${branchName}"`, { cwd: projectPath, encoding: "utf-8" });
+    await execAsync6(`git branch -D "${branchName}"`, { cwd: projectPath, encoding: "utf-8" });
     details.push(`Deleted local branch ${branchName}`);
   } catch {
     details.push(`Local branch ${branchName} not found (already deleted)`);
   }
   try {
-    await execAsync5(`git push origin --delete "${branchName}"`, { cwd: projectPath, encoding: "utf-8" });
+    await execAsync6(`git push origin --delete "${branchName}"`, { cwd: projectPath, encoding: "utf-8" });
     details.push(`Deleted remote branch ${branchName}`);
   } catch {
     details.push(`Remote branch ${branchName} not found (already deleted)`);
@@ -6442,8 +6645,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 = join25(projectPath, ".planning", issueLower);
+  if (existsSync26(legacyDir)) {
     rmSync2(legacyDir, { recursive: true, force: true });
     return stepOk(step, [`Deleted legacy planning dir: ${legacyDir}`]);
   }
@@ -6451,8 +6654,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 = join25(workspacePath, ".planning", ".planning-complete");
+  if (existsSync26(markerPath)) {
     unlinkSync2(markerPath);
     return stepOk(step, ["Cleared .planning-complete marker"]);
   }
@@ -6503,7 +6706,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 && existsSync26(workspacePath)) {
     if (shouldDeleteWorkspace) {
       results.push(await stopTldrDaemon(workspacePath));
     }
@@ -6511,6 +6714,11 @@ async function teardownWorkspace(ctx, opts = {}) {
       results.push(await stopDocker(workspacePath, projName, issueLower));
     }
     results.push(await clearPlanningMarker(workspacePath));
+    if (opts.clearBeads) {
+      results.push(await clearProjectBeads(ctx.projectPath, issueLower));
+    } else if (shouldDeleteWorkspace) {
+      results.push(await syncWorkspaceBeads(ctx.projectPath, workspacePath, issueLower));
+    }
     if (shouldDeleteWorkspace && (opts.workspaceConfig?.tunnel || opts.workspaceConfig?.hume)) {
       const placeholders = buildPlaceholders(ctx, opts, workspacePath);
       if (opts.workspaceConfig.tunnel) {
@@ -6536,11 +6744,11 @@ async function teardownWorkspace(ctx, opts = {}) {
 // src/lib/lifecycle/workflows.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync26, readFileSync as readFileSync23 } from "fs";
-import { join as join25 } from "path";
-import { exec as exec6 } from "child_process";
-import { promisify as promisify6 } from "util";
-var execAsync6 = promisify6(exec6);
+import { existsSync as existsSync27, readFileSync as readFileSync24 } from "fs";
+import { join as join26 } from "path";
+import { exec as exec7 } from "child_process";
+import { promisify as promisify7 } from "util";
+var execAsync7 = promisify7(exec7);
 function buildResult(workflow, issueId, steps, startTime) {
   return {
     workflow,
@@ -6591,19 +6799,19 @@ async function verifyBranchMerged(ctx) {
       }
     } catch {
     }
-    const { stdout: branchExists } = await execAsync6(
+    const { stdout: branchExists } = await execAsync7(
       `git branch --list "${branchName}" 2>/dev/null || true`,
       { cwd: ctx.projectPath, encoding: "utf-8" }
     );
     if (branchExists.trim()) {
       try {
-        await execAsync6(
+        await execAsync7(
           `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 execAsync6(
+        const { stdout: unmerged } = await execAsync7(
           `git log main..${branchName} --oneline 2>/dev/null || true`,
           { cwd: ctx.projectPath, encoding: "utf-8" }
         );
@@ -6611,21 +6819,21 @@ async function verifyBranchMerged(ctx) {
         return stepFailed(step, `${count} unmerged commit(s) on ${branchName}. Merge before closing out.`);
       }
     }
-    const { stdout: remoteBranch } = await execAsync6(
+    const { stdout: remoteBranch } = await execAsync7(
       `git ls-remote --heads origin "${branchName}" 2>/dev/null || true`,
       { cwd: ctx.projectPath, encoding: "utf-8" }
     );
     if (remoteBranch.trim()) {
-      await execAsync6(`git fetch origin ${branchName}`, { cwd: ctx.projectPath }).catch(() => {
+      await execAsync7(`git fetch origin ${branchName}`, { cwd: ctx.projectPath }).catch(() => {
       });
       try {
-        await execAsync6(
+        await execAsync7(
           `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 execAsync6(
+        const { stdout: remoteUnmerged } = await execAsync7(
           `git log main..origin/${branchName} --oneline 2>/dev/null || true`,
           { cwd: ctx.projectPath, encoding: "utf-8" }
         );
@@ -6646,9 +6854,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(readFileSync23(statusFile, "utf-8"));
+      const statusFile = join26(PANOPTICON_HOME, "review-status.json");
+      if (existsSync27(statusFile)) {
+        const data = JSON.parse(readFileSync24(statusFile, "utf-8"));
         const upperKey = issueId.toUpperCase();
         if (data[upperKey]) {
           delete data[upperKey];
@@ -6666,9 +6874,9 @@ async function clearReviewStatusStep(issueId) {
 // src/cli/commands/work/close-out.ts
 init_projects();
 function getGitHubConfig2() {
-  const envFile = join26(homedir12(), ".panopticon.env");
-  if (!existsSync27(envFile)) return null;
-  const content = readFileSync24(envFile, "utf-8");
+  const envFile = join27(homedir12(), ".panopticon.env");
+  if (!existsSync28(envFile)) return null;
+  const content = readFileSync25(envFile, "utf-8");
   const reposMatch = content.match(/GITHUB_REPOS=(.+)/);
   if (!reposMatch) return null;
   const repoStr = reposMatch[1].trim();
@@ -6775,13 +6983,13 @@ Running close-out for ${issueUpper}...
 // src/cli/commands/work/linear-states.ts
 init_esm_shims();
 import chalk32 from "chalk";
-import { readFileSync as readFileSync25, existsSync as existsSync28 } from "fs";
+import { readFileSync as readFileSync26, existsSync as existsSync29 } from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function getLinearApiKey8() {
-  const envFile = join27(homedir13(), ".panopticon.env");
-  if (existsSync28(envFile)) {
-    const content = readFileSync25(envFile, "utf-8");
+  const envFile = join28(homedir13(), ".panopticon.env");
+  if (existsSync29(envFile)) {
+    const content = readFileSync26(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -6970,8 +7178,8 @@ function registerWorkCommands(program2) {
 init_esm_shims();
 import chalk33 from "chalk";
 import ora16 from "ora";
-import { existsSync as existsSync29, writeFileSync as writeFileSync10, rmSync as rmSync3, readFileSync as readFileSync26, realpathSync } from "fs";
-import { join as join28, basename as basename6, resolve } from "path";
+import { existsSync as existsSync30, writeFileSync as writeFileSync10, rmSync as rmSync3, readFileSync as readFileSync27, realpathSync } from "fs";
+import { join as join29, basename as basename6, resolve } from "path";
 
 // src/lib/worktree.ts
 init_esm_shims();
@@ -7034,13 +7242,13 @@ init_agents();
 init_projects();
 init_workspace_manager();
 init_config();
-import { exec as exec7 } from "child_process";
-import { promisify as promisify7 } from "util";
+import { exec as exec8 } from "child_process";
+import { promisify as promisify8 } from "util";
 import { homedir as homedir14 } from "os";
-var execAsync7 = promisify7(exec7);
+var execAsync8 = promisify8(exec8);
 async function getBeadsVersion() {
   try {
-    const { stdout } = await execAsync7("bd --version", { encoding: "utf-8" });
+    const { stdout } = await execAsync8("bd --version", { encoding: "utf-8" });
     const match = stdout.match(/(\d+)\.(\d+)\.(\d+)/);
     if (match) {
       const [, , minor, patch] = match.map(Number);
@@ -7064,23 +7272,23 @@ async function initializeWorkspaceBeads(workspacePath, issueId) {
   try {
     const beadsVersion = await getBeadsVersion();
     if (beadsVersion >= 4701) {
-      const workspaceLabel = `workspace:${issueId.toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
+      const issueLabel = issueId.toLowerCase();
       const title = `${issueId.toUpperCase()}: Implementation`;
-      const { stdout } = await execAsync7(
-        `bd create --title "${title}" --priority 1 --type task --labels "${workspaceLabel}" 2>&1`,
+      const { stdout } = await execAsync8(
+        `bd create --title "${title}" --priority 1 --type task --labels "${issueLabel}" 2>&1`,
         { cwd: workspacePath, encoding: "utf-8" }
       );
       const match = stdout.match(/([a-z]+-[a-z0-9]+)/);
       return { success: true, beadId: match?.[1] };
     } else {
-      const beadsDir = join28(workspacePath, ".beads");
-      if (existsSync29(beadsDir)) {
+      const beadsDir = join29(workspacePath, ".beads");
+      if (existsSync30(beadsDir)) {
         rmSync3(beadsDir, { recursive: true, force: true });
       }
       const prefix = "workspace";
-      await execAsync7(`bd init --prefix ${prefix}`, { cwd: workspacePath, encoding: "utf-8" });
+      await execAsync8(`bd init --prefix ${prefix}`, { cwd: workspacePath, encoding: "utf-8" });
       const title = `${issueId.toUpperCase()}: Implementation`;
-      const { stdout } = await execAsync7(
+      const { stdout } = await execAsync8(
         `bd create --title "${title}" --priority 1 --type task --json`,
         { cwd: workspacePath, encoding: "utf-8" }
       );
@@ -7203,7 +7411,7 @@ async function createCommand(issueId, options) {
       const dockerFlag = options.docker ? " --docker" : "";
       const cmd = `${projectConfig.workspace_command} ${normalizedId}${dockerFlag}`;
       try {
-        const { stdout } = await execAsync7(cmd, {
+        const { stdout } = await execAsync8(cmd, {
           cwd: projectConfig.path,
           encoding: "utf-8",
           timeout: options.docker ? 3e5 : 12e4
@@ -7239,8 +7447,8 @@ async function createCommand(issueId, options) {
         projectRoot = process.cwd();
       }
     }
-    const workspacesDir = join28(projectRoot, "workspaces");
-    const workspacePath = join28(workspacesDir, folderName);
+    const workspacesDir = join29(projectRoot, "workspaces");
+    const workspacePath = join29(workspacesDir, folderName);
     if (options.dryRun) {
       spinner.info("Dry run mode");
       console.log("");
@@ -7253,11 +7461,11 @@ async function createCommand(issueId, options) {
       console.log(`  Branch:    ${chalk33.cyan(branchName)}`);
       return;
     }
-    if (existsSync29(workspacePath)) {
+    if (existsSync30(workspacePath)) {
       spinner.fail(`Workspace already exists: ${workspacePath}`);
       process.exit(1);
     }
-    if (!existsSync29(join28(projectRoot, ".git"))) {
+    if (!existsSync30(join29(projectRoot, ".git"))) {
       spinner.fail("Not a git repository. Run this from the project root.");
       process.exit(1);
     }
@@ -7266,7 +7474,7 @@ async function createCommand(issueId, options) {
     const resolvedWorkspace = resolve(workspacePath);
     const resolvedPlanning = resolve(resolvedWorkspace, ".planning");
     const isUnderWorkspacesDir = resolvedWorkspace.match(/\/workspaces\/feature-[a-z0-9-]+$/);
-    if (isUnderWorkspacesDir && resolvedPlanning === join28(resolvedWorkspace, ".planning") && existsSync29(join28(resolvedWorkspace, ".git")) && existsSync29(resolvedPlanning)) {
+    if (isUnderWorkspacesDir && resolvedPlanning === join29(resolvedWorkspace, ".planning") && existsSync30(join29(resolvedWorkspace, ".git")) && existsSync30(resolvedPlanning)) {
       rmSync3(resolvedPlanning, { recursive: true, force: true });
       console.log("  Removed stale .planning/ directory from previous issue");
     }
@@ -7288,7 +7496,7 @@ async function createCommand(issueId, options) {
       BEAD_ID: workspaceBeadId
     };
     const claudeMd = generateClaudeMd(projectRoot, variables);
-    writeFileSync10(join28(workspacePath, "CLAUDE.md"), claudeMd);
+    writeFileSync10(join29(workspacePath, "CLAUDE.md"), claudeMd);
     let skillsResult = { added: [], updated: [], skipped: [], overlayed: [] };
     if (options.skills !== false) {
       spinner.text = "Merging skills and agents...";
@@ -7298,20 +7506,20 @@ 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")
+        join29(workspacePath, "docker-compose.yml"),
+        join29(workspacePath, "docker-compose.yaml"),
+        join29(workspacePath, ".devcontainer", "docker-compose.yml"),
+        join29(workspacePath, ".devcontainer", "docker-compose.yaml"),
+        join29(workspacePath, ".devcontainer", "docker-compose.devcontainer.yml"),
+        join29(workspacePath, ".devcontainer", "compose.yml"),
+        join29(workspacePath, ".devcontainer", "compose.yaml")
       ];
-      const composeFile = composeLocations.find((f) => existsSync29(f));
+      const composeFile = composeLocations.find((f) => existsSync30(f));
       if (composeFile) {
         spinner.text = "Starting Docker containers...";
         try {
-          const composeDir = join28(composeFile, "..");
-          await execAsync7(`docker compose -f "${composeFile}" up -d --build`, {
+          const composeDir = join29(composeFile, "..");
+          await execAsync8(`docker compose -f "${composeFile}" up -d --build`, {
             cwd: composeDir,
             encoding: "utf-8",
             timeout: 3e5
@@ -7377,15 +7585,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 = join29(config2.path, repo.path);
+          if (!existsSync30(join29(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 = join29(config2.path, "workspaces", workspaceDir);
                 if (!workspaces2.some((w) => w.path === canonicalPath)) {
                   workspaces2.push({ ...wt, path: canonicalPath });
                 }
@@ -7394,7 +7602,7 @@ async function listCommand2(options) {
           }
         }
       } else {
-        if (!existsSync29(join28(config2.path, ".git"))) continue;
+        if (!existsSync30(join29(config2.path, ".git"))) continue;
         const worktrees2 = listWorktrees(config2.path);
         for (const wt of worktrees2) {
           if (wt.path.includes("/workspaces/") || wt.path.includes("\\workspaces\\")) {
@@ -7434,7 +7642,7 @@ ${proj.projectName}
     return;
   }
   const projectRoot = process.cwd();
-  if (!existsSync29(join28(projectRoot, ".git"))) {
+  if (!existsSync30(join29(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."));
@@ -7504,7 +7712,7 @@ async function destroyCommand(issueId, options) {
       spinner.text = "Running custom remove command...";
       const cmd = `${projectConfig.workspace_remove_command} ${normalizedId}`;
       try {
-        const { stdout } = await execAsync7(cmd, {
+        const { stdout } = await execAsync8(cmd, {
           cwd: projectConfig.path,
           encoding: "utf-8",
           timeout: 12e4
@@ -7530,17 +7738,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 = join29(projectRoot, "workspaces", folderName);
+    if (!existsSync30(workspacePath)) {
+      const cwdPath = join29(process.cwd(), "workspaces", folderName);
+      if (projectRoot !== process.cwd() && existsSync30(cwdPath)) {
         projectRoot = process.cwd();
       } else {
         spinner.fail(`Workspace not found: ${workspacePath}`);
         process.exit(1);
       }
     }
-    const finalWorkspacePath = join28(projectRoot, "workspaces", folderName);
+    const finalWorkspacePath = join29(projectRoot, "workspaces", folderName);
     spinner.text = "Removing git worktree...";
     removeWorktree2(projectRoot, finalWorkspacePath);
     spinner.succeed(`Workspace destroyed: ${folderName}`);
@@ -7578,7 +7786,7 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
   }
   if (!projectId) {
     try {
-      const { stdout } = await execAsync7("git remote get-url origin", {
+      const { stdout } = await execAsync8("git remote get-url origin", {
         cwd: projectRoot,
         encoding: "utf-8"
       });
@@ -7603,7 +7811,7 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
     const vmInfo = await fly.createVm(vmName);
     let repoUrl = "";
     try {
-      const { stdout } = await execAsync7("git remote get-url origin", {
+      const { stdout } = await execAsync8("git remote get-url origin", {
         cwd: projectRoot,
         encoding: "utf-8"
       });
@@ -7624,13 +7832,13 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
       await fly.ssh(vmName, `ssh-keyscan -t ed25519,rsa ${gitHost} >> ~/.ssh/known_hosts 2>/dev/null`);
     }
     const sshKeyPaths = [
-      join28(homedir14(), ".panopticon", "ssh", "exe-dev-key"),
-      join28(homedir14(), ".ssh", "id_ed25519"),
-      join28(homedir14(), ".ssh", "id_rsa")
+      join29(homedir14(), ".panopticon", "ssh", "exe-dev-key"),
+      join29(homedir14(), ".ssh", "id_ed25519"),
+      join29(homedir14(), ".ssh", "id_rsa")
     ];
-    const sshKeyPath = sshKeyPaths.find((p) => existsSync29(p));
+    const sshKeyPath = sshKeyPaths.find((p) => existsSync30(p));
     if (sshKeyPath) {
-      const sshKeyBase64 = Buffer.from(readFileSync26(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 fly.ssh(vmName, `echo '${sshKeyBase64}' | base64 -d > ~/.ssh/${keyFilename} && chmod 600 ~/.ssh/${keyFilename}`);
     }
@@ -7646,11 +7854,11 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
       await fly.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 = join29(projectRoot, repo.path);
+        const actualRepoPath = existsSync30(rawRepoPath) ? realpathSync(rawRepoPath) : rawRepoPath;
         let repoRemoteUrl;
         try {
-          const { stdout } = await execAsync7("git remote get-url origin", {
+          const { stdout } = await execAsync8("git remote get-url origin", {
             cwd: actualRepoPath,
             encoding: "utf-8"
           });
@@ -7686,7 +7894,7 @@ async function createRemoteWorkspace(issueId, normalizedId, branchName, spinner,
     spinner.text = "Configuring Claude Code...";
     await fly.ssh(vmName, `mkdir -p ~/.claude`);
     try {
-      const { stdout: credentials } = await execAsync7(
+      const { stdout: credentials } = await execAsync8(
         'security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null',
         { encoding: "utf-8" }
       );
@@ -7777,8 +7985,8 @@ async function migrateCommand(issueId, options) {
     }
     spinner.text = "Syncing beads...";
     try {
-      await execAsync7("bd sync", { encoding: "utf-8" });
-      await execAsync7('git add .beads/ && git commit -m "Sync beads before migration" && git push', { encoding: "utf-8" });
+      await execAsync8("bd sync", { encoding: "utf-8" });
+      await execAsync8('git add .beads/ && git commit -m "Sync beads before migration" && git push', { encoding: "utf-8" });
     } catch {
     }
     const branchName = `feature/${normalizedId}`;
@@ -7906,8 +8114,8 @@ async function destroyRemoteWorkspace(issueId, normalizedId, metadata, spinner,
     await fly.ssh(metadata.vmName, `tmux kill-session -t ${agentId} 2>/dev/null || true`);
     spinner.text = "Deleting VM...";
     await fly.deleteVm(metadata.vmName);
-    const metadataFile = join28(WORKSPACES_DIR, `${normalizedId}.yaml`);
-    if (existsSync29(metadataFile)) {
+    const metadataFile = join29(WORKSPACES_DIR, `${normalizedId}.yaml`);
+    if (existsSync30(metadataFile)) {
       rmSync3(metadataFile);
     }
     spinner.succeed(`Remote workspace ${issueId} destroyed`);
@@ -7933,9 +8141,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 = join29(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
+    const workspacePath = join29(workspacesDir, folderName);
+    if (!existsSync30(workspacePath)) {
       spinner.fail(`Workspace not found: ${workspacePath}`);
       process.exit(1);
     }
@@ -7955,7 +8163,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 = join29(projectConfig.path, workspaceConfig.agent.template_dir);
       const overlayed = applyProjectTemplateOverlay(workspacePath, templateDir);
       result.overlayed = overlayed;
     }
@@ -7987,12 +8195,12 @@ import ora17 from "ora";
 // src/lib/test-runner.ts
 init_esm_shims();
 init_workspace_config();
-import { existsSync as existsSync30, mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "fs";
-import { join as join29, basename as basename7 } from "path";
-import { exec as exec8 } from "child_process";
-import { promisify as promisify8 } from "util";
+import { existsSync as existsSync31, mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "fs";
+import { join as join30, basename as basename7 } from "path";
+import { exec as exec9 } from "child_process";
+import { promisify as promisify9 } from "util";
 import { homedir as homedir15 } from "os";
-var execAsync8 = promisify8(exec8);
+var execAsync9 = promisify9(exec9);
 function formatDuration(seconds) {
   const minutes = Math.floor(seconds / 60);
   const secs = seconds % 60;
@@ -8042,8 +8250,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 = join30(workspacePath, testConfig.path);
+  const logFile = join30(reportsDir, `${testName}-${timestamp}.log`);
   const result = {
     name: testName,
     status: "pending",
@@ -8066,7 +8274,7 @@ async function runTestSuite(testName, testConfig, workspacePath, placeholders, r
   }
   const startTime = Date.now();
   try {
-    const { stdout, stderr } = await execAsync8(command, {
+    const { stdout, stderr } = await execAsync9(command, {
       cwd: testPath,
       env,
       timeout: 6e5,
@@ -8135,10 +8343,10 @@ function generateReport2(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(homedir15(), ".panopticon", "bin", "notify-complete");
-  if (existsSync30(notifyScript)) {
+  const notifyScript = join30(homedir15(), ".panopticon", "bin", "notify-complete");
+  if (existsSync31(notifyScript)) {
     try {
-      await execAsync8(`"${notifyScript}" "${result.target}" "${message}"`);
+      await execAsync9(`"${notifyScript}" "${result.target}" "${message}"`);
     } catch {
     }
   }
@@ -8154,12 +8362,12 @@ async function runTests(options) {
   let target;
   let baseUrl;
   if (featureName) {
-    const workspacesDir = join29(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
+    const workspacesDir = join30(projectConfig.path, workspaceConfig?.workspaces_dir || "workspaces");
     const featureFolder2 = `feature-${featureName}`;
-    workspacePath = join29(workspacesDir, featureFolder2);
+    workspacePath = join30(workspacesDir, featureFolder2);
     target = featureFolder2;
     baseUrl = workspaceConfig?.dns?.domain ? `https://${featureFolder2}.${workspaceConfig.dns.domain}` : `http://localhost:3000`;
-    if (!existsSync30(workspacePath)) {
+    if (!existsSync31(workspacePath)) {
       throw new Error(`Workspace not found: ${workspacePath}`);
     }
   } else {
@@ -8176,13 +8384,13 @@ async function runTests(options) {
     DOMAIN: workspaceConfig?.dns?.domain || "localhost",
     PROJECT_NAME: basename7(projectConfig.path),
     PROJECT_PATH: projectConfig.path,
-    PROJECTS_DIR: join29(projectConfig.path, ".."),
+    PROJECTS_DIR: join30(projectConfig.path, ".."),
     WORKSPACE_PATH: workspacePath
   };
-  const reportsDir = join29(projectConfig.path, "reports");
+  const reportsDir = join30(projectConfig.path, "reports");
   mkdirSync12(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 = join30(reportsDir, `test-run-${target}-${timestamp}.md`);
   const result = {
     target,
     baseUrl,
@@ -8346,21 +8554,21 @@ 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 mkdirSync13, writeFileSync as writeFileSync12, readFileSync as readFileSync27, copyFileSync, readdirSync as readdirSync15, statSync as statSync6 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync13, writeFileSync as writeFileSync12, readFileSync as readFileSync28, copyFileSync, readdirSync as readdirSync15, statSync as statSync6 } from "fs";
+import { join as join31 } from "path";
 import { homedir as homedir16 } from "os";
 function registerInstallCommand(program2) {
   program2.command("install").description("Install Panopticon prerequisites").option("--check", "Check prerequisites only").option("--minimal", "Skip Traefik and mkcert (use port-based routing)").option("--skip-mkcert", "Skip mkcert/HTTPS setup").option("--skip-docker", "Skip Docker network setup").option("--skip-beads", "Skip beads CLI installation").option("--skip-router", "Skip claude-code-router installation").option("--skip-sageox", "Skip SageOx CLI installation").action(installCommand);
 }
 function copyDirectoryRecursive(source, dest) {
-  if (!existsSync31(source)) {
+  if (!existsSync32(source)) {
     throw new Error(`Source directory not found: ${source}`);
   }
   mkdirSync13(dest, { recursive: true });
   const entries = readdirSync15(source);
   for (const entry of entries) {
-    const sourcePath = join30(source, entry);
-    const destPath = join30(dest, entry);
+    const sourcePath = join31(source, entry);
+    const destPath = join31(dest, entry);
     const stat = statSync6(sourcePath);
     if (stat.isDirectory()) {
       copyDirectoryRecursive(sourcePath, destPath);
@@ -8460,7 +8668,7 @@ function checkPrerequisites() {
     message: hasJq ? "installed" : "not found",
     fix: "apt install jq / brew install jq"
   });
-  const hasTtyd = checkCommand2("ttyd") || existsSync31(join30(homedir16(), "bin", "ttyd"));
+  const hasTtyd = checkCommand2("ttyd") || existsSync32(join31(homedir16(), "bin", "ttyd"));
   results.push({
     name: "ttyd",
     passed: hasTtyd,
@@ -8536,9 +8744,9 @@ async function installCommand(options) {
           execSync4("brew install mkcert", { stdio: "pipe", timeout: 12e4 });
           spinner.succeed("mkcert installed via Homebrew");
         } else {
-          const binDir = join30(homedir16(), ".local", "bin");
+          const binDir = join31(homedir16(), ".local", "bin");
           mkdirSync13(binDir, { recursive: true });
-          const mkcertPath = join30(binDir, "mkcert");
+          const mkcertPath = join31(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",
@@ -8557,14 +8765,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 = join31(TRAEFIK_CERTS_DIR, "_wildcard.pan.localhost.pem");
+        const traefikKeyFile = join31(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 = join31(CERTS_DIR, "localhost.pem");
+        const legacyKeyFile = join31(CERTS_DIR, "localhost-key.pem");
         copyFileSync(traefikCertFile, legacyCertFile);
         copyFileSync(traefikKeyFile, legacyKeyFile);
         spinner.succeed("Wildcard certificates generated (*.pan.localhost, *.localhost)");
@@ -8582,13 +8790,13 @@ async function installCommand(options) {
       spinner.info("Skipping mkcert (not installed)");
     }
   }
-  const hasTtyd = checkCommand2("ttyd") || existsSync31(join30(homedir16(), "bin", "ttyd"));
+  const hasTtyd = checkCommand2("ttyd") || existsSync32(join31(homedir16(), "bin", "ttyd"));
   if (!hasTtyd) {
     spinner.start("Installing ttyd (web terminal)...");
     try {
-      const binDir = join30(homedir16(), "bin");
+      const binDir = join31(homedir16(), "bin");
       mkdirSync13(binDir, { recursive: true });
-      const ttydPath = join30(binDir, "ttyd");
+      const ttydPath = join31(binDir, "ttyd");
       const plat2 = detectPlatform();
       let downloadUrl = "";
       if (plat2 === "darwin") {
@@ -8700,9 +8908,9 @@ async function installCommand(options) {
     if (!hasOxNow) {
       spinner.start("Installing SageOx CLI (ox)...");
       try {
-        const binDir = join30(homedir16(), ".local", "bin");
+        const binDir = join31(homedir16(), ".local", "bin");
         mkdirSync13(binDir, { recursive: true });
-        const oxPath = join30(binDir, "ox");
+        const oxPath = join31(binDir, "ox");
         const arch = process.arch === "x64" ? "amd64" : process.arch;
         const plat2 = detectPlatform();
         const platform2 = plat2 === "darwin" ? "darwin" : "linux";
@@ -8721,7 +8929,7 @@ async function installCommand(options) {
   if (!options.minimal) {
     spinner.start("Setting up Traefik configuration...");
     try {
-      if (!existsSync31(join30(TRAEFIK_DIR, "docker-compose.yml"))) {
+      if (!existsSync32(join31(TRAEFIK_DIR, "docker-compose.yml"))) {
         copyDirectoryRecursive(SOURCE_TRAEFIK_TEMPLATES, TRAEFIK_DIR);
         cleanupTemplateFiles();
         spinner.succeed("Traefik configuration created from templates");
@@ -8734,9 +8942,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 = readFileSync27(existingCompose, "utf-8");
+      const existingCompose = join31(TRAEFIK_DIR, "docker-compose.yml");
+      if (existsSync32(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/,
@@ -8751,8 +8959,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 = join31(PANOPTICON_HOME, "config.toml");
+  const configExists = existsSync32(configFile);
   if (!configExists) {
     spinner.start("Creating default config...");
   } else {
@@ -8993,10 +9201,10 @@ init_esm_shims();
 init_agents();
 init_tmux();
 init_jsonl_parser();
-import { existsSync as existsSync32, readFileSync as readFileSync28, statSync as statSync7, mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync29, statSync as statSync7, mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "fs";
+import { join as join32 } from "path";
 import { homedir as homedir17 } from "os";
-var CLAUDE_PROJECTS_DIR = join31(homedir17(), ".claude", "projects");
+var CLAUDE_PROJECTS_DIR = join32(homedir17(), ".claude", "projects");
 var ClaudeCodeRuntime = class {
   name = "claude-code";
   /**
@@ -9006,15 +9214,15 @@ var ClaudeCodeRuntime = class {
    * We need to find the project directory that contains sessions for this workspace.
    */
   getProjectDirForWorkspace(workspace) {
-    if (!existsSync32(CLAUDE_PROJECTS_DIR)) {
+    if (!existsSync33(CLAUDE_PROJECTS_DIR)) {
       return null;
     }
     const projectDirs = getProjectDirs();
     for (const projectDir of projectDirs) {
-      const indexPath = join31(projectDir, "sessions-index.json");
-      if (existsSync32(indexPath)) {
+      const indexPath = join32(projectDir, "sessions-index.json");
+      if (existsSync33(indexPath)) {
         try {
-          const indexContent = readFileSync28(indexPath, "utf-8");
+          const indexContent = readFileSync29(indexPath, "utf-8");
           if (indexContent.includes(workspace)) {
             return projectDir;
           }
@@ -9028,12 +9236,12 @@ var ClaudeCodeRuntime = class {
    * Get the active session ID for an agent from the sessions index
    */
   getActiveSessionId(projectDir) {
-    const indexPath = join31(projectDir, "sessions-index.json");
-    if (!existsSync32(indexPath)) {
+    const indexPath = join32(projectDir, "sessions-index.json");
+    if (!existsSync33(indexPath)) {
       return null;
     }
     try {
-      const indexContent = readFileSync28(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;
@@ -9068,8 +9276,8 @@ var ClaudeCodeRuntime = class {
     }
     const sessionId = this.getActiveSessionId(projectDir);
     if (sessionId) {
-      const sessionPath = join31(projectDir, `${sessionId}.jsonl`);
-      if (existsSync32(sessionPath)) {
+      const sessionPath = join32(projectDir, `${sessionId}.jsonl`);
+      if (existsSync33(sessionPath)) {
         return sessionPath;
       }
     }
@@ -9082,7 +9290,7 @@ var ClaudeCodeRuntime = class {
    */
   getLastActivity(agentId) {
     const sessionPath = this.getSessionPath(agentId);
-    if (!sessionPath || !existsSync32(sessionPath)) {
+    if (!sessionPath || !existsSync33(sessionPath)) {
       return null;
     }
     try {
@@ -9096,12 +9304,12 @@ var ClaudeCodeRuntime = class {
    * Read active heartbeat file if it exists
    */
   getActiveHeartbeat(agentId) {
-    const heartbeatPath = join31(homedir17(), ".panopticon", "heartbeats", `${agentId}.json`);
-    if (!existsSync32(heartbeatPath)) {
+    const heartbeatPath = join32(homedir17(), ".panopticon", "heartbeats", `${agentId}.json`);
+    if (!existsSync33(heartbeatPath)) {
       return null;
     }
     try {
-      const content = readFileSync28(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();
@@ -9205,11 +9413,11 @@ var ClaudeCodeRuntime = class {
       throw new Error(`Agent ${agentId} is not running`);
     }
     await sendKeysAsync(agentId, message);
-    const mailDir = join31(getAgentDir(agentId), "mail");
+    const mailDir = join32(getAgentDir(agentId), "mail");
     mkdirSync14(mailDir, { recursive: true });
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     writeFileSync13(
-      join31(mailDir, `${timestamp}.md`),
+      join32(mailDir, `${timestamp}.md`),
       `# Message
 
 ${message}
@@ -9367,9 +9575,9 @@ init_agents();
 // src/lib/cloister/triggers.ts
 init_esm_shims();
 init_config2();
-import { exec as exec9 } from "child_process";
-import { promisify as promisify9 } from "util";
-var execAsync9 = promisify9(exec9);
+import { exec as exec10 } from "child_process";
+import { promisify as promisify10 } from "util";
+var execAsync10 = promisify10(exec10);
 function checkStuckEscalation(health, currentModel, config2) {
   const conf = config2 || loadCloisterConfig();
   const stuckConfig = conf.handoffs?.auto_triggers?.stuck_escalation;
@@ -9493,7 +9701,7 @@ async function checkTaskCompletion(issueId, config2) {
     };
   }
   try {
-    const { stdout: output } = await execAsync9(`bd list --json -l ${issueId.toLowerCase()} --status closed`, {
+    const { stdout: output } = await execAsync10(`bd list --json -l ${issueId.toLowerCase()} --status closed`, {
       encoding: "utf-8"
     });
     const tasks = JSON.parse(output);
@@ -9501,7 +9709,7 @@ async function checkTaskCompletion(issueId, config2) {
       (t) => t.title.toLowerCase().includes("implement") || t.labels?.includes("implementation")
     );
     if (implementTask) {
-      const { stdout: openOutput } = await execAsync9(`bd list --json -l ${issueId.toLowerCase()} --status open`, {
+      const { stdout: openOutput } = await execAsync10(`bd list --json -l ${issueId.toLowerCase()} --status open`, {
         encoding: "utf-8"
       });
       const openTasks = JSON.parse(openOutput);
@@ -9546,15 +9754,15 @@ async function checkAllTriggers(agentId, workspace, issueId, currentModel, healt
 init_esm_shims();
 init_agents();
 import { writeFileSync as writeFileSync14, mkdirSync as mkdirSync15 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 
 // src/lib/cloister/handoff-context.ts
 init_esm_shims();
-import { existsSync as existsSync33, readFileSync as readFileSync29 } from "fs";
-import { join as join32 } from "path";
-import { exec as exec10 } from "child_process";
-import { promisify as promisify10 } from "util";
-var execAsync10 = promisify10(exec10);
+import { existsSync as existsSync34, readFileSync as readFileSync30 } from "fs";
+import { join as join33 } from "path";
+import { exec as exec11 } from "child_process";
+import { promisify as promisify11 } from "util";
+var execAsync11 = promisify11(exec11);
 async function captureHandoffContext(agentState, targetModel, reason) {
   const context = {
     issueId: agentState.issueId,
@@ -9575,13 +9783,13 @@ async function captureHandoffContext(agentState, targetModel, reason) {
 }
 async function captureFiles(context, workspace) {
   try {
-    const stateFile = join32(workspace, ".planning/STATE.md");
-    if (existsSync33(stateFile)) {
-      context.stateFile = readFileSync29(stateFile, "utf-8");
+    const stateFile = join33(workspace, ".planning/STATE.md");
+    if (existsSync34(stateFile)) {
+      context.stateFile = readFileSync30(stateFile, "utf-8");
     }
-    const claudeMd = join32(workspace, "CLAUDE.md");
-    if (existsSync33(claudeMd)) {
-      context.claudeMd = readFileSync29(claudeMd, "utf-8");
+    const claudeMd = join33(workspace, "CLAUDE.md");
+    if (existsSync34(claudeMd)) {
+      context.claudeMd = readFileSync30(claudeMd, "utf-8");
     }
   } catch (error) {
     console.error("Error capturing files:", error);
@@ -9589,17 +9797,17 @@ async function captureFiles(context, workspace) {
 }
 async function captureGitState(context, workspace) {
   try {
-    const { stdout: branch } = await execAsync10("git branch --show-current", {
+    const { stdout: branch } = await execAsync11("git branch --show-current", {
       cwd: workspace,
       encoding: "utf-8"
     });
     context.gitBranch = branch.trim();
-    const { stdout: status } = await execAsync10("git status --porcelain", {
+    const { stdout: status } = await execAsync11("git status --porcelain", {
       cwd: workspace,
       encoding: "utf-8"
     });
     context.uncommittedFiles = status.split("\n").filter((line) => line.trim()).map((line) => line.substring(3));
-    const { stdout: lastCommit } = await execAsync10("git log -1 --oneline", {
+    const { stdout: lastCommit } = await execAsync11("git log -1 --oneline", {
       cwd: workspace,
       encoding: "utf-8"
     });
@@ -9611,7 +9819,7 @@ async function captureGitState(context, workspace) {
 async function captureBeadsTasks(context, issueId) {
   try {
     const label = issueId.toLowerCase();
-    const { stdout: output } = await execAsync10(`bd list --json -l ${label}`, {
+    const { stdout: output } = await execAsync11(`bd list --json -l ${label}`, {
       encoding: "utf-8"
     });
     const tasks = JSON.parse(output);
@@ -9772,9 +9980,9 @@ 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 = join33(getAgentDir(state.id), "handoffs");
+    const handoffDir = join34(getAgentDir(state.id), "handoffs");
     mkdirSync15(handoffDir, { recursive: true });
-    const handoffFile = join33(handoffDir, `handoff-${Date.now()}.md`);
+    const handoffFile = join34(handoffDir, `handoff-${Date.now()}.md`);
     writeFileSync14(handoffFile, prompt);
     const newState = await spawnAgent({
       issueId: state.issueId,
@@ -9883,12 +10091,12 @@ function sleep(ms) {
 // src/lib/cloister/handoff-logger.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync35, mkdirSync as mkdirSync16, appendFileSync as appendFileSync3, readFileSync as readFileSync30, writeFileSync as writeFileSync15 } from "fs";
-import { join as join34 } from "path";
-var HANDOFF_LOG_FILE = join34(PANOPTICON_HOME, "logs", "handoffs.jsonl");
+import { existsSync as existsSync36, mkdirSync as mkdirSync16, appendFileSync as appendFileSync3, readFileSync as readFileSync31, writeFileSync as writeFileSync15 } from "fs";
+import { join as join35 } from "path";
+var HANDOFF_LOG_FILE = join35(PANOPTICON_HOME, "logs", "handoffs.jsonl");
 function ensureLogDir() {
-  const logDir = join34(PANOPTICON_HOME, "logs");
-  if (!existsSync35(logDir)) {
+  const logDir = join35(PANOPTICON_HOME, "logs");
+  if (!existsSync36(logDir)) {
     mkdirSync16(logDir, { recursive: true });
   }
 }
@@ -9932,8 +10140,8 @@ function createHandoffEvent(agentId, issueId, context, trigger, success, errorMe
 // src/lib/cloister/fpp-violations.ts
 init_esm_shims();
 init_hooks();
-import { readFileSync as readFileSync31, existsSync as existsSync36, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17, unlinkSync as unlinkSync3 } from "fs";
-import { join as join35, dirname as dirname10 } from "path";
+import { readFileSync as readFileSync32, existsSync as existsSync37, writeFileSync as writeFileSync16, mkdirSync as mkdirSync17, unlinkSync as unlinkSync3 } from "fs";
+import { join as join36, dirname as dirname10 } from "path";
 init_paths();
 var DEFAULT_FPP_CONFIG = {
   hook_idle_minutes: 5,
@@ -9941,13 +10149,13 @@ var DEFAULT_FPP_CONFIG = {
   review_pending_minutes: 15,
   max_nudges: 3
 };
-var VIOLATIONS_DATA_FILE = join35(PANOPTICON_HOME, "fpp-violations.json");
+var VIOLATIONS_DATA_FILE = join36(PANOPTICON_HOME, "fpp-violations.json");
 function loadViolations() {
-  if (!existsSync36(VIOLATIONS_DATA_FILE)) {
+  if (!existsSync37(VIOLATIONS_DATA_FILE)) {
     return /* @__PURE__ */ new Map();
   }
   try {
-    const fileContent = readFileSync31(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) {
@@ -9958,7 +10166,7 @@ function loadViolations() {
 function saveViolations(violations) {
   try {
     const dir = dirname10(VIOLATIONS_DATA_FILE);
-    if (!existsSync36(dir)) {
+    if (!existsSync37(dir)) {
       mkdirSync17(dir, { recursive: true });
     }
     const persisted = {
@@ -9966,7 +10174,7 @@ function saveViolations(violations) {
     };
     const tempFile = `${VIOLATIONS_DATA_FILE}.tmp`;
     writeFileSync16(tempFile, JSON.stringify(persisted, null, 2));
-    writeFileSync16(VIOLATIONS_DATA_FILE, readFileSync31(tempFile));
+    writeFileSync16(VIOLATIONS_DATA_FILE, readFileSync32(tempFile));
     try {
       unlinkSync3(tempFile);
     } catch (unlinkError) {
@@ -10056,11 +10264,11 @@ function clearOldViolations(hoursOld = 24) {
 init_esm_shims();
 init_paths();
 init_config2();
-import { readFileSync as readFileSync32, existsSync as existsSync37, writeFileSync as writeFileSync17, mkdirSync as mkdirSync18, unlinkSync as unlinkSync4 } from "fs";
-import { join as join36, dirname as dirname11 } from "path";
-var COST_DATA_FILE = join36(PANOPTICON_HOME, "cost-data.json");
+import { readFileSync as readFileSync33, existsSync as existsSync38, writeFileSync as writeFileSync17, mkdirSync as mkdirSync18, unlinkSync as unlinkSync4 } from "fs";
+import { join as join37, dirname as dirname11 } from "path";
+var COST_DATA_FILE = join37(PANOPTICON_HOME, "cost-data.json");
 function loadCostData() {
-  if (!existsSync37(COST_DATA_FILE)) {
+  if (!existsSync38(COST_DATA_FILE)) {
     return {
       perAgent: /* @__PURE__ */ new Map(),
       perIssue: /* @__PURE__ */ new Map(),
@@ -10069,7 +10277,7 @@ function loadCostData() {
     };
   }
   try {
-    const fileContent = readFileSync32(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 || {})),
@@ -10090,7 +10298,7 @@ function loadCostData() {
 function saveCostData(data) {
   try {
     const dir = dirname11(COST_DATA_FILE);
-    if (!existsSync37(dir)) {
+    if (!existsSync38(dir)) {
       mkdirSync18(dir, { recursive: true });
     }
     const persisted = {
@@ -10101,7 +10309,7 @@ function saveCostData(data) {
     };
     const tempFile = `${COST_DATA_FILE}.tmp`;
     writeFileSync17(tempFile, JSON.stringify(persisted, null, 2));
-    writeFileSync17(COST_DATA_FILE, readFileSync32(tempFile));
+    writeFileSync17(COST_DATA_FILE, readFileSync33(tempFile));
     try {
       unlinkSync4(tempFile);
     } catch (unlinkError) {
@@ -10222,12 +10430,12 @@ function getCostSummary() {
 init_esm_shims();
 init_paths();
 import { writeFileSync as writeFileSync18 } from "fs";
-import { join as join37 } from "path";
-import { exec as exec11 } from "child_process";
-import { promisify as promisify11 } from "util";
+import { join as join38 } from "path";
+import { exec as exec12 } from "child_process";
+import { promisify as promisify12 } from "util";
 init_agents();
 init_specialists();
-var execAsync11 = promisify11(exec11);
+var execAsync12 = promisify12(exec12);
 var SESSION_ROTATION_THRESHOLD = 1e5;
 var DEFAULT_MEMORY_TIERS = {
   recent_summary: 100,
@@ -10249,7 +10457,7 @@ async function buildMergeAgentMemory(workingDir, tiers = DEFAULT_MEMORY_TIERS) {
   const merges = [];
   try {
     const totalMerges = Math.max(tiers.recent_summary, tiers.recent_detailed, tiers.recent_full);
-    const { stdout: gitLog } = await execAsync11(
+    const { stdout: gitLog } = await execAsync12(
       `git log --merges --format="%H|%s|%an|%ad|%D" -n ${totalMerges}`,
       { cwd: workingDir, encoding: "utf-8" }
     );
@@ -10284,14 +10492,14 @@ async function buildMergeAgentMemory(workingDir, tiers = DEFAULT_MEMORY_TIERS) {
     if (merge.branch) memory += `- Branch: ${merge.branch}
 `;
     try {
-      const { stdout: filesOutput } = await execAsync11(`git show --name-only --format= ${merge.hash}`, {
+      const { stdout: filesOutput } = await execAsync12(`git show --name-only --format= ${merge.hash}`, {
         cwd: workingDir,
         encoding: "utf-8"
       });
       const files = filesOutput.trim().split("\n").filter((f) => f);
       memory += `- Files changed: ${files.length}
 `;
-      const { stdout: diff } = await execAsync11(`git show ${merge.hash} --stat`, {
+      const { stdout: diff } = await execAsync12(`git show ${merge.hash} --stat`, {
         cwd: workingDir,
         encoding: "utf-8",
         maxBuffer: 10 * 1024 * 1024
@@ -10362,13 +10570,13 @@ async function rotateSpecialistSession(specialistName, workingDir) {
     let memoryFile;
     if (specialistName === "merge-agent" && workingDir) {
       memoryContent = await buildMergeAgentMemory(workingDir);
-      memoryFile = join37(PANOPTICON_HOME, `merge-agent-memory-${Date.now()}.md`);
+      memoryFile = join38(PANOPTICON_HOME, `merge-agent-memory-${Date.now()}.md`);
       writeFileSync18(memoryFile, memoryContent);
       console.log(`Built memory file: ${memoryFile}`);
     }
     const tmuxSession = getTmuxSessionName(specialistName);
     try {
-      await execAsync11(`tmux kill-session -t "${tmuxSession}"`);
+      await execAsync12(`tmux kill-session -t "${tmuxSession}"`);
       console.log(`Killed session: ${tmuxSession}`);
     } catch (error) {
       console.log(`Session ${tmuxSession} not found or already killed`);
@@ -10418,14 +10626,14 @@ init_config2();
 init_specialists();
 init_agents();
 init_tmux();
-import { readFileSync as readFileSync34, writeFileSync as writeFileSync19, existsSync as existsSync39, mkdirSync as mkdirSync19, readdirSync as readdirSync17, statSync as statSync8, rmSync as rmSync4 } from "fs";
-import { join as join38 } from "path";
-import { exec as exec12, execFile } from "child_process";
-import { promisify as promisify12 } from "util";
+import { readFileSync as readFileSync35, writeFileSync as writeFileSync19, existsSync as existsSync40, mkdirSync as mkdirSync19, readdirSync as readdirSync17, statSync as statSync8, rmSync as rmSync4 } from "fs";
+import { join as join39 } from "path";
+import { exec as exec13, execFile } from "child_process";
+import { promisify as promisify13 } from "util";
 import { homedir as homedir18 } from "os";
-var execAsync12 = promisify12(exec12);
-var execFileAsync = promisify12(execFile);
-var REVIEW_STATUS_FILE = join38(homedir18(), ".panopticon", "review-status.json");
+var execAsync13 = promisify13(exec13);
+var execFileAsync = promisify13(execFile);
+var REVIEW_STATUS_FILE = join39(homedir18(), ".panopticon", "review-status.json");
 var DEFAULT_CONFIG = {
   pingTimeoutMs: 3e4,
   // How long to wait for response
@@ -10440,15 +10648,15 @@ var DEFAULT_CONFIG = {
   massDeathWindowMs: 6e4
   // 1 minute window for mass death detection
 };
-var DEACON_DIR = join38(PANOPTICON_HOME, "deacon");
-var STATE_FILE = join38(DEACON_DIR, "health-state.json");
-var CONFIG_FILE2 = join38(DEACON_DIR, "config.json");
+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 deaconInterval = null;
 var config = { ...DEFAULT_CONFIG };
 function loadConfig3() {
   try {
-    if (existsSync39(CONFIG_FILE2)) {
-      const content = readFileSync34(CONFIG_FILE2, "utf-8");
+    if (existsSync40(CONFIG_FILE2)) {
+      const content = readFileSync35(CONFIG_FILE2, "utf-8");
       const loaded = JSON.parse(content);
       config = { ...DEFAULT_CONFIG, ...loaded };
     }
@@ -10458,15 +10666,15 @@ function loadConfig3() {
   return config;
 }
 function ensureDeaconDir() {
-  if (!existsSync39(DEACON_DIR)) {
+  if (!existsSync40(DEACON_DIR)) {
     mkdirSync19(DEACON_DIR, { recursive: true });
   }
 }
 function loadState() {
   ensureDeaconDir();
   try {
-    if (existsSync39(STATE_FILE)) {
-      const content = readFileSync34(STATE_FILE, "utf-8");
+    if (existsSync40(STATE_FILE)) {
+      const content = readFileSync35(STATE_FILE, "utf-8");
       return JSON.parse(content);
     }
   } catch (error) {
@@ -10561,7 +10769,7 @@ async function checkAndSuspendIdleAgents() {
       try {
         const sessionId = runtimeState.sessionId || `session-${agent.id}`;
         saveSessionId(agent.id, sessionId);
-        await execAsync12(`tmux kill-session -t "${agent.id}" 2>/dev/null || true`);
+        await execAsync13(`tmux kill-session -t "${agent.id}" 2>/dev/null || true`);
         saveAgentRuntimeState(agent.id, {
           state: "suspended",
           suspendedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10604,7 +10812,7 @@ async function checkLazyAgent(sessionName) {
     if (Date.now() - lastSent < LAZY_COOLDOWN_MS) {
       return { isLazy: false };
     }
-    const { stdout } = await execAsync12(
+    const { stdout } = await execAsync13(
       `tmux capture-pane -t "${sessionName}" -p -S -20 2>/dev/null || echo ""`,
       { encoding: "utf-8" }
     );
@@ -10639,11 +10847,11 @@ async function checkLazyAgent(sessionName) {
 }
 async function sendAntiLazyMessage(sessionName) {
   try {
-    await execAsync12(
+    await execAsync13(
       `tmux send-keys -t "${sessionName}" "${ANTI_LAZY_MESSAGE.replace(/"/g, '\\"')}"`,
       { encoding: "utf-8" }
     );
-    await execAsync12(`tmux send-keys -t "${sessionName}" Enter`, { encoding: "utf-8" });
+    await execAsync13(`tmux send-keys -t "${sessionName}" Enter`, { encoding: "utf-8" });
     lazyMessageCooldowns.set(sessionName, Date.now());
     console.log(`[deacon] Sent anti-lazy message to ${sessionName}`);
     return true;
@@ -10658,10 +10866,10 @@ function isIssueCompletedOrInReview(agentId) {
     const match = agentId.match(/agent-([a-z]+-\d+)/i);
     if (!match) return false;
     const issueId = match[1].toUpperCase();
-    if (!existsSync39(REVIEW_STATUS_FILE)) {
+    if (!existsSync40(REVIEW_STATUS_FILE)) {
       return false;
     }
-    const content = readFileSync34(REVIEW_STATUS_FILE, "utf-8");
+    const content = readFileSync35(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const status = statuses[issueId];
     if (!status) {
@@ -10713,7 +10921,7 @@ var ACTIVE_STATUS_PATTERNS = [
 ];
 async function isAgentActiveInTmux(sessionName) {
   try {
-    const { stdout } = await execAsync12(
+    const { stdout } = await execAsync13(
       `tmux capture-pane -t "${sessionName}" -p -S -5 2>/dev/null || echo ""`,
       { encoding: "utf-8" }
     );
@@ -10759,7 +10967,7 @@ async function checkStuckWorkAgents() {
     }
     let tmuxOutput;
     try {
-      const { stdout } = await execAsync12(
+      const { stdout } = await execAsync13(
         `tmux capture-pane -t "${agent.id}" -p -S -10 2>/dev/null || echo ""`,
         { encoding: "utf-8" }
       );
@@ -10780,23 +10988,23 @@ async function checkStuckWorkAgents() {
     console.log(`[deacon] Work agent ${agent.id} stuck thinking for ${thinkingMinutes}m (attempt ${attempts + 1})`);
     try {
       if (attempts === 0) {
-        await execAsync12(`tmux send-keys -t "${agent.id}" Escape 2>/dev/null || true`);
+        await execAsync13(`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 execAsync12(`tmux send-keys -t "${agent.id}" C-c 2>/dev/null || true`);
+        await execAsync13(`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 = join38(AGENTS_DIR, agent.id, "launcher.sh");
+        const launcherPath = join39(AGENTS_DIR, agent.id, "launcher.sh");
         const agentState = getAgentState(agent.id);
         const workspace = agentState?.workspace;
-        if (!existsSync39(launcherPath) || !workspace) {
+        if (!existsSync40(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 execAsync12(`tmux kill-session -t "${agent.id}" 2>/dev/null || true`);
+        await execAsync13(`tmux kill-session -t "${agent.id}" 2>/dev/null || true`);
         await new Promise((r) => setTimeout(r, 1e3));
-        await execAsync12(
+        await execAsync13(
           `tmux new-session -d -s "${agent.id}" -c "${workspace}" "bash ${launcherPath}"`,
           { encoding: "utf-8" }
         );
@@ -10823,22 +11031,22 @@ async function cleanupStaleAgentState() {
   const retentionDays = cloisterConfig.retention?.agent_state_days ?? 30;
   const retentionMs = retentionDays * 24 * 60 * 60 * 1e3;
   const now = Date.now();
-  if (!existsSync39(AGENTS_DIR)) {
+  if (!existsSync40(AGENTS_DIR)) {
     return actions;
   }
   try {
     const dirs = readdirSync17(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const dir of dirs) {
-      const agentDir = join38(AGENTS_DIR, dir.name);
+      const agentDir = join39(AGENTS_DIR, dir.name);
       try {
         try {
-          await execAsync12(`tmux has-session -t "${dir.name}" 2>/dev/null`);
+          await execAsync13(`tmux has-session -t "${dir.name}" 2>/dev/null`);
           continue;
         } catch {
         }
-        const stateFile = join38(agentDir, "state.json");
+        const stateFile = join39(agentDir, "state.json");
         let mtime;
-        if (existsSync39(stateFile)) {
+        if (existsSync40(stateFile)) {
           mtime = statSync8(stateFile).mtimeMs;
         } else {
           mtime = statSync8(agentDir).mtimeMs;
@@ -10847,8 +11055,8 @@ async function cleanupStaleAgentState() {
         if (ageMs < retentionMs) {
           continue;
         }
-        const completedFile = join38(agentDir, "completed");
-        if (existsSync39(completedFile)) {
+        const completedFile = join39(agentDir, "completed");
+        if (existsSync40(completedFile)) {
           const completedAge = now - statSync8(completedFile).mtimeMs;
           if (completedAge < 7 * 24 * 60 * 60 * 1e3) {
             continue;
@@ -10875,10 +11083,10 @@ async function cleanupStaleAgentState() {
 async function checkOrphanedReviewStatuses() {
   const actions = [];
   try {
-    if (!existsSync39(REVIEW_STATUS_FILE)) {
+    if (!existsSync40(REVIEW_STATUS_FILE)) {
       return actions;
     }
-    const content = readFileSync34(REVIEW_STATUS_FILE, "utf-8");
+    const content = readFileSync35(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const activeReviewSessions = /* @__PURE__ */ new Set();
     const activeTestSessions = /* @__PURE__ */ new Set();
@@ -10945,7 +11153,7 @@ async function checkOrphanedReviewStatuses() {
             const { resolveProjectFromIssue: resolveProjectFromIssue2 } = await import("../projects-BPGM6IFB.js");
             const resolved = resolveProjectFromIssue2(issueId);
             if (resolved) {
-              const { spawnEphemeralSpecialist: spawnEphemeralSpecialist2 } = await import("../specialists-CXRGSJY3.js");
+              const { spawnEphemeralSpecialist: spawnEphemeralSpecialist2 } = await import("../specialists-X4OGA7WX.js");
               const result = await spawnEphemeralSpecialist2(resolved.projectKey, "test-agent", {
                 issueId,
                 workspace,
@@ -11007,10 +11215,10 @@ var mergeReadyNotifier = null;
 async function checkReadyForMergeStuck() {
   const actions = [];
   try {
-    if (!existsSync39(REVIEW_STATUS_FILE)) {
+    if (!existsSync40(REVIEW_STATUS_FILE)) {
       return actions;
     }
-    const content = readFileSync34(REVIEW_STATUS_FILE, "utf-8");
+    const content = readFileSync35(REVIEW_STATUS_FILE, "utf-8");
     const statuses = JSON.parse(content);
     const now = Date.now();
     const state = loadState();
@@ -11060,10 +11268,10 @@ var DEAD_END_COOLDOWN_MS = 10 * 60 * 1e3;
 async function checkDeadEndAgents() {
   const actions = [];
   try {
-    if (!existsSync39(REVIEW_STATUS_FILE)) {
+    if (!existsSync40(REVIEW_STATUS_FILE)) {
       return actions;
     }
-    const content = readFileSync34(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)) {
@@ -11123,15 +11331,15 @@ async function checkFirstCompletionAgents() {
       const agentId = agent.id;
       if (!agentId || !agentId.startsWith("agent-") || !agent.tmuxActive) continue;
       if (agentId.startsWith("specialist-")) continue;
-      const completedFile = join38(AGENTS_DIR, agent.id, "completed");
-      if (existsSync39(completedFile)) continue;
+      const completedFile = join39(AGENTS_DIR, agent.id, "completed");
+      if (existsSync40(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 execAsync12(
+        const { stdout: lastLines } = await execAsync13(
           `tmux capture-pane -t "${agent.id}" -p -S -3 2>/dev/null || echo ""`,
           { encoding: "utf-8" }
         );
@@ -11146,9 +11354,9 @@ async function checkFirstCompletionAgents() {
       if (lastNudge && now - lastNudge < FIRST_COMPLETION_COOLDOWN_MS) continue;
       const issueId = agent.issueId || agent.id.replace("agent-", "").toUpperCase();
       const issueKey = issueId.toLowerCase();
-      if (existsSync39(REVIEW_STATUS_FILE)) {
+      if (existsSync40(REVIEW_STATUS_FILE)) {
         try {
-          const statuses = JSON.parse(readFileSync34(REVIEW_STATUS_FILE, "utf-8"));
+          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})`);
@@ -11159,8 +11367,8 @@ async function checkFirstCompletionAgents() {
       }
       const agentStateForGate = getAgentState(agent.id);
       if (agentStateForGate?.workspace) {
-        const feedbackDir = join38(agentStateForGate.workspace, ".planning", "feedback");
-        if (existsSync39(feedbackDir)) {
+        const feedbackDir = join39(agentStateForGate.workspace, ".planning", "feedback");
+        if (existsSync40(feedbackDir)) {
           try {
             const feedbackFiles = readdirSync17(feedbackDir);
             if (feedbackFiles.length > 0) {
@@ -11172,10 +11380,10 @@ async function checkFirstCompletionAgents() {
         }
       }
       const agentState = getAgentState(agent.id);
-      if (!agentState?.workspace || !existsSync39(agentState.workspace)) continue;
+      if (!agentState?.workspace || !existsSync40(agentState.workspace)) continue;
       let hasCommits = false;
       try {
-        const { stdout: gitLog } = await execAsync12(
+        const { stdout: gitLog } = await execAsync13(
           "git log --oneline -3 2>/dev/null",
           { cwd: agentState.workspace }
         );
@@ -11185,9 +11393,9 @@ async function checkFirstCompletionAgents() {
           const subdirs = readdirSync17(agentState.workspace, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
           for (const sub of subdirs) {
             try {
-              const { stdout: subLog } = await execAsync12(
+              const { stdout: subLog } = await execAsync13(
                 "git log --oneline -3 2>/dev/null",
-                { cwd: join38(agentState.workspace, sub.name) }
+                { cwd: join39(agentState.workspace, sub.name) }
               );
               if (subLog.trim().length > 0) {
                 hasCommits = true;
@@ -11237,8 +11445,8 @@ async function patrolWorkAgentResolutions() {
       if (resolution === "done" && count >= 2) {
         console.log(`[deacon] Auto-completing ${agent.id} (${issueId}): resolution=done, count=${count}`);
         try {
-          const panBin = join38(PANOPTICON_HOME, "bin", "pan");
-          const binExists = existsSync39(panBin);
+          const panBin = join39(PANOPTICON_HOME, "bin", "pan");
+          const binExists = existsSync40(panBin);
           const bin = binExists ? panBin : "pan";
           await execFileAsync(bin, ["work", "done", issueId, "-c", "Auto-completed by Deacon: evidence showed work complete after 2 nudges"], {
             timeout: 3e4
@@ -11281,8 +11489,8 @@ async function checkSpecialistQueues() {
       spawnEphemeralSpecialist: spawnEphemeralSpecialist2,
       getTmuxSessionName: getTmuxSessionName2,
       isRunning: isRunning3
-    } = await import("../specialists-CXRGSJY3.js");
-    const { getAgentRuntimeState: getAgentRuntimeState2 } = await import("../agents-M2ZOZL3P.js");
+    } = await import("../specialists-X4OGA7WX.js");
+    const { getAgentRuntimeState: getAgentRuntimeState2 } = await import("../agents-RL2KUSP3.js");
     const { resolveProjectFromIssue: resolveProjectFromIssue2 } = await import("../projects-BPGM6IFB.js");
     const specialistTypes = ["review-agent", "test-agent", "inspect-agent", "uat-agent"];
     for (const specialistType of specialistTypes) {
@@ -11304,10 +11512,10 @@ async function checkSpecialistQueues() {
         if (lastActivityAge > tenMinutes) {
           console.log(`[deacon] Stale specialist detected: ${tmuxSession} (last activity: ${Math.round(lastActivityAge / 6e4)}m ago) \u2014 killing and treating as idle`);
           try {
-            const { exec: exec22 } = await import("child_process");
-            const { promisify: promisify22 } = await import("util");
-            const execAsync22 = promisify22(exec22);
-            await execAsync22(`tmux kill-session -t "${tmuxSession}"`, { encoding: "utf-8" }).catch(() => {
+            const { exec: exec24 } = await import("child_process");
+            const { promisify: promisify24 } = await import("util");
+            const execAsync24 = promisify24(exec24);
+            await execAsync24(`tmux kill-session -t "${tmuxSession}"`, { encoding: "utf-8" }).catch(() => {
             });
           } catch {
           }
@@ -11317,7 +11525,7 @@ async function checkSpecialistQueues() {
       if (!isIdle) continue;
       console.log(`[deacon] Dispatching queued ${specialistType} work for ${issueId} (project: ${resolved.projectKey})`);
       try {
-        const { findWorkspacePath: findWorkspacePath3 } = await import("../archive-planning-U3AZAKWI.js");
+        const { findWorkspacePath: findWorkspacePath3 } = await import("../archive-planning-54J6EP6A.js");
         const workspacePath = findWorkspacePath3(resolved.projectPath, issueId.toLowerCase());
         const queuePayload = item.payload;
         await spawnEphemeralSpecialist2(resolved.projectKey, specialistType, {
@@ -11395,15 +11603,15 @@ async function runPatrol() {
           if (projSpec.specialistType === "merge-agent" && runtimeState2.currentIssue) {
             const issueId = runtimeState2.currentIssue;
             try {
-              if (!existsSync39(REVIEW_STATUS_FILE)) continue;
-              const statuses = JSON.parse(readFileSync34(REVIEW_STATUS_FILE, "utf-8"));
+              if (!existsSync40(REVIEW_STATUS_FILE)) continue;
+              const statuses = JSON.parse(readFileSync35(REVIEW_STATUS_FILE, "utf-8"));
               const rs = statuses[issueId];
               if (rs?.mergeStatus === "merging") {
                 const { resolveProjectFromIssue: resolveProjectFromIssue2 } = await import("../projects-BPGM6IFB.js");
                 const resolved = resolveProjectFromIssue2(issueId);
                 if (resolved) {
                   const branch = `feature/${issueId.toLowerCase()}`;
-                  const { stdout } = await execAsync12(
+                  const { stdout } = await execAsync13(
                     `git -C "${resolved.projectPath}" log --oneline origin/main --grep="Merge branch '${branch}'" 2>/dev/null | head -1`,
                     { encoding: "utf-8" }
                   );
@@ -11412,7 +11620,7 @@ async function runPatrol() {
                     statuses[issueId].mergeStatus = "merged";
                     statuses[issueId].readyForMerge = false;
                     writeFileSync19(REVIEW_STATUS_FILE, JSON.stringify(statuses, null, 2), "utf-8");
-                    const { postMergeLifecycle } = await import("../merge-agent-756U4NPX.js");
+                    const { postMergeLifecycle } = await import("../merge-agent-7L7MWJEC.js");
                     postMergeLifecycle(issueId, resolved.projectPath).catch(
                       (err) => console.warn(`[deacon] postMergeLifecycle failed for ${issueId}: ${err}`)
                     );
@@ -11437,7 +11645,7 @@ async function runPatrol() {
         addLog("warn", `Per-project ${projSpec.specialistType} (${projSpec.projectKey}) stuck, force-killing`, state.patrolCycle);
         console.log(`[deacon] Per-project ${projSpec.specialistType} (${projSpec.projectKey}) stuck, force-killing ${projSpec.tmuxSession}`);
         try {
-          await execAsync12(`tmux kill-session -t "${projSpec.tmuxSession}"`);
+          await execAsync13(`tmux kill-session -t "${projSpec.tmuxSession}"`);
           saveAgentRuntimeState(projSpec.tmuxSession, { state: "idle", lastActivity: (/* @__PURE__ */ new Date()).toISOString() });
           actions.push(`Force-killed stuck per-project ${projSpec.specialistType} (${projSpec.projectKey})`);
         } catch {
@@ -11512,9 +11720,9 @@ function getDeaconStatus() {
 // src/lib/cloister/service.ts
 init_paths();
 init_paths();
-import { existsSync as existsSync40, writeFileSync as writeFileSync20, unlinkSync as unlinkSync5, readFileSync as readFileSync35, readdirSync as readdirSync18, renameSync as renameSync3 } from "fs";
-import { join as join39 } from "path";
-var CLOISTER_STATE_FILE = join39(PANOPTICON_HOME, "cloister.state");
+import { existsSync as existsSync41, writeFileSync as writeFileSync20, unlinkSync as unlinkSync5, readFileSync as readFileSync36, readdirSync as readdirSync18, renameSync as renameSync3 } from "fs";
+import { join as join40 } from "path";
+var CLOISTER_STATE_FILE = join40(PANOPTICON_HOME, "cloister.state");
 function writeStateFile(running, pid) {
   try {
     if (running) {
@@ -11524,7 +11732,7 @@ function writeStateFile(running, pid) {
         startedAt: (/* @__PURE__ */ new Date()).toISOString()
       }));
     } else {
-      if (existsSync40(CLOISTER_STATE_FILE)) {
+      if (existsSync41(CLOISTER_STATE_FILE)) {
         unlinkSync5(CLOISTER_STATE_FILE);
       }
     }
@@ -11534,8 +11742,8 @@ function writeStateFile(running, pid) {
 }
 function readStateFile() {
   try {
-    if (existsSync40(CLOISTER_STATE_FILE)) {
-      const data = JSON.parse(readFileSync35(CLOISTER_STATE_FILE, "utf-8"));
+    if (existsSync41(CLOISTER_STATE_FILE)) {
+      const data = JSON.parse(readFileSync36(CLOISTER_STATE_FILE, "utf-8"));
       if (data.pid) {
         try {
           process.kill(data.pid, 0);
@@ -11741,14 +11949,14 @@ var CloisterService = class {
    */
   async checkCompletionMarkers() {
     try {
-      if (!existsSync40(AGENTS_DIR)) return;
+      if (!existsSync41(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 = join39(AGENTS_DIR, dir.name, "completed");
-        const processedFile = join39(AGENTS_DIR, dir.name, "completed.processed");
-        if (!existsSync40(completedFile) || existsSync40(processedFile)) continue;
+        const completedFile = join40(AGENTS_DIR, dir.name, "completed");
+        const processedFile = join40(AGENTS_DIR, dir.name, "completed.processed");
+        if (!existsSync41(completedFile) || existsSync41(processedFile)) continue;
         try {
-          const content = JSON.parse(readFileSync35(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)`);
@@ -12425,8 +12633,8 @@ init_esm_shims();
 // src/cli/commands/setup/hooks.ts
 init_esm_shims();
 import chalk39 from "chalk";
-import { readFileSync as readFileSync36, writeFileSync as writeFileSync21, existsSync as existsSync41, mkdirSync as mkdirSync20, copyFileSync as copyFileSync2, chmodSync } from "fs";
-import { join as join40 } from "path";
+import { readFileSync as readFileSync37, writeFileSync as writeFileSync21, existsSync as existsSync42, mkdirSync as mkdirSync20, copyFileSync as copyFileSync2, chmodSync } from "fs";
+import { join as join41 } from "path";
 import { execSync as execSync5 } from "child_process";
 import { homedir as homedir19 } from "os";
 function checkJqInstalled() {
@@ -12504,14 +12712,14 @@ async function setupHooksCommand() {
   } else {
     console.log(chalk39.green("\u2713 jq is installed"));
   }
-  const panopticonHome = join40(homedir19(), ".panopticon");
-  const binDir = join40(panopticonHome, "bin");
-  const heartbeatsDir = join40(panopticonHome, "heartbeats");
-  if (!existsSync41(binDir)) {
+  const panopticonHome = join41(homedir19(), ".panopticon");
+  const binDir = join41(panopticonHome, "bin");
+  const heartbeatsDir = join41(panopticonHome, "heartbeats");
+  if (!existsSync42(binDir)) {
     mkdirSync20(binDir, { recursive: true });
     console.log(chalk39.green("\u2713 Created ~/.panopticon/bin/"));
   }
-  if (!existsSync41(heartbeatsDir)) {
+  if (!existsSync42(heartbeatsDir)) {
     mkdirSync20(heartbeatsDir, { recursive: true });
     console.log(chalk39.green("\u2713 Created ~/.panopticon/heartbeats/"));
   }
@@ -12520,13 +12728,13 @@ async function setupHooksCommand() {
   const { dirname: dirname17 } = await import("path");
   const __dirname7 = dirname17(fileURLToPath7(import.meta.url));
   for (const scriptName of hookScripts) {
-    const devSource = join40(process.cwd(), "scripts", scriptName);
-    const installedSource = join40(__dirname7, "..", "..", "..", "scripts", scriptName);
-    const scriptDest = join40(binDir, scriptName);
+    const devSource = join41(process.cwd(), "scripts", scriptName);
+    const installedSource = join41(__dirname7, "..", "..", "..", "scripts", scriptName);
+    const scriptDest = join41(binDir, scriptName);
     let sourcePath = null;
-    if (existsSync41(devSource)) {
+    if (existsSync42(devSource)) {
       sourcePath = devSource;
-    } else if (existsSync41(installedSource)) {
+    } else if (existsSync42(installedSource)) {
       sourcePath = installedSource;
     }
     if (!sourcePath) {
@@ -12539,12 +12747,12 @@ async function setupHooksCommand() {
     chmodSync(scriptDest, 493);
   }
   console.log(chalk39.green("\u2713 Installed hook scripts (pre-tool, post-tool, stop, specialist-stop)"));
-  const claudeDir = join40(homedir19(), ".claude");
-  const settingsPath = join40(claudeDir, "settings.json");
+  const claudeDir = join41(homedir19(), ".claude");
+  const settingsPath = join41(claudeDir, "settings.json");
   let settings = {};
-  if (existsSync41(settingsPath)) {
+  if (existsSync42(settingsPath)) {
     try {
-      const settingsContent = readFileSync36(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) {
@@ -12553,7 +12761,7 @@ async function setupHooksCommand() {
     }
   } else {
     console.log(chalk39.dim("No existing settings.json found, creating new file"));
-    if (!existsSync41(claudeDir)) {
+    if (!existsSync42(claudeDir)) {
       mkdirSync20(claudeDir, { recursive: true });
     }
   }
@@ -12567,11 +12775,11 @@ async function setupHooksCommand() {
     console.log(chalk39.dim("  Install Python3 to enable token-efficient code analysis\n"));
   }
   if (python3Available) {
-    const mcpPath = join40(dirname17(settingsPath), "mcp.json");
+    const mcpPath = join41(dirname17(settingsPath), "mcp.json");
     let mcpConfig = {};
     try {
-      if (existsSync41(mcpPath)) {
-        mcpConfig = JSON.parse(readFileSync36(mcpPath, "utf-8"));
+      if (existsSync42(mcpPath)) {
+        mcpConfig = JSON.parse(readFileSync37(mcpPath, "utf-8"));
       }
     } catch {
       mcpConfig = {};
@@ -12606,7 +12814,7 @@ async function setupHooksCommand() {
     hooks: [
       {
         type: "command",
-        command: join40(binDir, "pre-tool-hook")
+        command: join41(binDir, "pre-tool-hook")
       }
     ]
   });
@@ -12616,7 +12824,7 @@ async function setupHooksCommand() {
       hooks: [
         {
           type: "command",
-          command: join40(binDir, "tldr-read-enforcer")
+          command: join41(binDir, "tldr-read-enforcer")
         }
       ]
     });
@@ -12629,7 +12837,7 @@ async function setupHooksCommand() {
     hooks: [
       {
         type: "command",
-        command: join40(binDir, "heartbeat-hook")
+        command: join41(binDir, "heartbeat-hook")
       }
     ]
   });
@@ -12639,7 +12847,7 @@ async function setupHooksCommand() {
       hooks: [
         {
           type: "command",
-          command: join40(binDir, "tldr-post-edit")
+          command: join41(binDir, "tldr-post-edit")
         }
       ]
     });
@@ -12652,7 +12860,7 @@ async function setupHooksCommand() {
     hooks: [
       {
         type: "command",
-        command: join40(binDir, "stop-hook")
+        command: join41(binDir, "stop-hook")
       }
     ]
   });
@@ -12762,20 +12970,20 @@ init_specialists();
 init_paths();
 init_tmux();
 import chalk41 from "chalk";
-import { exec as exec13 } from "child_process";
-import { promisify as promisify13 } from "util";
+import { exec as exec14 } from "child_process";
+import { promisify as promisify14 } from "util";
 import { setTimeout as sleep2 } from "timers/promises";
-import { existsSync as existsSync42, mkdirSync as mkdirSync21, writeFileSync as writeFileSync22 } from "fs";
-import { join as join41 } from "path";
-var execAsync13 = promisify13(exec13);
-var TASKS_DIR = join41(PANOPTICON_HOME, "specialists", "tasks");
+import { existsSync as existsSync43, mkdirSync as mkdirSync21, writeFileSync as writeFileSync22 } from "fs";
+import { join as join42 } from "path";
+var execAsync14 = promisify14(exec14);
+var TASKS_DIR = join42(PANOPTICON_HOME, "specialists", "tasks");
 function sendTask(tmuxSession, specialistName, task) {
   const isLargeTask = task.length > 500 || task.includes("\n");
   if (isLargeTask) {
-    if (!existsSync42(TASKS_DIR)) {
+    if (!existsSync43(TASKS_DIR)) {
       mkdirSync21(TASKS_DIR, { recursive: true });
     }
-    const taskFile = join41(TASKS_DIR, `${specialistName}-${Date.now()}.md`);
+    const taskFile = join42(TASKS_DIR, `${specialistName}-${Date.now()}.md`);
     writeFileSync22(taskFile, task, "utf-8");
     const shortMessage = `Read and execute the task in: ${taskFile}`;
     sendKeys(tmuxSession, shortMessage);
@@ -12829,7 +13037,7 @@ Waking ${status.displayName}...
       console.log(chalk41.dim("Starting fresh session (no previous session found)"));
     }
     console.log(chalk41.dim(`Creating tmux session: ${tmuxSession}`));
-    await execAsync13(
+    await execAsync14(
       `tmux new-session -d -s "${tmuxSession}" -c "${cwd}" "${claudeCmd}"`,
       { encoding: "utf-8" }
     );
@@ -12953,10 +13161,10 @@ function getAge(date) {
 init_esm_shims();
 init_specialists();
 import chalk43 from "chalk";
-import { exec as exec14 } from "child_process";
-import { promisify as promisify14 } from "util";
+import { exec as exec15 } from "child_process";
+import { promisify as promisify15 } from "util";
 import * as readline from "readline";
-var execAsync14 = promisify14(exec14);
+var execAsync15 = promisify15(exec15);
 var ALL_SPECIALISTS = ["merge-agent", "review-agent", "test-agent", "inspect-agent", "uat-agent"];
 async function resetCommand(name, options) {
   if (options.all) {
@@ -13006,7 +13214,7 @@ Resetting ${status.displayName}...
   if (status.isRunning) {
     console.log(chalk43.dim("Stopping tmux session..."));
     try {
-      await execAsync14(`tmux kill-session -t "${status.tmuxSession}"`, { encoding: "utf-8" });
+      await execAsync15(`tmux kill-session -t "${status.tmuxSession}"`, { encoding: "utf-8" });
       console.log(chalk43.green("\u2713 Tmux session stopped"));
     } catch (error) {
       console.log(chalk43.yellow("\u26A0 Failed to stop tmux session (may not be running)"));
@@ -13060,7 +13268,7 @@ async function resetAllSpecialists(options) {
     const tmuxSession = getTmuxSessionName(specialistName);
     if (status.isRunning) {
       try {
-        await execAsync14(`tmux kill-session -t "${tmuxSession}"`, { encoding: "utf-8" });
+        await execAsync15(`tmux kill-session -t "${tmuxSession}"`, { encoding: "utf-8" });
         console.log(chalk43.dim(`  Stopped ${specialistName} tmux session`));
       } catch {
       }
@@ -13083,11 +13291,11 @@ init_esm_shims();
 init_specialists();
 init_paths();
 import chalk44 from "chalk";
-import { existsSync as existsSync43, readFileSync as readFileSync37, writeFileSync as writeFileSync23 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync44, readFileSync as readFileSync38, writeFileSync as writeFileSync23 } from "fs";
+import { join as join43 } from "path";
 import * as readline2 from "readline";
 var ALL_SPECIALISTS2 = ["merge-agent", "review-agent", "test-agent", "inspect-agent", "uat-agent"];
-var REVIEW_STATUS_FILE2 = join42(PANOPTICON_HOME, "review-status.json");
+var REVIEW_STATUS_FILE2 = join43(PANOPTICON_HOME, "review-status.json");
 async function clearQueueCommand(name, options) {
   if (!ALL_SPECIALISTS2.includes(name)) {
     console.log(chalk44.red(`
@@ -13137,10 +13345,10 @@ ${metadata.displayName} Queue:
       issueIds.push(payload.issueId);
     }
   }
-  const hookFile = join42(PANOPTICON_HOME, "agents", specialistName, "hook.json");
-  if (existsSync43(hookFile)) {
+  const hookFile = join43(PANOPTICON_HOME, "agents", specialistName, "hook.json");
+  if (existsSync44(hookFile)) {
     try {
-      const hook = JSON.parse(readFileSync37(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");
@@ -13151,9 +13359,9 @@ ${metadata.displayName} Queue:
     }
   }
   if (options.resetStatus && issueIds.length > 0) {
-    if (existsSync43(REVIEW_STATUS_FILE2)) {
+    if (existsSync44(REVIEW_STATUS_FILE2)) {
       try {
-        const statuses = JSON.parse(readFileSync37(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());
@@ -13306,13 +13514,13 @@ function formatStatus(status) {
 
 // src/cli/commands/specialists/logs.ts
 init_esm_shims();
-import { existsSync as existsSync44 } from "fs";
-import { exec as exec15 } from "child_process";
-import { promisify as promisify15 } from "util";
-var execAsync15 = promisify15(exec15);
+import { existsSync as existsSync45 } from "fs";
+import { exec as exec16 } from "child_process";
+import { promisify as promisify16 } from "util";
+var execAsync16 = promisify16(exec16);
 async function listLogsCommand(project2, type, options) {
   try {
-    const { listRunLogs } = await import("../specialist-logs-FQRI3AIS.js");
+    const { listRunLogs } = await import("../specialist-logs-B7UC3UDO.js");
     const limit = options.limit ? parseInt(options.limit) : 10;
     const runs = listRunLogs(project2, type, { limit });
     if (options.json) {
@@ -13357,7 +13565,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-FQRI3AIS.js");
+    const { getRunLog, parseLogMetadata, getRunLogPath } = await import("../specialist-logs-B7UC3UDO.js");
     const content = getRunLog(project2, type, runId);
     if (!content) {
       console.error(`\u274C Run log not found: ${runId}`);
@@ -13370,7 +13578,7 @@ async function viewLogCommand(project2, type, runId, options) {
     }
     const logPath = getRunLogPath(project2, type, runId);
     try {
-      await execAsync15(`less -R "${logPath}"`);
+      await execAsync16(`less -R "${logPath}"`);
     } catch {
       console.log(content);
     }
@@ -13381,15 +13589,15 @@ async function viewLogCommand(project2, type, runId, options) {
 }
 async function tailLogCommand(project2, type) {
   try {
-    const { getRunLogPath } = await import("../specialist-logs-FQRI3AIS.js");
-    const { getProjectSpecialistMetadata } = await import("../specialists-CXRGSJY3.js");
+    const { getRunLogPath } = await import("../specialist-logs-B7UC3UDO.js");
+    const { getProjectSpecialistMetadata } = await import("../specialists-X4OGA7WX.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 (!existsSync44(logPath)) {
+    if (!existsSync45(logPath)) {
       console.error(`\u274C Log file not found: ${logPath}`);
       process.exit(1);
     }
@@ -13451,7 +13659,7 @@ async function cleanupLogsCommand(projectOrAll, type, options) {
         console.log("   Use --force to confirm.");
         process.exit(1);
       }
-      const { cleanupAllLogs } = await import("../specialist-logs-FQRI3AIS.js");
+      const { cleanupAllLogs } = await import("../specialist-logs-B7UC3UDO.js");
       console.log("\u{1F9F9} Cleaning up old logs for all projects...\n");
       const results = cleanupAllLogs();
       console.log(`
@@ -13478,7 +13686,7 @@ async function cleanupLogsCommand(projectOrAll, type, options) {
       console.log("   Use --force to confirm.");
       process.exit(1);
     }
-    const { cleanupOldLogs } = await import("../specialist-logs-FQRI3AIS.js");
+    const { cleanupOldLogs } = await import("../specialist-logs-B7UC3UDO.js");
     const { getSpecialistRetention } = await import("../projects-BPGM6IFB.js");
     const retention = getSpecialistRetention(projectOrAll);
     console.log(`\u{1F9F9} Cleaning up old logs for ${projectOrAll}/${type}...`);
@@ -13517,11 +13725,11 @@ import ora19 from "ora";
 // src/lib/convoy.ts
 init_esm_shims();
 init_tmux();
-import { existsSync as existsSync45, mkdirSync as mkdirSync22, writeFileSync as writeFileSync24, readFileSync as readFileSync39, readdirSync as readdirSync19 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync46, mkdirSync as mkdirSync22, writeFileSync as writeFileSync24, readFileSync as readFileSync40, readdirSync as readdirSync19 } from "fs";
+import { join as join44 } from "path";
 import { homedir as homedir20 } from "os";
-import { exec as exec16 } from "child_process";
-import { promisify as promisify16 } from "util";
+import { exec as exec17 } from "child_process";
+import { promisify as promisify17 } from "util";
 import { parse as parseYaml } from "yaml";
 
 // src/lib/convoy-templates.ts
@@ -13626,14 +13834,14 @@ function getExecutionOrder(template) {
 // src/lib/convoy.ts
 init_paths();
 init_work_type_router();
-var execAsync16 = promisify16(exec16);
-var CONVOY_DIR = join43(homedir20(), ".panopticon", "convoys");
+var execAsync17 = promisify17(exec17);
+var CONVOY_DIR = join44(homedir20(), ".panopticon", "convoys");
 function getConvoyStateFile(convoyId) {
-  return join43(CONVOY_DIR, `${convoyId}.json`);
+  return join44(CONVOY_DIR, `${convoyId}.json`);
 }
 function getConvoyOutputDir(convoyId, template) {
   const baseDir = template.config?.outputDir || ".panopticon/convoy-output";
-  return join43(process.cwd(), baseDir, convoyId);
+  return join44(process.cwd(), baseDir, convoyId);
 }
 function saveConvoyState(state) {
   mkdirSync22(CONVOY_DIR, { recursive: true });
@@ -13641,11 +13849,11 @@ function saveConvoyState(state) {
 }
 function loadConvoyState(convoyId) {
   const stateFile = getConvoyStateFile(convoyId);
-  if (!existsSync45(stateFile)) {
+  if (!existsSync46(stateFile)) {
     return void 0;
   }
   try {
-    const content = readFileSync39(stateFile, "utf-8");
+    const content = readFileSync40(stateFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -13655,7 +13863,7 @@ function getConvoyStatus(convoyId) {
   return loadConvoyState(convoyId);
 }
 function listConvoys(filter) {
-  if (!existsSync45(CONVOY_DIR)) {
+  if (!existsSync46(CONVOY_DIR)) {
     return [];
   }
   const files = readdirSync19(CONVOY_DIR).filter((f) => f.endsWith(".json"));
@@ -13674,10 +13882,10 @@ function listConvoys(filter) {
   );
 }
 function parseAgentTemplate(templatePath) {
-  if (!existsSync45(templatePath)) {
+  if (!existsSync46(templatePath)) {
     throw new Error(`Agent template not found: ${templatePath}`);
   }
-  const content = readFileSync39(templatePath, "utf-8");
+  const content = readFileSync40(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}`);
@@ -13703,7 +13911,7 @@ function mapConvoyRoleToWorkType(role) {
 }
 async function spawnConvoyAgent(convoy, agent, agentState, context) {
   const { role, subagent } = agent;
-  const templatePath = join43(AGENTS_DIR, `${subagent}.md`);
+  const templatePath = join44(AGENTS_DIR, `${subagent}.md`);
   const template = parseAgentTemplate(templatePath);
   let model = template.model;
   try {
@@ -13742,7 +13950,7 @@ ${context.issueId ? `**Issue ID**: ${context.issueId}` : ""}
 `;
   prompt = contextInstructions + prompt;
   mkdirSync22(convoy.outputDir, { recursive: true });
-  const promptFile = join43(convoy.outputDir, `${role}-prompt.md`);
+  const promptFile = join44(convoy.outputDir, `${role}-prompt.md`);
   writeFileSync24(promptFile, prompt);
   const claudeCmd = `claude --dangerously-skip-permissions --model ${model}`;
   createSession(agentState.tmuxSession, convoy.context.projectPath, claudeCmd, {
@@ -13753,10 +13961,10 @@ ${context.issueId ? `**Issue ID**: ${context.issueId}` : ""}
     }
   });
   await new Promise((resolve3) => setTimeout(resolve3, 1500));
-  await execAsync16(`tmux load-buffer "${promptFile}"`);
-  await execAsync16(`tmux paste-buffer -t ${agentState.tmuxSession}`);
+  await execAsync17(`tmux load-buffer "${promptFile}"`);
+  await execAsync17(`tmux paste-buffer -t ${agentState.tmuxSession}`);
   await new Promise((resolve3) => setTimeout(resolve3, 500));
-  await execAsync16(`tmux send-keys -t ${agentState.tmuxSession} Enter`);
+  await execAsync17(`tmux send-keys -t ${agentState.tmuxSession} Enter`);
   agentState.status = "running";
   agentState.startedAt = (/* @__PURE__ */ new Date()).toISOString();
   saveConvoyState(convoy);
@@ -13781,7 +13989,7 @@ async function startConvoy(templateName, context) {
   };
   for (const agent of template.agents) {
     const tmuxSession = `${convoyId}-${agent.role}`;
-    const outputFile = join43(outputDir, `${agent.role}.md`);
+    const outputFile = join44(outputDir, `${agent.role}.md`);
     state.agents.push({
       role: agent.role,
       subagent: agent.subagent,
@@ -13816,8 +14024,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 && existsSync45(depAgent.outputFile)) {
-        agentContext[`${depRole}_output`] = readFileSync39(depAgent.outputFile, "utf-8");
+      if (depAgent?.outputFile && existsSync46(depAgent.outputFile)) {
+        agentContext[`${depRole}_output`] = readFileSync40(depAgent.outputFile, "utf-8");
       }
     }
     spawnPromises.push(spawnConvoyAgent(convoy, agent, agentState, agentContext));
@@ -13880,7 +14088,7 @@ function updateAgentStatuses(convoy) {
       agent.status = "completed";
       agent.completedAt = (/* @__PURE__ */ new Date()).toISOString();
       updated = true;
-      if (agent.outputFile && existsSync45(agent.outputFile)) {
+      if (agent.outputFile && existsSync46(agent.outputFile)) {
         agent.exitCode = 0;
       } else {
         agent.exitCode = 1;
@@ -14126,30 +14334,30 @@ function registerConvoyCommands(program2) {
 init_esm_shims();
 init_projects();
 import chalk50 from "chalk";
-import { existsSync as existsSync46, readFileSync as readFileSync40, symlinkSync as symlinkSync2, mkdirSync as mkdirSync23, readdirSync as readdirSync20, statSync as statSync10 } from "fs";
-import { join as join44, resolve as resolve2, dirname as dirname13 } from "path";
+import { existsSync as existsSync47, readFileSync as readFileSync41, symlinkSync as symlinkSync2, mkdirSync as mkdirSync23, readdirSync as readdirSync20, statSync as statSync10 } from "fs";
+import { join as join45, resolve as resolve2, dirname as dirname13 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __filename5 = fileURLToPath4(import.meta.url);
 var __dirname5 = dirname13(__filename5);
-var BUNDLED_HOOKS_DIR = join44(__dirname5, "..", "..", "scripts", "git-hooks");
+var BUNDLED_HOOKS_DIR = join45(__dirname5, "..", "..", "scripts", "git-hooks");
 function installGitHooks(gitDir) {
-  const hooksTarget = join44(gitDir, "hooks");
+  const hooksTarget = join45(gitDir, "hooks");
   let installed = 0;
-  if (!existsSync46(hooksTarget)) {
+  if (!existsSync47(hooksTarget)) {
     mkdirSync23(hooksTarget, { recursive: true });
   }
-  if (!existsSync46(BUNDLED_HOOKS_DIR)) {
+  if (!existsSync47(BUNDLED_HOOKS_DIR)) {
     return 0;
   }
   try {
     const hooks = readdirSync20(BUNDLED_HOOKS_DIR).filter((f) => {
-      const p = join44(BUNDLED_HOOKS_DIR, f);
-      return existsSync46(p) && statSync10(p).isFile();
+      const p = join45(BUNDLED_HOOKS_DIR, f);
+      return existsSync47(p) && statSync10(p).isFile();
     });
     for (const hook of hooks) {
-      const source = join44(BUNDLED_HOOKS_DIR, hook);
-      const target = join44(hooksTarget, hook);
-      if (existsSync46(target)) {
+      const source = join45(BUNDLED_HOOKS_DIR, hook);
+      const target = join45(hooksTarget, hook);
+      if (existsSync47(target)) {
         try {
           const { readlinkSync: readlinkSync2 } = __require("fs");
           if (readlinkSync2(target) === source) {
@@ -14158,7 +14366,7 @@ function installGitHooks(gitDir) {
         } catch {
         }
       }
-      if (existsSync46(target)) {
+      if (existsSync47(target)) {
         const { renameSync: renameSync4 } = __require("fs");
         renameSync4(target, `${target}.backup`);
       }
@@ -14171,7 +14379,7 @@ function installGitHooks(gitDir) {
 }
 async function projectAddCommand(projectPath, options = {}) {
   const fullPath = resolve2(projectPath);
-  if (!existsSync46(fullPath)) {
+  if (!existsSync47(fullPath)) {
     console.log(chalk50.red(`Path does not exist: ${fullPath}`));
     return;
   }
@@ -14186,9 +14394,9 @@ async function projectAddCommand(projectPath, options = {}) {
   }
   let linearTeam = options.linearTeam;
   if (!linearTeam) {
-    const projectToml = join44(fullPath, ".panopticon", "project.toml");
-    if (existsSync46(projectToml)) {
-      const content = readFileSync40(projectToml, "utf-8");
+    const projectToml = join45(fullPath, ".panopticon", "project.toml");
+    if (existsSync47(projectToml)) {
+      const content = readFileSync41(projectToml, "utf-8");
       const match = content.match(/team\s*=\s*"([^"]+)"/);
       if (match) linearTeam = match[1];
     }
@@ -14214,19 +14422,19 @@ async function projectAddCommand(projectPath, options = {}) {
     console.log(chalk50.dim(`  Rally project: ${options.rallyProject}`));
   }
   console.log("");
-  const hasDevcontainer = existsSync46(join44(fullPath, ".devcontainer"));
-  const hasInfra = existsSync46(join44(fullPath, "infra"));
-  const hasDevcontainerTemplate = existsSync46(join44(fullPath, "infra", ".devcontainer-template")) || existsSync46(join44(fullPath, ".devcontainer-template"));
-  const hasRootGit = existsSync46(join44(fullPath, ".git"));
+  const hasDevcontainer = existsSync47(join45(fullPath, ".devcontainer"));
+  const hasInfra = existsSync47(join45(fullPath, "infra"));
+  const hasDevcontainerTemplate = existsSync47(join45(fullPath, "infra", ".devcontainer-template")) || existsSync47(join45(fullPath, ".devcontainer-template"));
+  const hasRootGit = existsSync47(join45(fullPath, ".git"));
   const subRepos = [];
   if (!hasRootGit) {
     const { readdirSync: readdirSync22, statSync: statSync12 } = await import("fs");
     try {
       const entries = readdirSync22(fullPath);
       for (const entry of entries) {
-        const entryPath = join44(fullPath, entry);
+        const entryPath = join45(fullPath, entry);
         try {
-          if (statSync12(entryPath).isDirectory() && existsSync46(join44(entryPath, ".git"))) {
+          if (statSync12(entryPath).isDirectory() && existsSync47(join45(entryPath, ".git"))) {
             subRepos.push(entry);
           }
         } catch {
@@ -14237,19 +14445,19 @@ async function projectAddCommand(projectPath, options = {}) {
   }
   const isPolyrepo = !hasRootGit && subRepos.length > 0;
   try {
-    const { preTrustDirectory } = await import("../workspace-manager-OWHLR5BL.js");
+    const { preTrustDirectory } = await import("../workspace-manager-6RP5A5HF.js");
     preTrustDirectory(fullPath);
   } catch {
   }
   let hooksInstalled = 0;
   if (hasRootGit) {
-    hooksInstalled = installGitHooks(join44(fullPath, ".git"));
+    hooksInstalled = installGitHooks(join45(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(join44(fullPath, repo, ".git"));
+      const count = installGitHooks(join45(fullPath, repo, ".git"));
       hooksInstalled += count;
     }
     if (hooksInstalled > 0) {
@@ -14321,7 +14529,7 @@ async function projectListCommand(options = {}) {
   }
   console.log(chalk50.bold("\nRegistered Projects:\n"));
   for (const { key, config: config2 } of projects) {
-    const exists = existsSync46(config2.path);
+    const exists = existsSync47(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)}`);
@@ -14355,7 +14563,7 @@ async function projectRemoveCommand(nameOrPath) {
   console.log(chalk50.dim(`Use 'pan project list' to see registered projects.`));
 }
 async function projectInitCommand() {
-  if (existsSync46(PROJECTS_CONFIG_FILE)) {
+  if (existsSync47(PROJECTS_CONFIG_FILE)) {
     console.log(chalk50.yellow(`Config already exists: ${PROJECTS_CONFIG_FILE}`));
     return;
   }
@@ -14389,7 +14597,7 @@ async function projectShowCommand(keyOrName) {
     console.log(chalk50.dim(`Use 'pan project list' to see registered projects.`));
     process.exit(1);
   }
-  const pathExists = existsSync46(found.path);
+  const pathExists = existsSync47(found.path);
   const pathStatus = pathExists ? chalk50.green("\u2713") : chalk50.red("\u2717");
   console.log(chalk50.bold(`
 Project: ${foundKey}
@@ -14421,10 +14629,10 @@ Project: ${foundKey}
 init_esm_shims();
 init_paths();
 import chalk51 from "chalk";
-import { existsSync as existsSync47, readdirSync as readdirSync21, readFileSync as readFileSync41 } from "fs";
+import { existsSync as existsSync48, readdirSync as readdirSync21, readFileSync as readFileSync42 } from "fs";
 import { execSync as execSync6 } from "child_process";
 import { homedir as homedir21 } from "os";
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 function checkCommand3(cmd) {
   try {
     execSync6(`which ${cmd}`, { encoding: "utf-8", stdio: "pipe" });
@@ -14434,10 +14642,10 @@ function checkCommand3(cmd) {
   }
 }
 function checkDirectory(path) {
-  return existsSync47(path);
+  return existsSync48(path);
 }
 function countItems(path) {
-  if (!existsSync47(path)) return 0;
+  if (!existsSync48(path)) return 0;
   try {
     return readdirSync21(path).length;
   } catch {
@@ -14488,8 +14696,8 @@ async function doctorCommand() {
     }
   }
   if (checkDirectory(CLAUDE_DIR)) {
-    const skillsCount = countItems(join45(CLAUDE_DIR, "skills"));
-    const commandsCount = countItems(join45(CLAUDE_DIR, "commands"));
+    const skillsCount = countItems(join46(CLAUDE_DIR, "skills"));
+    const commandsCount = countItems(join46(CLAUDE_DIR, "commands"));
     checks.push({
       name: "Claude Code Skills",
       status: skillsCount > 0 ? "ok" : "warn",
@@ -14510,8 +14718,8 @@ async function doctorCommand() {
       fix: "Install Claude Code first"
     });
   }
-  const envFile = join45(homedir21(), ".panopticon.env");
-  if (existsSync47(envFile)) {
+  const envFile = join46(homedir21(), ".panopticon.env");
+  if (existsSync48(envFile)) {
     checks.push({ name: "Config File", status: "ok", message: "~/.panopticon.env exists" });
   } else {
     checks.push({
@@ -14523,8 +14731,8 @@ async function doctorCommand() {
   }
   if (process.env.LINEAR_API_KEY) {
     checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in environment" });
-  } else if (existsSync47(envFile)) {
-    const content = readFileSync41(envFile, "utf-8");
+  } else if (existsSync48(envFile)) {
+    const content = readFileSync42(envFile, "utf-8");
     if (content.includes("LINEAR_API_KEY")) {
       checks.push({ name: "LINEAR_API_KEY", status: "ok", message: "Set in config file" });
     } else {
@@ -14592,15 +14800,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 readFileSync43 } from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname14, join as join46 } from "path";
+import { dirname as dirname14, join as join47 } from "path";
 function getCurrentVersion() {
   try {
     const __filename7 = fileURLToPath5(import.meta.url);
     const __dirname7 = dirname14(__filename7);
-    const pkgPath = join46(__dirname7, "..", "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync42(pkgPath, "utf-8"));
+    const pkgPath = join47(__dirname7, "..", "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync43(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "unknown";
@@ -14686,11 +14894,11 @@ init_esm_shims();
 init_projects();
 import chalk53 from "chalk";
 import ora21 from "ora";
-import { existsSync as existsSync48, readFileSync as readFileSync43, writeFileSync as writeFileSync25, mkdirSync as mkdirSync24, statSync as statSync11 } from "fs";
-import { join as join47, dirname as dirname15 } from "path";
-import { exec as exec17 } from "child_process";
-import { promisify as promisify17 } from "util";
-var execAsync17 = promisify17(exec17);
+import { existsSync as existsSync49, readFileSync as readFileSync44, writeFileSync as writeFileSync25, mkdirSync as mkdirSync24, statSync as statSync11 } from "fs";
+import { join as join48, dirname as dirname15 } from "path";
+import { exec as exec18 } from "child_process";
+import { promisify as promisify18 } from "util";
+var execAsync18 = promisify18(exec18);
 function loadFullProjects() {
   const config2 = loadProjectsConfig();
   const projects = config2.projects;
@@ -14749,9 +14957,9 @@ async function snapshotCommand(options) {
 `));
       return;
     }
-    const outputPath = options.output || dbConfig.seed_file || join47(projectConfig.path, "infra", "seed", "seed.sql");
+    const outputPath = options.output || dbConfig.seed_file || join48(projectConfig.path, "infra", "seed", "seed.sql");
     const outputDir = dirname15(outputPath);
-    if (!existsSync48(outputDir)) {
+    if (!existsSync49(outputDir)) {
       mkdirSync24(outputDir, { recursive: true });
     }
     spinner.text = "Running snapshot command...";
@@ -14772,10 +14980,10 @@ async function snapshotCommand(options) {
     }
     const fullCmd = `${snapshotCmd} > "${outputPath}" 2>&1`;
     try {
-      await execAsync17(fullCmd, { timeout: 3e5 });
+      await execAsync18(fullCmd, { timeout: 3e5 });
     } catch (error) {
-      if (existsSync48(outputPath)) {
-        const content2 = readFileSync43(outputPath, "utf-8");
+      if (existsSync49(outputPath)) {
+        const content2 = readFileSync44(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"));
@@ -14788,7 +14996,7 @@ async function snapshotCommand(options) {
         return;
       }
     }
-    const content = readFileSync43(outputPath, "utf-8");
+    const content = readFileSync44(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);
@@ -14796,7 +15004,7 @@ async function snapshotCommand(options) {
     if (options.sanitize && dbConfig.seed_command) {
       spinner.text = "Running sanitization...";
       try {
-        await execAsync17(dbConfig.seed_command, { cwd: projectConfig.path });
+        await execAsync18(dbConfig.seed_command, { cwd: projectConfig.path });
       } catch (error) {
         spinner.warn(`Sanitization warning: ${error.message}`);
       }
@@ -14820,14 +15028,14 @@ async function seedCommand(workspaceOrIssue, options) {
       spinner.fail("Could not find project workspace configuration");
       return;
     }
-    const workspacePath = join47(projectConfig.path, projectConfig.workspace.workspaces_dir || "workspaces", folderName);
-    if (!existsSync48(workspacePath)) {
+    const workspacePath = join48(projectConfig.path, projectConfig.workspace.workspaces_dir || "workspaces", folderName);
+    if (!existsSync49(workspacePath)) {
       spinner.fail(`Workspace not found: ${workspacePath}`);
       return;
     }
     const dbConfig = projectConfig.workspace.database;
     const seedFile = options.file || dbConfig?.seed_file;
-    if (!seedFile || !existsSync48(seedFile)) {
+    if (!seedFile || !existsSync49(seedFile)) {
       spinner.fail(`Seed file not found: ${seedFile || "(not configured)"}`);
       console.log(chalk53.dim("\nConfigure seed_file in projects.yaml or use --file"));
       return;
@@ -14836,7 +15044,7 @@ async function seedCommand(workspaceOrIssue, options) {
     const containerName = dbConfig?.container_name?.replace("{{PROJECT}}", projectName) || `${projectName}-postgres-1`;
     spinner.text = `Finding database container ${containerName}...`;
     try {
-      const { stdout } = await execAsync17(`docker ps --filter "name=${containerName}" --format "{{.Names}}"`);
+      const { stdout } = await execAsync18(`docker ps --filter "name=${containerName}" --format "{{.Names}}"`);
       if (!stdout.trim()) {
         spinner.fail(`Database container not running: ${containerName}`);
         console.log(chalk53.dim("\nStart the workspace containers first:"));
@@ -14849,7 +15057,7 @@ async function seedCommand(workspaceOrIssue, options) {
     }
     if (!options.force) {
       try {
-        const { stdout } = await execAsync17(
+        const { stdout } = await execAsync18(
           `docker exec ${containerName} psql -U postgres -d myn -c "SELECT count(*) FROM flyway_schema_history" -t 2>/dev/null`
         );
         const count = parseInt(stdout.trim(), 10);
@@ -14863,7 +15071,7 @@ async function seedCommand(workspaceOrIssue, options) {
     if (options.force) {
       spinner.text = "Dropping existing database...";
       try {
-        await execAsync17(
+        await execAsync18(
           `docker exec ${containerName} psql -U postgres -c "DROP DATABASE IF EXISTS myn; CREATE DATABASE myn;"`
         );
       } catch (error) {
@@ -14871,10 +15079,10 @@ async function seedCommand(workspaceOrIssue, options) {
       }
     }
     spinner.text = "Copying seed file to container...";
-    await execAsync17(`docker cp "${seedFile}" ${containerName}:/tmp/seed.sql`);
+    await execAsync18(`docker cp "${seedFile}" ${containerName}:/tmp/seed.sql`);
     spinner.text = "Executing seed...";
     try {
-      await execAsync17(`docker exec ${containerName} psql -U postgres -d myn -f /tmp/seed.sql`, {
+      await execAsync18(`docker exec ${containerName} psql -U postgres -d myn -f /tmp/seed.sql`, {
         timeout: 6e5
         // 10 minute timeout for large seeds
       });
@@ -14884,10 +15092,10 @@ async function seedCommand(workspaceOrIssue, options) {
         return;
       }
     }
-    await execAsync17(`docker exec ${containerName} rm /tmp/seed.sql`);
+    await execAsync18(`docker exec ${containerName} rm /tmp/seed.sql`);
     spinner.succeed("Database seeded successfully");
     try {
-      const { stdout } = await execAsync17(
+      const { stdout } = await execAsync18(
         `docker exec ${containerName} psql -U postgres -d myn -c "SELECT version, description FROM flyway_schema_history ORDER BY installed_rank DESC LIMIT 3" -t`
       );
       console.log(chalk53.dim("\nRecent migrations:"));
@@ -14917,7 +15125,7 @@ async function statusCommand5(workspaceOrIssue) {
       const projects = loadFullProjects();
       projectConfig = projects.find((p) => cwd.startsWith(p.path));
       if (projectConfig) {
-        const { stdout } = await execAsync17(
+        const { stdout } = await execAsync18(
           `docker ps --filter "name=${projectConfig.name?.toLowerCase().replace(/\s+/g, "-")}" --filter "name=postgres" --format "{{.Names}}" | head -1`
         );
         containerName = stdout.trim();
@@ -14930,7 +15138,7 @@ async function statusCommand5(workspaceOrIssue) {
       return;
     }
     spinner.text = `Checking container ${containerName}...`;
-    const { stdout: containerStatus } = await execAsync17(
+    const { stdout: containerStatus } = await execAsync18(
       `docker ps --filter "name=${containerName}" --format "{{.Status}}"`
     );
     if (!containerStatus.trim()) {
@@ -14940,7 +15148,7 @@ async function statusCommand5(workspaceOrIssue) {
     spinner.succeed(`Container: ${containerName}`);
     console.log(chalk53.dim(`  Status: ${containerStatus.trim()}`));
     try {
-      const { stdout: version } = await execAsync17(
+      const { stdout: version } = await execAsync18(
         `docker exec ${containerName} psql -U postgres -d myn -c "SELECT version, description FROM flyway_schema_history ORDER BY installed_rank DESC LIMIT 1" -t`
       );
       const [ver, desc] = version.trim().split("|").map((s) => s.trim());
@@ -14949,14 +15157,14 @@ async function statusCommand5(workspaceOrIssue) {
       console.log(chalk53.yellow("  Flyway: Not initialized"));
     }
     try {
-      const { stdout: tableCount } = await execAsync17(
+      const { stdout: tableCount } = await execAsync18(
         `docker exec ${containerName} psql -U postgres -d myn -c "SELECT count(*) FROM information_schema.tables WHERE table_schema = 'public'" -t`
       );
       console.log(chalk53.dim(`  Tables: ${tableCount.trim()}`));
     } catch {
     }
     try {
-      const { stdout: dbSize } = await execAsync17(
+      const { stdout: dbSize } = await execAsync18(
         `docker exec ${containerName} psql -U postgres -d myn -c "SELECT pg_size_pretty(pg_database_size('myn'))" -t`
       );
       console.log(chalk53.dim(`  Size: ${dbSize.trim()}`));
@@ -14969,11 +15177,11 @@ async function statusCommand5(workspaceOrIssue) {
 async function cleanCommand(file, options) {
   const spinner = ora21("Cleaning database dump file...").start();
   try {
-    if (!existsSync48(file)) {
+    if (!existsSync49(file)) {
       spinner.fail(`File not found: ${file}`);
       return;
     }
-    const content = readFileSync43(file, "utf-8");
+    const content = readFileSync44(file, "utf-8");
     const lines = content.split("\n");
     const patternsToRemove = [
       /^Defaulted container/,
@@ -15043,7 +15251,7 @@ async function cleanCommand(file, options) {
   }
 }
 async function cleanFile(filePath) {
-  const content = readFileSync43(filePath, "utf-8");
+  const content = readFileSync44(filePath, "utf-8");
   const lines = content.split("\n");
   let startIndex = 0;
   for (let i = 0; i < lines.length; i++) {
@@ -15097,7 +15305,7 @@ async function configCommand(project2) {
     return;
   }
   if (dbConfig.seed_file) {
-    const exists = existsSync48(dbConfig.seed_file);
+    const exists = existsSync49(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) {
@@ -15126,17 +15334,17 @@ async function configCommand(project2) {
 init_esm_shims();
 import chalk54 from "chalk";
 import ora22 from "ora";
-import { existsSync as existsSync49, readFileSync as readFileSync44 } from "fs";
-import { join as join48 } from "path";
-import { exec as exec18, execSync as execSync8 } from "child_process";
-import { promisify as promisify18 } from "util";
+import { existsSync as existsSync50, readFileSync as readFileSync45 } from "fs";
+import { join as join49 } from "path";
+import { exec as exec19, execSync as execSync8 } from "child_process";
+import { promisify as promisify19 } from "util";
 import { platform } from "os";
-var execAsync18 = promisify18(exec18);
+var execAsync19 = promisify19(exec19);
 function detectPlatform2() {
   const os = platform();
   if (os === "linux") {
     try {
-      const release = readFileSync44("/proc/version", "utf8").toLowerCase();
+      const release = readFileSync45("/proc/version", "utf8").toLowerCase();
       if (release.includes("microsoft") || release.includes("wsl")) {
         return "wsl";
       }
@@ -15148,7 +15356,7 @@ function detectPlatform2() {
 }
 async function isBdAvailable() {
   try {
-    await execAsync18("which bd", { encoding: "utf-8" });
+    await execAsync19("which bd", { encoding: "utf-8" });
     return true;
   } catch {
     return false;
@@ -15157,7 +15365,7 @@ async function isBdAvailable() {
 async function getOldClosedCount(cwd, days) {
   try {
     const seconds = days * 24 * 60 * 60;
-    const { stdout } = await execAsync18(
+    const { stdout } = await execAsync19(
       `bd list --status closed --json 2>/dev/null | jq '[.[] | select(.closed_at != null) | select((now - (.closed_at | fromdateiso8601)) > ${seconds})] | length' 2>/dev/null || echo "0"`,
       { cwd, encoding: "utf-8" }
     );
@@ -15174,8 +15382,8 @@ async function compactCommand(options) {
     console.log(chalk54.dim("Install beads: https://github.com/steveyegge/beads"));
     process.exit(1);
   }
-  const beadsDir = join48(cwd, ".beads");
-  if (!existsSync49(beadsDir)) {
+  const beadsDir = join49(cwd, ".beads");
+  if (!existsSync50(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);
@@ -15193,7 +15401,7 @@ async function compactCommand(options) {
       console.log("");
       console.log(chalk54.bold("Beads that would be compacted:"));
       try {
-        const { stdout: beadsList } = await execAsync18(
+        const { stdout: beadsList } = await execAsync19(
           `bd list --status closed --json 2>/dev/null | jq -r '.[] | select(.closed_at != null) | select((now - (.closed_at | fromdateiso8601)) > ${days * 24 * 60 * 60}) | "  - \\(.id): \\(.title)"' 2>/dev/null`,
           { cwd, encoding: "utf-8" }
         );
@@ -15204,10 +15412,10 @@ async function compactCommand(options) {
       return;
     }
     spinner.text = "Running compaction...";
-    await execAsync18(`bd admin compact --days ${days}`, { cwd, encoding: "utf-8" });
+    await execAsync19(`bd admin compact --days ${days}`, { cwd, encoding: "utf-8" });
     spinner.succeed(`Compacted ${count} beads older than ${days} days`);
     try {
-      await execAsync18(`git diff --quiet .beads/`, { cwd, encoding: "utf-8" });
+      await execAsync19(`git diff --quiet .beads/`, { cwd, encoding: "utf-8" });
       console.log(chalk54.dim("No changes to commit (beads already up to date)"));
     } catch {
       console.log("");
@@ -15234,24 +15442,24 @@ async function statsCommand() {
     console.error(chalk54.red("Error: bd (beads) CLI not found"));
     process.exit(1);
   }
-  const beadsDir = join48(cwd, ".beads");
-  if (!existsSync49(beadsDir)) {
+  const beadsDir = join49(cwd, ".beads");
+  if (!existsSync50(beadsDir)) {
     console.error(chalk54.red("Error: No .beads directory found"));
     process.exit(1);
   }
   const spinner = ora22("Gathering beads statistics...").start();
   try {
-    const { stdout: totalRaw } = await execAsync18(`bd list --limit 0 --json 2>/dev/null | jq 'length'`, {
+    const { stdout: totalRaw } = await execAsync19(`bd list --limit 0 --json 2>/dev/null | jq 'length'`, {
       cwd,
       encoding: "utf-8"
     });
     const total = parseInt(totalRaw.trim(), 10) || 0;
-    const { stdout: openRaw } = await execAsync18(`bd list --status open --limit 0 --json 2>/dev/null | jq 'length'`, {
+    const { stdout: openRaw } = await execAsync19(`bd list --status open --limit 0 --json 2>/dev/null | jq 'length'`, {
       cwd,
       encoding: "utf-8"
     });
     const open = parseInt(openRaw.trim(), 10) || 0;
-    const { stdout: closedRaw } = await execAsync18(`bd list --status closed --limit 0 --json 2>/dev/null | jq 'length'`, {
+    const { stdout: closedRaw } = await execAsync19(`bd list --status closed --limit 0 --json 2>/dev/null | jq 'length'`, {
       cwd,
       encoding: "utf-8"
     });
@@ -15296,7 +15504,7 @@ async function upgradeCommand(checkOnly = false) {
   console.log(chalk54.dim("Checking beads version..."));
   let currentVersion = "not installed";
   try {
-    const { stdout } = await execAsync18("bd --version", { encoding: "utf-8" });
+    const { stdout } = await execAsync19("bd --version", { encoding: "utf-8" });
     const match = stdout.match(/(\d+\.\d+\.\d+)/);
     if (match) {
       currentVersion = match[1];
@@ -15305,7 +15513,7 @@ async function upgradeCommand(checkOnly = false) {
   }
   let latestVersion = "unknown";
   try {
-    const { stdout } = await execAsync18(
+    const { stdout } = await execAsync19(
       "curl -sL https://api.github.com/repos/steveyegge/beads/releases/latest | jq -r .tag_name",
       { encoding: "utf-8" }
     );
@@ -15354,7 +15562,7 @@ async function upgradeCommand(checkOnly = false) {
       spinner.succeed("beads upgraded via install script");
     }
     try {
-      const { stdout } = await execAsync18("bd --version", { encoding: "utf-8" });
+      const { stdout } = await execAsync19("bd --version", { encoding: "utf-8" });
       const match = stdout.match(/(\d+\.\d+\.\d+)/);
       if (match) {
         console.log(chalk54.green(`
@@ -15567,9 +15775,9 @@ init_esm_shims();
 init_config();
 import chalk57 from "chalk";
 import ora25 from "ora";
-import { exec as exec19 } from "child_process";
-import { promisify as promisify19 } from "util";
-var execAsync19 = promisify19(exec19);
+import { exec as exec20 } from "child_process";
+import { promisify as promisify20 } from "util";
+var execAsync20 = promisify20(exec20);
 async function initCommand2(options) {
   const config2 = loadConfig();
   if (!config2.remote?.enabled) {
@@ -15763,9 +15971,9 @@ init_esm_shims();
 init_config();
 import chalk59 from "chalk";
 import ora27 from "ora";
-import { exec as exec20 } from "child_process";
-import { promisify as promisify20 } from "util";
-var execAsync20 = promisify20(exec20);
+import { exec as exec21 } from "child_process";
+import { promisify as promisify21 } from "util";
+var execAsync21 = promisify21(exec21);
 async function setupCommand() {
   console.log("");
   console.log(chalk59.bold("\u{1F680} Remote Workspace Setup"));
@@ -15774,7 +15982,7 @@ async function setupCommand() {
   const spinner = ora27("Checking flyctl installation...").start();
   let flyInstalled = false;
   try {
-    await execAsync20("fly version", { timeout: 1e4 });
+    await execAsync21("fly version", { timeout: 1e4 });
     flyInstalled = true;
     spinner.succeed("flyctl is installed");
   } catch {
@@ -15796,7 +16004,7 @@ async function setupCommand() {
     console.log(`  ${chalk59.green("\u2713")} Authenticated with Fly.io`);
     if (flyInstalled) {
       try {
-        const { stdout } = await execAsync20("fly auth whoami", { timeout: 1e4 });
+        const { stdout } = await execAsync21("fly auth whoami", { timeout: 1e4 });
         console.log(`  ${chalk59.dim("  User: " + stdout.trim())}`);
       } catch {
       }
@@ -15879,9 +16087,9 @@ import chalk60 from "chalk";
 
 // src/lib/env-loader.ts
 init_esm_shims();
-import { join as join49 } from "path";
+import { join as join50 } from "path";
 import { homedir as homedir22 } from "os";
-var ENV_FILE_PATH = join49(homedir22(), ".panopticon.env");
+var ENV_FILE_PATH = join50(homedir22(), ".panopticon.env");
 function getShadowModeFromEnv() {
   const value = process.env.SHADOW_MODE;
   if (!value) return false;
@@ -15982,30 +16190,32 @@ import chalk61 from "chalk";
 
 // src/lib/cloister/inspect-agent.ts
 init_esm_shims();
-import { readFileSync as readFileSync46, existsSync as existsSync51 } from "fs";
-import { join as join51, dirname as dirname16 } from "path";
+import { readFileSync as readFileSync47, existsSync as existsSync52 } from "fs";
+import { join as join52, dirname as dirname16 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { exec as exec21 } from "child_process";
-import { promisify as promisify21 } from "util";
+import { exec as exec23 } from "child_process";
+import { promisify as promisify23 } from "util";
 
 // src/lib/cloister/inspect-checkpoints.ts
 init_esm_shims();
-import { existsSync as existsSync50, readFileSync as readFileSync45, writeFileSync as writeFileSync26, mkdirSync as mkdirSync25 } from "fs";
-import { join as join50 } from "path";
+import { existsSync as existsSync51, readFileSync as readFileSync46, writeFileSync as writeFileSync26, mkdirSync as mkdirSync25 } from "fs";
+import { join as join51 } from "path";
 import { homedir as homedir23 } from "os";
-import { execSync as execSync9 } from "child_process";
-var PANOPTICON_HOME2 = join50(homedir23(), ".panopticon");
+import { exec as exec22 } from "child_process";
+import { promisify as promisify22 } from "util";
+var execAsync22 = promisify22(exec22);
+var PANOPTICON_HOME2 = join51(homedir23(), ".panopticon");
 function getCheckpointDir(projectKey) {
-  return join50(PANOPTICON_HOME2, "specialists", projectKey, "inspect-agent", "checkpoints");
+  return join51(PANOPTICON_HOME2, "specialists", projectKey, "inspect-agent", "checkpoints");
 }
 function getCheckpointPath(projectKey, issueId) {
-  return join50(getCheckpointDir(projectKey), `${issueId.toUpperCase()}.json`);
+  return join51(getCheckpointDir(projectKey), `${issueId.toUpperCase()}.json`);
 }
 function loadCheckpoints(projectKey, issueId) {
   const filePath = getCheckpointPath(projectKey, issueId);
-  if (!existsSync50(filePath)) return null;
+  if (!existsSync51(filePath)) return null;
   try {
-    return JSON.parse(readFileSync45(filePath, "utf-8"));
+    return JSON.parse(readFileSync46(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -16015,28 +16225,28 @@ function getLastCheckpoint(projectKey, issueId) {
   if (!data || data.checkpoints.length === 0) return null;
   return data.checkpoints[data.checkpoints.length - 1];
 }
-function getDiffBase(projectKey, issueId, workspacePath) {
+async function getDiffBase(projectKey, issueId, workspacePath) {
   const lastCheckpoint = getLastCheckpoint(projectKey, issueId);
   if (lastCheckpoint) {
     return lastCheckpoint.commitSha;
   }
   try {
-    const mergeBase = execSync9("git merge-base main HEAD", {
+    const { stdout } = await execAsync22("git merge-base main HEAD", {
       cwd: workspacePath,
       encoding: "utf-8"
-    }).trim();
-    return mergeBase;
+    });
+    return stdout.trim();
   } catch {
     return "main";
   }
 }
-function getDiffStats(workspacePath, diffBase) {
+async function getDiffStats(workspacePath, diffBase) {
   try {
-    const stats = execSync9(`git diff --stat ${diffBase}...HEAD`, {
+    const { stdout } = await execAsync22(`git diff --stat ${diffBase}...HEAD`, {
       cwd: workspacePath,
       encoding: "utf-8"
-    }).trim();
-    return stats || "No changes detected";
+    });
+    return stdout.trim() || "No changes detected";
   } catch {
     return "Unable to compute diff stats";
   }
@@ -16045,12 +16255,12 @@ function getDiffStats(workspacePath, diffBase) {
 // src/lib/cloister/inspect-agent.ts
 init_specialists();
 init_review_status();
-var execAsync21 = promisify21(exec21);
+var execAsync23 = promisify23(exec23);
 var __filename6 = fileURLToPath6(import.meta.url);
 var __dirname6 = dirname16(__filename6);
 async function getBeadDescription(beadId, workspacePath) {
   try {
-    const { stdout } = await execAsync21(`bd show ${beadId} --json`, {
+    const { stdout } = await execAsync23(`bd show ${beadId} --json`, {
       cwd: workspacePath,
       encoding: "utf-8"
     });
@@ -16064,7 +16274,7 @@ async function getBeadDescription(beadId, workspacePath) {
     return parts.join("\n\n") || `Bead ${beadId} (no description available)`;
   } catch {
     try {
-      const { stdout } = await execAsync21(`bd show ${beadId}`, {
+      const { stdout } = await execAsync23(`bd show ${beadId}`, {
         cwd: workspacePath,
         encoding: "utf-8"
       });
@@ -16084,8 +16294,8 @@ function detectCompileCommand(workspacePath) {
   ];
   for (const check of checks) {
     for (const subdir of ["", "fe", "api", "frontend", "backend"]) {
-      const checkPath = subdir ? join51(workspacePath, subdir, check.file) : join51(workspacePath, check.file);
-      if (existsSync51(checkPath)) {
+      const checkPath = subdir ? join52(workspacePath, subdir, check.file) : join52(workspacePath, check.file);
+      if (existsSync52(checkPath)) {
         const cwd = subdir ? `cd ${subdir} && ` : "";
         return `${cwd}${check.command}`;
       }
@@ -16094,14 +16304,14 @@ function detectCompileCommand(workspacePath) {
   return 'echo "No compile command detected \u2014 skipping compile check"';
 }
 async function buildInspectPrompt(context) {
-  const templatePath = join51(__dirname6, "prompts", "inspect-agent.md");
-  if (!existsSync51(templatePath)) {
+  const templatePath = join52(__dirname6, "prompts", "inspect-agent.md");
+  if (!existsSync52(templatePath)) {
     throw new Error(`Inspect agent prompt template not found at ${templatePath}`);
   }
-  const template = readFileSync46(templatePath, "utf-8");
+  const template = readFileSync47(templatePath, "utf-8");
   const beadDescription = await getBeadDescription(context.beadId, context.workspace);
-  const diffBase = getDiffBase(context.projectKey, context.issueId, context.workspace);
-  const diffStats = getDiffStats(context.workspace, diffBase);
+  const diffBase = await getDiffBase(context.projectKey, context.issueId, context.workspace);
+  const diffStats = await getDiffStats(context.workspace, diffBase);
   const compileCommand = detectCompileCommand(context.workspace);
   const apiUrl = process.env.DASHBOARD_URL || `http://localhost:${process.env.API_PORT || process.env.PORT || "3011"}`;
   const prompt = template.replace(/\{\{apiUrl\}\}/g, apiUrl).replace(/\{\{projectPath\}\}/g, context.projectPath).replace(/\{\{issueId\}\}/g, context.issueId).replace(/\{\{beadId\}\}/g, context.beadId).replace(/\{\{workspacePath\}\}/g, context.workspace).replace(/\{\{checkpoint\}\}/g, diffBase.substring(0, 8)).replace(/\{\{diffBase\}\}/g, diffBase).replace(/\{\{diffStats\}\}/g, diffStats).replace(/\{\{beadDescription\}\}/g, beadDescription).replace(/\{\{compileCommand\}\}/g, compileCommand).replace(/\{\{resultStatus\}\}/g, "${RESULT_STATUS}").replace(/\{\{resultNotes\}\}/g, "${RESULT_NOTES}");
@@ -16144,10 +16354,10 @@ async function inspectCommand(issueId, options) {
   }
   let workspacePath = options.workspace;
   if (!workspacePath) {
-    const { join: join54 } = await import("path");
-    const { existsSync: existsSync54 } = await import("fs");
-    const candidatePath = join54(project2.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`);
-    if (existsSync54(candidatePath)) {
+    const { join: join55 } = await import("path");
+    const { existsSync: existsSync55 } = await import("fs");
+    const candidatePath = join55(project2.projectPath, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`);
+    if (existsSync55(candidatePath)) {
       workspacePath = candidatePath;
     }
   }
@@ -16156,8 +16366,8 @@ async function inspectCommand(issueId, options) {
     console.error(chalk61.dim("Provide --workspace <path> or ensure a workspace exists for this issue"));
     process.exit(1);
   }
-  const diffBase = getDiffBase(project2.projectKey, normalizedIssueId, workspacePath);
-  const diffStats = getDiffStats(workspacePath, diffBase);
+  const diffBase = await getDiffBase(project2.projectKey, normalizedIssueId, workspacePath);
+  const diffStats = await getDiffStats(workspacePath, diffBase);
   console.log("");
   console.log(chalk61.bold("Requesting inspection"));
   console.log(chalk61.dim(`  Issue:     ${normalizedIssueId}`));
@@ -16202,9 +16412,9 @@ import chalk62 from "chalk";
 // src/lib/costs/sync-wal.ts
 init_esm_shims();
 init_projects();
-import { existsSync as existsSync52 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 
 // src/lib/database/cost-events-db.ts
 init_esm_shims();
@@ -16269,8 +16479,8 @@ async function syncWalFromAllProjects() {
   for (const { key, config: config2 } of projects) {
     const repoPath = config2.events_repo ?? config2.path;
     const eventsSubdir = config2.events_path ?? DEFAULT_EVENTS_SUBDIR;
-    const eventsDir = join52(repoPath, eventsSubdir);
-    if (!existsSync52(eventsDir)) continue;
+    const eventsDir = join53(repoPath, eventsSubdir);
+    if (!existsSync53(eventsDir)) continue;
     const projectStats = { imported: 0, duplicates: 0, files: 0 };
     let files;
     try {
@@ -16280,7 +16490,7 @@ async function syncWalFromAllProjects() {
       continue;
     }
     for (const file of files) {
-      const filePath = join52(eventsDir, file);
+      const filePath = join53(eventsDir, file);
       const events = await parseWalFile(filePath, result.errors);
       if (events.length === 0) continue;
       try {
@@ -16607,10 +16817,10 @@ function createCostCommand() {
 }
 
 // src/cli/index.ts
-var PANOPTICON_ENV_FILE = join53(homedir24(), ".panopticon.env");
-if (existsSync53(PANOPTICON_ENV_FILE)) {
+var PANOPTICON_ENV_FILE = join54(homedir24(), ".panopticon.env");
+if (existsSync54(PANOPTICON_ENV_FILE)) {
   try {
-    const envContent = readFileSync47(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;
@@ -16627,7 +16837,7 @@ if (existsSync53(PANOPTICON_ENV_FILE)) {
   }
 }
 var program = new Command2();
-program.name("pan").description("Multi-agent orchestration for AI coding assistants").version(JSON.parse(readFileSync47(join53(import.meta.dirname, "../../package.json"), "utf-8")).version);
+program.name("pan").description("Multi-agent orchestration for AI coding assistants").version(JSON.parse(readFileSync48(join54(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);
@@ -16651,22 +16861,22 @@ registerInspectCommand(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").option("--tldr", "Show TLDR index health across all workspaces").option("--context", "Show context window usage % for each agent").action(statusCommand);
 program.command("up").description("Start dashboard (and Traefik if enabled)").option("--detach", "Run in background").option("--skip-traefik", "Skip Traefik startup").action(async (options) => {
-  const { spawn: spawn2, execSync: execSync10 } = await import("child_process");
-  const { join: join54, dirname: dirname17 } = await import("path");
+  const { spawn: spawn2, execSync: execSync9 } = await import("child_process");
+  const { join: join55, dirname: dirname17 } = await import("path");
   const { fileURLToPath: fileURLToPath7 } = await import("url");
-  const { readFileSync: readFileSync48, existsSync: existsSync54 } = await import("fs");
+  const { readFileSync: readFileSync49, existsSync: existsSync55 } = await import("fs");
   const { parse } = await import("@iarna/toml");
   const __dirname7 = dirname17(fileURLToPath7(import.meta.url));
-  const bundledServer = join54(__dirname7, "..", "dashboard", "server.js");
-  const srcDashboard = join54(__dirname7, "..", "..", "src", "dashboard");
-  const configFile = join54(process.env.HOME || "", ".panopticon", "config.toml");
+  const bundledServer = join55(__dirname7, "..", "dashboard", "server.js");
+  const srcDashboard = join55(__dirname7, "..", "..", "src", "dashboard");
+  const configFile = join55(process.env.HOME || "", ".panopticon", "config.toml");
   let traefikEnabled = false;
   let traefikDomain = "pan.localhost";
   let dashboardPort = 3010;
   let dashboardApiPort = 3011;
-  if (existsSync54(configFile)) {
+  if (existsSync55(configFile)) {
     try {
-      const configContent = readFileSync48(configFile, "utf-8");
+      const configContent = readFileSync49(configFile, "utf-8");
       const config2 = parse(configContent);
       traefikEnabled = config2.traefik?.enabled === true;
       traefikDomain = config2.traefik?.domain || "pan.localhost";
@@ -16696,7 +16906,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(readFileSync48(configFile, "utf-8")).traefik?.dns_sync_method : null) || detectDnsSyncMethod2();
+      const dnsMethod = (existsSync55(configFile) ? parse(readFileSync49(configFile, "utf-8")).traefik?.dns_sync_method : null) || detectDnsSyncMethod2();
       ensureBaseDomain2(dnsMethod, traefikDomain);
       if (dnsMethod === "wsl2hosts") {
         syncDnsToWindows2().catch(() => {
@@ -16707,7 +16917,7 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
     }
   } else if (!traefikEnabled) {
     try {
-      const containerCheck = execSync10(
+      const containerCheck = execSync9(
         'docker ps --filter "name=panopticon-traefik" --format "{{.Names}}" 2>/dev/null',
         { encoding: "utf-8" }
       ).trim();
@@ -16719,12 +16929,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 = join55(process.env.HOME || "", ".panopticon", "traefik");
+    if (existsSync55(traefikDir)) {
       try {
-        const composeFile = join54(traefikDir, "docker-compose.yml");
-        if (existsSync54(composeFile)) {
-          const content = readFileSync48(composeFile, "utf-8");
+        const composeFile = join55(traefikDir, "docker-compose.yml");
+        if (existsSync55(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/,
@@ -16736,7 +16946,7 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
           }
         }
         console.log(chalk63.dim("Starting Traefik..."));
-        execSync10("docker compose up -d", {
+        execSync9("docker compose up -d", {
           cwd: traefikDir,
           stdio: "pipe"
         });
@@ -16749,8 +16959,8 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
       }
     }
   }
-  const isProduction = existsSync54(bundledServer);
-  const isDevelopment = existsSync54(srcDashboard);
+  const isProduction = existsSync55(bundledServer);
+  const isDevelopment = existsSync55(srcDashboard);
   if (!isProduction && !isDevelopment) {
     console.error(chalk63.red("Error: Dashboard not found"));
     console.error(chalk63.dim("This may be a corrupted installation. Try reinstalling panopticon-cli."));
@@ -16758,7 +16968,7 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
   }
   if (isDevelopment && !isProduction) {
     try {
-      execSync10("npm --version", { stdio: "pipe" });
+      execSync9("npm --version", { stdio: "pipe" });
     } catch {
       console.error(chalk63.red("Error: npm not found in PATH"));
       console.error(chalk63.dim("Make sure Node.js and npm are installed and in your PATH"));
@@ -16825,8 +17035,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 = join55(projectRoot, ".venv");
+    if (existsSync55(venvPath)) {
       console.log(chalk63.dim("\nStarting TLDR daemon for project root..."));
       const tldrService = getTldrDaemonService2(projectRoot, venvPath);
       await tldrService.start(true);
@@ -16841,18 +17051,18 @@ 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: execSync10 } = await import("child_process");
-  const { join: join54 } = await import("path");
-  const { readFileSync: readFileSync48, existsSync: existsSync54 } = await import("fs");
+  const { execSync: execSync9 } = await import("child_process");
+  const { join: join55 } = await import("path");
+  const { readFileSync: readFileSync49, existsSync: existsSync55 } = await import("fs");
   const { parse } = await import("@iarna/toml");
   console.log(chalk63.bold("Stopping Panopticon...\n"));
-  const configFile = join54(process.env.HOME || "", ".panopticon", "config.toml");
+  const configFile = join55(process.env.HOME || "", ".panopticon", "config.toml");
   let traefikEnabled = false;
   let dashboardPort = 3010;
   let dashboardApiPort = 3011;
-  if (existsSync54(configFile)) {
+  if (existsSync55(configFile)) {
     try {
-      const configContent = readFileSync48(configFile, "utf-8");
+      const configContent = readFileSync49(configFile, "utf-8");
       const config2 = parse(configContent);
       traefikEnabled = config2.traefik?.enabled === true;
       dashboardPort = config2.dashboard?.port || 3010;
@@ -16862,18 +17072,18 @@ program.command("down").description("Stop dashboard (and Traefik if enabled)").o
   }
   console.log(chalk63.dim("Stopping dashboard..."));
   try {
-    execSync10(`lsof -ti:${dashboardPort} | xargs kill -9 2>/dev/null || true`, { stdio: "pipe" });
-    execSync10(`lsof -ti:${dashboardApiPort} | xargs kill -9 2>/dev/null || true`, { stdio: "pipe" });
+    execSync9(`lsof -ti:${dashboardPort} | xargs kill -9 2>/dev/null || true`, { stdio: "pipe" });
+    execSync9(`lsof -ti:${dashboardApiPort} | xargs kill -9 2>/dev/null || true`, { stdio: "pipe" });
     console.log(chalk63.green("\u2713 Dashboard stopped"));
   } catch {
     console.log(chalk63.dim("  No dashboard processes found"));
   }
   if (traefikEnabled && !options.skipTraefik) {
-    const traefikDir = join54(process.env.HOME || "", ".panopticon", "traefik");
-    if (existsSync54(traefikDir)) {
+    const traefikDir = join55(process.env.HOME || "", ".panopticon", "traefik");
+    if (existsSync55(traefikDir)) {
       console.log(chalk63.dim("Stopping Traefik..."));
       try {
-        execSync10("docker compose down", {
+        execSync9("docker compose down", {
           cwd: traefikDir,
           stdio: "pipe"
         });
@@ -16885,12 +17095,12 @@ program.command("down").description("Stop dashboard (and Traefik if enabled)").o
   }
   try {
     const { getTldrDaemonService: getTldrDaemonService2 } = await import("../tldr-daemon-T3THOUGT.js");
-    const { exec: exec22 } = await import("child_process");
-    const { promisify: promisify22 } = await import("util");
-    const execAsync22 = promisify22(exec22);
+    const { exec: exec24 } = await import("child_process");
+    const { promisify: promisify24 } = await import("util");
+    const execAsync24 = promisify24(exec24);
     const projectRoot = process.cwd();
-    const venvPath = join54(projectRoot, ".venv");
-    if (existsSync54(venvPath)) {
+    const venvPath = join55(projectRoot, ".venv");
+    if (existsSync55(venvPath)) {
       console.log(chalk63.dim("\nStopping TLDR daemon..."));
       const tldrService = getTldrDaemonService2(projectRoot, venvPath);
       await tldrService.stop();