panopticon-cli 0.5.0 → 0.5.1

package/dist/cli/index.js

@@ -1,18 +1,43 @@
 #!/usr/bin/env node
+import {
+  checkSpecialistQueue,
+  clearSessionId,
+  completeSpecialistTask,
+  getAllSpecialistStatus,
+  getEnabledSpecialists,
+  getNextSpecialistTask,
+  getProjectDirs,
+  getSessionFiles,
+  getSessionId,
+  getSpecialistMetadata,
+  getSpecialistStatus,
+  getTmuxSessionName,
+  init_jsonl_parser,
+  init_specialists,
+  initializeEnabledSpecialists,
+  isRunning,
+  parseClaudeSession,
+  recordWake,
+  setSessionId,
+  wakeSpecialist,
+  wakeSpecialistOrQueue,
+  wakeSpecialistWithTask
+} from "../chunk-OWHXCGVO.js";
 import {
   cleanupTemplateFiles,
   ensureProjectCerts,
   generatePanopticonTraefikConfig,
   generateTlsConfig
-} from "../chunk-PPRFKTVC.js";
+} from "../chunk-NLQRED36.js";
 import {
   applyProjectTemplateOverlay,
   createWorkspace,
   init_skills_merge,
   init_workspace_manager,
   mergeSkillsIntoWorkspace,
-  removeWorkspace
-} from "../chunk-GR6ZZMCX.js";
+  removeWorkspace,
+  stopWorkspaceDocker
+} from "../chunk-F5555J3A.js";
 import "../chunk-7SN4L4PH.js";
 import {
   init_remote_agents,
@@ -41,7 +66,24 @@ import {
   saveSessionId,
   spawnAgent,
   stopAgent
-} from "../chunk-HZT2AOPN.js";
+} from "../chunk-VHKSS7QX.js";
+import {
+  checkHook,
+  clearHook,
+  createSession,
+  generateFixedPointPrompt,
+  getModelId,
+  init_hooks,
+  init_tmux,
+  init_work_type_router,
+  killSession,
+  popFromHook,
+  pushToHook,
+  sendKeys,
+  sendKeysAsync,
+  sendMail,
+  sessionExists
+} from "../chunk-FTCPTHIJ.js";
 import {
   createShadowState,
   getPendingSyncCount,
@@ -69,48 +111,7 @@ import {
   init_review_status,
   loadReviewStatuses,
   saveReviewStatuses
-} from "../chunk-GFP3PIPB.js";
-import {
-  checkSpecialistQueue,
-  clearSessionId,
-  completeSpecialistTask,
-  getAllSpecialistStatus,
-  getEnabledSpecialists,
-  getNextSpecialistTask,
-  getProjectDirs,
-  getSessionFiles,
-  getSessionId,
-  getSpecialistMetadata,
-  getSpecialistStatus,
-  getTmuxSessionName,
-  init_jsonl_parser,
-  init_specialists,
-  initializeEnabledSpecialists,
-  isRunning,
-  parseClaudeSession,
-  recordWake,
-  setSessionId,
-  wakeSpecialist,
-  wakeSpecialistOrQueue,
-  wakeSpecialistWithTask
-} from "../chunk-AAFQANKW.js";
-import {
-  checkHook,
-  clearHook,
-  createSession,
-  generateFixedPointPrompt,
-  getModelId,
-  init_hooks,
-  init_tmux,
-  init_work_type_router,
-  killSession,
-  popFromHook,
-  pushToHook,
-  sendKeys,
-  sendKeysAsync,
-  sendMail,
-  sessionExists
-} from "../chunk-FTCPTHIJ.js";
+} from "../chunk-YGJ54GW2.js";
 import "../chunk-JQBV3Q2W.js";
 import {
   addAlias,
@@ -128,13 +129,13 @@ import {
   restoreBackup,
   syncHooks,
   syncStatusline
-} from "../chunk-WQG2TYCB.js";
+} from "../chunk-4YSYJ4HM.js";
 import "../chunk-AQXETQHW.js";
 import {
   createTracker,
   createTrackerFromConfig,
   init_factory
-} from "../chunk-NTO3EDB3.js";
+} from "../chunk-76F6DSVS.js";
 import {
   init_config_yaml,
   init_settings,
@@ -162,7 +163,7 @@ import {
   registerProject,
   resolveProjectFromIssue,
   unregisterProject
-} from "../chunk-OMNXYPXC.js";
+} from "../chunk-2V4NF7J2.js";
 import {
   NotImplementedError,
   init_interface
@@ -1556,7 +1557,7 @@ async function handleRemoteWorkspace(issueId, options, spinner) {
   if (!remoteMetadata) {
     spinner.text = "Remote workspace not found, creating...";
     try {
-      const { createRemoteWorkspace: createRemoteWorkspace2 } = await import("../remote-workspace-AHVHQEES.js");
+      const { createRemoteWorkspace: createRemoteWorkspace2 } = await import("../remote-workspace-7FPGF2RM.js");
       remoteMetadata = await createRemoteWorkspace2(issueId, { spinner });
     } catch (error) {
       spinner.fail(`Failed to create remote workspace: ${error.message}`);
@@ -2289,9 +2290,9 @@ 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 { homedir as homedir5 } from "os";
+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 homedir6 } from "os";
 import { exec } from "child_process";
 import { promisify } from "util";
 
@@ -2424,12 +2425,46 @@ function cleanupWorkflowLabels(currentLabels, targetState) {
   return cleaned;
 }
 
+// src/lib/tracker-utils.ts
+init_esm_shims();
+import { readFileSync as readFileSync10, existsSync as existsSync12 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir5 } from "os";
+function parseGitHubRepos() {
+  const envFile = join12(homedir5(), ".panopticon.env");
+  if (!existsSync12(envFile)) return [];
+  const content = readFileSync10(envFile, "utf-8");
+  const reposMatch = content.match(/GITHUB_REPOS=(.+)/);
+  if (!reposMatch) return [];
+  return reposMatch[1].trim().split(",").map((r) => {
+    const [repoPath, prefix] = r.trim().split(":");
+    const [owner, repo] = (repoPath || "").split("/");
+    return { owner: owner || "", repo: repo || "", prefix: (prefix || "").toUpperCase() };
+  }).filter((r) => r.owner && r.repo && r.prefix);
+}
+function extractIssuePrefix(issueId) {
+  return issueId.split("-")[0].toUpperCase();
+}
+function resolveGitHubIssue(issueId) {
+  const prefix = extractIssuePrefix(issueId);
+  const repos = parseGitHubRepos();
+  for (const repoConfig of repos) {
+    if (repoConfig.prefix === prefix) {
+      const number = parseInt(issueId.split("-")[1], 10);
+      if (!isNaN(number)) {
+        return { isGitHub: true, ...repoConfig, number };
+      }
+    }
+  }
+  return { isGitHub: false };
+}
+
 // src/cli/commands/work/done.ts
 var execAsync = promisify(exec);
 function getLinearApiKey3() {
-  const envFile = join12(homedir5(), ".panopticon.env");
-  if (existsSync12(envFile)) {
-    const content = readFileSync10(envFile, "utf-8");
+  const envFile = join13(homedir6(), ".panopticon.env");
+  if (existsSync13(envFile)) {
+    const content = readFileSync11(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -2471,9 +2506,9 @@ ${comment}`
   }
 }
 function getGitHubConfig() {
-  const envFile = join12(homedir5(), ".panopticon.env");
-  if (!existsSync12(envFile)) return null;
-  const content = readFileSync10(envFile, "utf-8");
+  const envFile = join13(homedir6(), ".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();
@@ -2491,9 +2526,9 @@ async function updateGitHubToInReview(issueId, comment) {
   try {
     const ghConfig = getGitHubConfig();
     if (!ghConfig) return false;
-    const number = parseInt(issueId.split("-")[1], 10);
-    const repoConfig = ghConfig.repos.find((r) => r.prefix === "PAN") || ghConfig.repos[0];
-    const { owner, repo } = repoConfig;
+    const resolved = resolveGitHubIssue(issueId);
+    if (!resolved.isGitHub) return false;
+    const { owner, repo, number } = resolved;
     const token = ghConfig.token;
     const headers = {
       "Authorization": `token ${token}`,
@@ -2529,10 +2564,59 @@ 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-E43Y3HNU.js");
+    const { getAgentState: getAgentState2 } = await import("../agents-5OPQKM5K.js");
     const agentState = getAgentState2(agentId);
     const workspacePath = agentState?.workspace;
-    if (workspacePath && existsSync12(workspacePath)) {
+    if (workspacePath && existsSync13(workspacePath)) {
+      try {
+        const { getReviewStatus: getReviewStatus2 } = await import("../review-status-TDPSOU5J.js");
+        const { getWorkspaceCommitHashes } = await import("../git-utils-I2UDKNZH.js");
+        const { getDashboardApiUrl: getDashboardApiUrl2 } = await import("../config-4CJNUE3O.js");
+        const reviewStatus = getReviewStatus2(issueId);
+        if (reviewStatus) {
+          const isBlockedOrFailed = ["blocked", "failed"].includes(reviewStatus.reviewStatus);
+          if (isBlockedOrFailed) {
+            const dashboardUrl = getDashboardApiUrl2();
+            console.error(chalk12.red(`
+\u2716 Cannot mark work done \u2014 review is ${reviewStatus.reviewStatus} for ${issueId}
+`));
+            console.error("  The review agent found issues that must be addressed before this issue can be completed.");
+            console.error("  Fix the issues, commit your changes, then re-submit for review:\n");
+            console.error(chalk12.cyan(`  curl -X POST ${dashboardUrl}/api/workspaces/${issueId}/request-review \\`));
+            console.error(chalk12.cyan(`    -H "Content-Type: application/json" -d '{}'`));
+            console.error("");
+            console.error(chalk12.dim("  Use --force to skip this check."));
+            console.error("");
+            process.exit(1);
+          }
+          if (reviewStatus.lastReviewCommits) {
+            const currentHashes = await getWorkspaceCommitHashes(workspacePath);
+            const allKeys = /* @__PURE__ */ new Set([
+              ...Object.keys(currentHashes),
+              ...Object.keys(reviewStatus.lastReviewCommits)
+            ]);
+            const commitsChanged = [...allKeys].some(
+              (k) => currentHashes[k] !== reviewStatus.lastReviewCommits[k]
+            );
+            if (commitsChanged) {
+              const dashboardUrl = getDashboardApiUrl2();
+              console.error(chalk12.red(`
+\u2716 Cannot mark work done \u2014 commits changed since last review for ${issueId}
+`));
+              console.error("  New commits were added after the last review/test run. The specialists");
+              console.error("  must review and test your latest code before work can be marked done.");
+              console.error("  Re-submit for review:\n");
+              console.error(chalk12.cyan(`  curl -X POST ${dashboardUrl}/api/workspaces/${issueId}/request-review \\`));
+              console.error(chalk12.cyan(`    -H "Content-Type: application/json" -d '{}'`));
+              console.error("");
+              console.error(chalk12.dim("  Use --force to skip this check."));
+              console.error("");
+              process.exit(1);
+            }
+          }
+        }
+      } catch {
+      }
       const failures = [];
       try {
         const { stdout } = await execAsync("bd list --status open --limit 0 --json", { cwd: workspacePath });
@@ -2547,7 +2631,7 @@ 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 });
@@ -2564,8 +2648,8 @@ 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 });
               if (stdout.trim()) {
@@ -2599,14 +2683,14 @@ async function doneCommand(id, options = {}) {
   try {
     let trackerUpdated = false;
     let shadowModeActive = false;
-    const isGitHubIssue = issueId.startsWith("PAN-");
+    const ghResolution = resolveGitHubIssue(issueId);
     const skipTrackerUpdate = shouldSkipTrackerUpdate(issueId, options.shadow);
     if (skipTrackerUpdate) {
       shadowModeActive = true;
       spinner.text = "Updating shadow state...";
       updateShadowState(issueId, "closed", "pan work done");
       console.log(chalk12.cyan(`  \u{1F47B} Shadow mode: status updated locally`));
-    } else if (isGitHubIssue) {
+    } else if (ghResolution.isGitHub) {
       spinner.text = "Updating GitHub labels...";
       trackerUpdated = await updateGitHubToInReview(issueId, options.comment);
       if (trackerUpdated) {
@@ -2628,7 +2712,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-E43Y3HNU.js");
+    const { getAgentState: getAgentState2, saveAgentState: saveAgentState2 } = await import("../agents-5OPQKM5K.js");
     const existingState = getAgentState2(agentId);
     if (existingState) {
       existingState.status = "stopped";
@@ -2639,8 +2723,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,
@@ -2767,14 +2851,14 @@ 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 { homedir as homedir6 } from "os";
+import { readFileSync as readFileSync13, existsSync as existsSync15 } from "fs";
+import { join as join15, dirname as dirname5 } from "path";
+import { homedir as homedir7 } 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 { existsSync as existsSync14, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join14 } from "path";
 import { exec as exec2, spawn } from "child_process";
 import { promisify as promisify2 } from "util";
 init_paths();
@@ -2786,17 +2870,17 @@ 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(
         `find "${fullPath}" -type f -name "*.md" 2>/dev/null | xargs grep -l -i "${issueIdLower}" 2>/dev/null || true`,
@@ -3039,25 +3123,25 @@ async function createBeadsTasks(issue, tasks, cwd) {
   return { success: errors.length === 0, created, errors };
 }
 function writePlanFiles(projectPath, stateContent, workspaceContent) {
-  const planningDir = join13(projectPath, ".planning");
+  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");
+  const workspacePath = join14(planningDir, "WORKSPACE.md");
   writeFileSync5(statePath, stateContent);
   writeFileSync5(workspacePath, workspaceContent);
   return { statePath, workspacePath };
 }
 async function copyToPRDDirectory(projectPath, issue, content, options) {
-  const prdDir = join13(projectPath, PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR);
+  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);
+        const relativePrdPath = join14(PROJECT_DOCS_SUBDIR, PROJECT_PRDS_SUBDIR, PROJECT_PRDS_ACTIVE_SUBDIR, filename);
         await execAsync2(`git add ${relativePrdPath}`, { cwd: projectPath, encoding: "utf-8" });
         try {
           await execAsync2("git diff --cached --quiet", { cwd: projectPath, encoding: "utf-8" });
@@ -3104,9 +3188,9 @@ async function executePlan(issue, tasks, decisions, projectPath, options) {
 
 // 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(homedir7(), ".panopticon.env");
+  if (existsSync15(envFile)) {
+    const content = readFileSync13(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -3589,9 +3673,9 @@ 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 { homedir as homedir7 } from "os";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync6, existsSync as existsSync16, mkdirSync as mkdirSync6 } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir8 } from "os";
 function getTrackerConfig2(trackerType) {
   const config2 = loadConfig();
   const trackerConfig = config2.trackers[trackerType];
@@ -3609,13 +3693,13 @@ function getTrackerConfig2(trackerType) {
   };
 }
 function getTriageStatePath() {
-  return join15(homedir7(), ".panopticon", "triage-state.json");
+  return join16(homedir8(), ".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: {} };
     }
@@ -3623,8 +3707,8 @@ function loadTriageState() {
   return { dismissed: [], created: {} };
 }
 function saveTriageState(state) {
-  const dir = join15(homedir7(), ".panopticon");
-  if (!existsSync15(dir)) {
+  const dir = join16(homedir8(), ".panopticon");
+  if (!existsSync16(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
   const path = getTriageStatePath();
@@ -4009,23 +4093,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);
@@ -4102,14 +4186,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);
@@ -4150,14 +4234,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}
@@ -4166,13 +4250,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)) {
@@ -4184,13 +4268,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;
@@ -4203,28 +4287,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) {
@@ -4340,7 +4424,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);
@@ -4368,8 +4452,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())}`);
@@ -4397,8 +4481,8 @@ 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 { existsSync as existsSync19, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "fs";
+import { join as join18 } from "path";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync3 = promisify3(exec3);
@@ -4407,7 +4491,7 @@ 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);
@@ -4419,9 +4503,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 {
     }
@@ -4429,7 +4513,7 @@ 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));
 }
@@ -4552,7 +4636,7 @@ async function runHealthCheck(config2 = {
     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) {
@@ -4790,15 +4874,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 { homedir as homedir8 } from "os";
+import { existsSync as existsSync21, readFileSync as readFileSync19 } from "fs";
+import { join as join20, dirname as dirname6 } from "path";
+import { homedir as homedir9 } 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();
@@ -4864,9 +4948,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);
@@ -4902,9 +4986,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(homedir9(), ".panopticon.env");
+  if (existsSync21(envFile)) {
+    const content = readFileSync19(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -4977,15 +5061,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;
@@ -5112,7 +5196,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-E43Y3HNU.js");
+      const { getAgentState: getAgentState2 } = await import("../agents-5OPQKM5K.js");
       const agentId = `agent-${id.toLowerCase()}`;
       const agentState = getAgentState2(agentId);
       const agentRunning = agentState?.status === "active" || agentState?.status === "running";
@@ -5228,11 +5312,12 @@ init_esm_shims();
 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 { homedir as homedir10 } from "os";
+import { join as join21 } from "path";
+import { existsSync as existsSync22, rmSync, readFileSync as readFileSync20 } from "fs";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
+init_workspace_manager();
 var execAsync4 = promisify4(exec4);
 async function wipeCommand(issueId, options) {
   const issueLower = issueId.toLowerCase();
@@ -5319,22 +5404,22 @@ async function wipeCommand(issueId, options) {
     }
   }
   const agentDirs = [
-    join20(homedir9(), ".panopticon", "agents", `agent-${issueLower}`)
+    join21(homedir10(), ".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(), "~")}`));
+      console.log(chalk24.green(`  \u2713 Deleted agent state: ${dir.replace(homedir10(), "~")}`));
     }
   }
   let projectPath;
   const prefix = issueId.split("-")[0].toUpperCase();
-  const projectsYamlPath = join20(homedir9(), ".panopticon", "projects.yaml");
-  if (existsSync21(projectsYamlPath)) {
+  const projectsYamlPath = join21(homedir10(), ".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) {
@@ -5345,20 +5430,37 @@ async function wipeCommand(issueId, options) {
     } catch (e) {
     }
   }
+  if (projectPath) {
+    const workspacePath = join21(projectPath, "workspaces", `feature-${issueLower}`);
+    if (existsSync22(workspacePath)) {
+      try {
+        const projName = projectPath.split("/").pop() || "";
+        const dockerResult = await stopWorkspaceDocker(workspacePath, projName, issueLower);
+        if (dockerResult.steps.length > 0) {
+          for (const step of dockerResult.steps) {
+            cleanupLog.push(step);
+            console.log(chalk24.green(`  \u2713 ${step}`));
+          }
+        }
+      } catch (e) {
+        console.log(chalk24.yellow(`  \u26A0 Docker cleanup: ${e.message}`));
+      }
+    }
+  }
   if (options.workspace && projectPath) {
-    const workspacePath = 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"))) {
+          const gitPath = join21(projectPath, gitDir);
+          if (existsSync22(join21(gitPath, ".git"))) {
             await execAsync4(`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}`);
@@ -5416,14 +5518,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 { homedir as homedir10 } from "os";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
+import { join as join22 } from "path";
+import { homedir as homedir11 } 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(homedir11(), ".panopticon.env");
+  if (existsSync23(envFile)) {
+    const content = readFileSync21(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -5522,10 +5624,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 { homedir as homedir11 } from "os";
-var SYNC_QUEUE_FILE = join22(homedir11(), ".panopticon", "sync-queue.json");
+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 homedir12 } from "os";
+var SYNC_QUEUE_FILE = join23(homedir12(), ".panopticon", "sync-queue.json");
 async function syncToLinear(apiKey, issueId, targetState) {
   try {
     const { LinearClient: LinearClient2 } = await import("@linear/sdk");
@@ -5697,11 +5799,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"));
@@ -5710,7 +5812,7 @@ function loadSyncQueue() {
 }
 function saveSyncQueue(queue) {
   const dir = dirname7(SYNC_QUEUE_FILE);
-  if (!existsSync23(dir)) {
+  if (!existsSync24(dir)) {
     mkdirSync9(dir, { recursive: true });
   }
   try {
@@ -5837,8 +5939,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":
@@ -5861,19 +5963,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));
@@ -5886,9 +5988,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) {
@@ -5910,23 +6012,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));
@@ -5939,9 +6041,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) {
@@ -5991,13 +6093,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);
@@ -6008,8 +6110,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);
@@ -6024,13 +6126,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);
     }
@@ -6040,8 +6142,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);
     }
@@ -6055,13 +6157,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);
     }
@@ -6075,8 +6177,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);
@@ -6159,18 +6261,15 @@ async function syncMainCommand(id) {
 // src/cli/commands/work/close-out.ts
 init_esm_shims();
 import chalk31 from "chalk";
-import { existsSync as existsSync29, readFileSync as readFileSync25 } from "fs";
-import { join as join28 } from "path";
-import { homedir as homedir13 } from "os";
 
 // src/lib/lifecycle/index.ts
 init_esm_shims();
 
 // src/lib/lifecycle/types.ts
 init_esm_shims();
-import { existsSync as existsSync25, readFileSync as readFileSync23 } from "fs";
-import { join as join24 } from "path";
-import { homedir as homedir12 } from "os";
+import { existsSync as existsSync26, readFileSync as readFileSync24 } from "fs";
+import { join as join25 } from "path";
+import { homedir as homedir13 } from "os";
 function stepOk(step, details) {
   return { step, success: true, skipped: false, details };
 }
@@ -6182,9 +6281,9 @@ function stepFailed(step, error, details) {
 }
 function getLinearApiKey7() {
   if (process.env.LINEAR_API_KEY) return process.env.LINEAR_API_KEY;
-  const envFile = join24(homedir12(), ".panopticon.env");
-  if (existsSync25(envFile)) {
-    const content = readFileSync23(envFile, "utf-8");
+  const envFile = join25(homedir13(), ".panopticon.env");
+  if (existsSync26(envFile)) {
+    const content = readFileSync24(envFile, "utf-8");
     const match = content.match(/LINEAR_API_KEY=(.+)/);
     if (match) return match[1].trim();
   }
@@ -6194,20 +6293,20 @@ function getLinearApiKey7() {
 // src/lib/lifecycle/archive-planning.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync26, mkdirSync as mkdirSync10, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
-import { join as join25, dirname as dirname8 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync10, cpSync as cpSync2, rmSync as rmSync2 } from "fs";
+import { join as join26, dirname as dirname8 } from "path";
 import { exec as exec5 } from "child_process";
 import { promisify as promisify5 } from "util";
 var execAsync5 = promisify5(exec5);
 function findWorkspacePath(projectPath, issueLower) {
   const candidates = [
-    join25(projectPath, "workspaces", `feature-${issueLower}`),
-    join25(projectPath, "workspaces", issueLower),
-    join25(projectPath, ".worktrees", issueLower),
-    join25(dirname8(projectPath), `feature-${issueLower}`)
+    join26(projectPath, "workspaces", `feature-${issueLower}`),
+    join26(projectPath, "workspaces", issueLower),
+    join26(projectPath, ".worktrees", issueLower),
+    join26(dirname8(projectPath), `feature-${issueLower}`)
   ];
   for (const p of candidates) {
-    if (existsSync26(p)) return p;
+    if (existsSync27(p)) return p;
   }
   return null;
 }
@@ -6215,28 +6314,28 @@ async function movePrd(ctx, opts = {}) {
   const { pushToRemote = true } = opts;
   const issueLower = ctx.issueId.toLowerCase();
   const step = "archive-planning:move-prd";
-  const completedPrdPath = join25(
+  const completedPrdPath = join26(
     ctx.projectPath,
     PROJECT_DOCS_SUBDIR,
     PROJECT_PRDS_SUBDIR,
     PROJECT_PRDS_COMPLETED_SUBDIR,
     `${issueLower}-plan.md`
   );
-  const activePrdPath = join25(
+  const activePrdPath = join26(
     ctx.projectPath,
     PROJECT_DOCS_SUBDIR,
     PROJECT_PRDS_SUBDIR,
     PROJECT_PRDS_ACTIVE_SUBDIR,
     `${issueLower}-plan.md`
   );
-  if (existsSync26(completedPrdPath)) {
+  if (existsSync27(completedPrdPath)) {
     return stepSkipped(step, ["PRD already in completed/"]);
   }
-  if (!existsSync26(activePrdPath)) {
+  if (!existsSync27(activePrdPath)) {
     return stepSkipped(step, ["No PRD found in active/ (may not have had one)"]);
   }
   const completedDir = dirname8(completedPrdPath);
-  if (!existsSync26(completedDir)) {
+  if (!existsSync27(completedDir)) {
     mkdirSync10(completedDir, { recursive: true });
   }
   try {
@@ -6250,7 +6349,7 @@ async function movePrd(ctx, opts = {}) {
   }
   try {
     cpSync2(activePrdPath, completedPrdPath);
-    if (!existsSync26(completedPrdPath)) {
+    if (!existsSync27(completedPrdPath)) {
       return stepFailed(step, "PRD copy appeared to succeed but file not found at destination");
     }
     return stepOk(step, ["Copied PRD to completed/ (git mv failed, plain copy succeeded)"]);
@@ -6262,14 +6361,14 @@ async function archiveWorkspaceArtifacts(ctx) {
   const issueLower = ctx.issueId.toLowerCase();
   const step = "archive-planning:archive-artifacts";
   const workspacePath = findWorkspacePath(ctx.projectPath, issueLower);
-  if (!workspacePath || !existsSync26(workspacePath)) {
+  if (!workspacePath || !existsSync27(workspacePath)) {
     return stepSkipped(step, ["No workspace found to archive"]);
   }
   try {
-    let archiveDir = join25(ARCHIVES_DIR, issueLower);
-    if (existsSync26(archiveDir)) {
+    let archiveDir = join26(ARCHIVES_DIR, issueLower);
+    if (existsSync27(archiveDir)) {
       let version = 1;
-      while (existsSync26(`${archiveDir}.${version}`)) {
+      while (existsSync27(`${archiveDir}.${version}`)) {
         version++;
       }
       const rotatedDir = `${archiveDir}.${version}`;
@@ -6278,24 +6377,24 @@ async function archiveWorkspaceArtifacts(ctx) {
     }
     mkdirSync10(archiveDir, { recursive: true });
     const details = [];
-    const feedbackDir = join25(workspacePath, ".planning", "feedback");
-    if (existsSync26(feedbackDir)) {
-      cpSync2(feedbackDir, join25(archiveDir, "feedback"), { recursive: true });
+    const feedbackDir = join26(workspacePath, ".planning", "feedback");
+    if (existsSync27(feedbackDir)) {
+      cpSync2(feedbackDir, join26(archiveDir, "feedback"), { recursive: true });
       details.push("Archived feedback/");
     }
-    const stateMd = join25(workspacePath, ".planning", "STATE.md");
-    if (existsSync26(stateMd)) {
-      cpSync2(stateMd, join25(archiveDir, "STATE.md"));
+    const stateMd = join26(workspacePath, ".planning", "STATE.md");
+    if (existsSync27(stateMd)) {
+      cpSync2(stateMd, join26(archiveDir, "STATE.md"));
       details.push("Archived STATE.md");
     }
-    const beadsDir = join25(workspacePath, ".planning", "beads");
-    if (existsSync26(beadsDir)) {
-      cpSync2(beadsDir, join25(archiveDir, "beads"), { recursive: true });
+    const beadsDir = join26(workspacePath, ".planning", "beads");
+    if (existsSync27(beadsDir)) {
+      cpSync2(beadsDir, join26(archiveDir, "beads"), { recursive: true });
       details.push("Archived beads/");
     }
-    const prdMd = join25(workspacePath, ".planning", "PRD.md");
-    if (existsSync26(prdMd)) {
-      cpSync2(prdMd, join25(archiveDir, "PRD.md"));
+    const prdMd = join26(workspacePath, ".planning", "PRD.md");
+    if (existsSync27(prdMd)) {
+      cpSync2(prdMd, join26(archiveDir, "PRD.md"));
       details.push("Archived workspace PRD.md");
     }
     details.push(`Archived to ${archiveDir}`);
@@ -6560,8 +6659,8 @@ async function applyLabelLinear(ctx, apiKey) {
 init_esm_shims();
 init_paths();
 init_tmux();
-import { existsSync as existsSync27, rmSync as rmSync3, unlinkSync as unlinkSync2 } from "fs";
-import { join as join26, basename as basename5 } from "path";
+import { existsSync as existsSync28, rmSync as rmSync3, unlinkSync as unlinkSync2 } from "fs";
+import { join as join27, basename as basename5 } from "path";
 import { exec as exec7 } from "child_process";
 import { promisify as promisify7 } from "util";
 var execAsync7 = promisify7(exec7);
@@ -6591,8 +6690,8 @@ async function killTmuxSessions(issueLower) {
 }
 async function stopTldrDaemon(workspacePath) {
   const step = "teardown:tldr-daemon";
-  const venvPath = join26(workspacePath, ".venv");
-  if (!existsSync27(venvPath)) {
+  const venvPath = join27(workspacePath, ".venv");
+  if (!existsSync28(venvPath)) {
     return stepSkipped(step, ["No .venv found"]);
   }
   try {
@@ -6607,8 +6706,8 @@ async function stopTldrDaemon(workspacePath) {
 async function stopDocker(workspacePath, projectName, issueLower) {
   const step = "teardown:docker";
   try {
-    const { stopWorkspaceDocker } = await import("../workspace-manager-IE4JL2JP.js");
-    await stopWorkspaceDocker(workspacePath, projectName, issueLower);
+    const { stopWorkspaceDocker: stopWorkspaceDocker2 } = await import("../workspace-manager-E434Z45T.js");
+    await stopWorkspaceDocker2(workspacePath, projectName, issueLower);
     return stepOk(step, ["Stopped Docker containers"]);
   } catch {
     return stepSkipped(step, ["Docker cleanup skipped (not running or failed)"]);
@@ -6616,7 +6715,7 @@ async function stopDocker(workspacePath, projectName, issueLower) {
 }
 async function removeWorktree(projectPath, workspacePath) {
   const step = "teardown:worktree";
-  if (!existsSync27(workspacePath)) {
+  if (!existsSync28(workspacePath)) {
     return stepSkipped(step, ["Workspace directory does not exist"]);
   }
   try {
@@ -6634,12 +6733,12 @@ async function removeWorktree(projectPath, workspacePath) {
 async function removeAgentState(issueLower) {
   const step = "teardown:agent-state";
   const dirs = [
-    join26(AGENTS_DIR, `agent-${issueLower}`),
-    join26(AGENTS_DIR, `planning-${issueLower}`)
+    join27(AGENTS_DIR, `agent-${issueLower}`),
+    join27(AGENTS_DIR, `planning-${issueLower}`)
   ];
   let removed = 0;
   for (const dir of dirs) {
-    if (existsSync27(dir)) {
+    if (existsSync28(dir)) {
       rmSync3(dir, { recursive: true, force: true });
       removed++;
     }
@@ -6682,8 +6781,8 @@ async function clearShadowState(issueId) {
 }
 async function clearLegacyPlanningDir(projectPath, issueLower) {
   const step = "teardown:legacy-planning-dir";
-  const legacyDir = join26(projectPath, ".planning", issueLower);
-  if (existsSync27(legacyDir)) {
+  const legacyDir = join27(projectPath, ".planning", issueLower);
+  if (existsSync28(legacyDir)) {
     rmSync3(legacyDir, { recursive: true, force: true });
     return stepOk(step, [`Deleted legacy planning dir: ${legacyDir}`]);
   }
@@ -6691,8 +6790,8 @@ async function clearLegacyPlanningDir(projectPath, issueLower) {
 }
 async function clearPlanningMarker(workspacePath) {
   const step = "teardown:planning-marker";
-  const markerPath = join26(workspacePath, ".planning", ".planning-complete");
-  if (existsSync27(markerPath)) {
+  const markerPath = join27(workspacePath, ".planning", ".planning-complete");
+  if (existsSync28(markerPath)) {
     unlinkSync2(markerPath);
     return stepOk(step, ["Cleared .planning-complete marker"]);
   }
@@ -6743,7 +6842,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 && existsSync27(workspacePath)) {
+  if (workspacePath && existsSync28(workspacePath)) {
     if (shouldDeleteWorkspace) {
       results.push(await stopTldrDaemon(workspacePath));
     }
@@ -6782,8 +6881,8 @@ var execAsync8 = promisify8(exec8);
 // src/lib/lifecycle/workflows.ts
 init_esm_shims();
 init_paths();
-import { existsSync as existsSync28, readFileSync as readFileSync24 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync25 } from "fs";
+import { join as join28 } from "path";
 import { exec as exec9 } from "child_process";
 import { promisify as promisify9 } from "util";
 var execAsync9 = promisify9(exec9);
@@ -6829,7 +6928,7 @@ async function verifyBranchMerged(ctx) {
   const branchName = `feature/${issueLower}`;
   try {
     try {
-      const { loadReviewStatuses: loadReviewStatuses3 } = await import("../review-status-EPFG4XM7.js");
+      const { loadReviewStatuses: loadReviewStatuses3 } = await import("../review-status-TDPSOU5J.js");
       const statuses = loadReviewStatuses3();
       const issueKey = ctx.issueId.toUpperCase();
       if (statuses[issueKey]?.mergeStatus === "merged") {
@@ -6887,14 +6986,14 @@ async function verifyBranchMerged(ctx) {
 async function clearReviewStatusStep(issueId) {
   const step = "clear-review-status";
   try {
-    const { clearReviewStatus: clearReviewStatus2 } = await import("../review-status-EPFG4XM7.js");
+    const { clearReviewStatus: clearReviewStatus2 } = await import("../review-status-TDPSOU5J.js");
     clearReviewStatus2(issueId.toUpperCase());
     return stepOk(step, ["Review status cleared"]);
   } catch {
     try {
-      const statusFile = join27(PANOPTICON_HOME, "review-status.json");
-      if (existsSync28(statusFile)) {
-        const data = JSON.parse(readFileSync24(statusFile, "utf-8"));
+      const statusFile = join28(PANOPTICON_HOME, "review-status.json");
+      if (existsSync29(statusFile)) {
+        const data = JSON.parse(readFileSync25(statusFile, "utf-8"));
         const upperKey = issueId.toUpperCase();
         if (data[upperKey]) {
           delete data[upperKey];
@@ -6911,20 +7010,6 @@ async function clearReviewStatusStep(issueId) {
 
 // src/cli/commands/work/close-out.ts
 init_projects();
-function getGitHubConfig2() {
-  const envFile = join28(homedir13(), ".panopticon.env");
-  if (!existsSync29(envFile)) return null;
-  const content = readFileSync25(envFile, "utf-8");
-  const reposMatch = content.match(/GITHUB_REPOS=(.+)/);
-  if (!reposMatch) return null;
-  const repoStr = reposMatch[1].trim();
-  const parts = repoStr.split(",")[0];
-  if (!parts) return null;
-  const [ownerRepo, prefix] = parts.split(":");
-  const [owner, repo] = ownerRepo.split("/");
-  if (!owner || !repo) return null;
-  return { owner, repo, prefix: prefix || repo.toUpperCase().replace(/-CLI$/, "").replace(/-/g, "") };
-}
 async function closeOutCommand(issueId, options) {
   if (process.env.PANOPTICON_AGENT_ID) {
     console.error(chalk31.red("Close-out is a human-only operation. Agents cannot close out issues."));
@@ -6947,22 +7032,11 @@ async function closeOutCommand(issueId, options) {
     console.error(chalk31.red(`Could not resolve project for ${issueId}`));
     process.exit(1);
   }
-  const isGitHub = issueUpper.startsWith("PAN-");
-  let owner;
-  let repo;
-  let number;
-  if (isGitHub) {
-    const ghConfig = getGitHubConfig2();
-    if (ghConfig) {
-      owner = ghConfig.owner;
-      repo = ghConfig.repo;
-      number = parseInt(issueId.replace(/^PAN-/i, ""), 10);
-    } else {
-      owner = "eltmon";
-      repo = "panopticon-cli";
-      number = parseInt(issueId.replace(/^PAN-/i, ""), 10);
-    }
-  }
+  const ghResolution = resolveGitHubIssue(issueId);
+  const isGitHub = ghResolution.isGitHub;
+  const owner = ghResolution.isGitHub ? ghResolution.owner : void 0;
+  const repo = ghResolution.isGitHub ? ghResolution.repo : void 0;
+  const number = ghResolution.isGitHub ? ghResolution.number : void 0;
   if (!options.force) {
     console.log(chalk31.yellow(`
 Close-out ceremony for ${issueUpper}
@@ -7262,6 +7336,10 @@ function createWorktree(repoPath, targetPath, branchName) {
       stdio: "pipe"
     });
   }
+  try {
+    execSync3("git config beads.role agent", { cwd: targetPath, stdio: "pipe" });
+  } catch {
+  }
 }
 function removeWorktree2(repoPath, worktreePath) {
   execSync3(`git worktree remove "${worktreePath}" --force`, {
@@ -11669,7 +11747,7 @@ async function runPatrol() {
       if (nextTask) {
         console.log(`[deacon] Auto-resuming suspended ${specialist.name} for queued task: ${nextTask.payload.issueId}`);
         try {
-          const { resumeAgent } = await import("../agents-E43Y3HNU.js");
+          const { resumeAgent } = await import("../agents-5OPQKM5K.js");
           const message = `# Queued Work
 
 Processing queued task: ${nextTask.payload.issueId}`;
@@ -13604,7 +13682,7 @@ import { promisify as promisify18 } from "util";
 var execAsync18 = promisify18(exec18);
 async function listLogsCommand(project2, type, options) {
   try {
-    const { listRunLogs } = await import("../specialist-logs-KLGJCEUL.js");
+    const { listRunLogs } = await import("../specialist-logs-XJB5TCKJ.js");
     const limit = options.limit ? parseInt(options.limit) : 10;
     const runs = listRunLogs(project2, type, { limit });
     if (options.json) {
@@ -13649,7 +13727,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-KLGJCEUL.js");
+    const { getRunLog, parseLogMetadata, getRunLogPath } = await import("../specialist-logs-XJB5TCKJ.js");
     const content = getRunLog(project2, type, runId);
     if (!content) {
       console.error(`\u274C Run log not found: ${runId}`);
@@ -13673,8 +13751,8 @@ async function viewLogCommand(project2, type, runId, options) {
 }
 async function tailLogCommand(project2, type) {
   try {
-    const { getRunLogPath } = await import("../specialist-logs-KLGJCEUL.js");
-    const { getProjectSpecialistMetadata } = await import("../specialists-O4HWDJL5.js");
+    const { getRunLogPath } = await import("../specialist-logs-XJB5TCKJ.js");
+    const { getProjectSpecialistMetadata } = await import("../specialists-5LBRHYFA.js");
     const metadata = getProjectSpecialistMetadata(project2, type);
     if (!metadata.currentRun) {
       console.error(`\u274C No active run for ${project2}/${type}`);
@@ -13743,7 +13821,7 @@ async function cleanupLogsCommand(projectOrAll, type, options) {
         console.log("   Use --force to confirm.");
         process.exit(1);
       }
-      const { cleanupAllLogs } = await import("../specialist-logs-KLGJCEUL.js");
+      const { cleanupAllLogs } = await import("../specialist-logs-XJB5TCKJ.js");
       console.log("\u{1F9F9} Cleaning up old logs for all projects...\n");
       const results = cleanupAllLogs();
       console.log(`
@@ -13770,8 +13848,8 @@ async function cleanupLogsCommand(projectOrAll, type, options) {
       console.log("   Use --force to confirm.");
       process.exit(1);
     }
-    const { cleanupOldLogs } = await import("../specialist-logs-KLGJCEUL.js");
-    const { getSpecialistRetention } = await import("../projects-JEIVIYC6.js");
+    const { cleanupOldLogs } = await import("../specialist-logs-XJB5TCKJ.js");
+    const { getSpecialistRetention } = await import("../projects-CFX3RTDL.js");
     const retention = getSpecialistRetention(projectOrAll);
     console.log(`\u{1F9F9} Cleaning up old logs for ${projectOrAll}/${type}...`);
     console.log(`   Retention: ${retention.max_days} days or ${retention.max_runs} runs
@@ -14528,6 +14606,11 @@ async function projectAddCommand(projectPath, options = {}) {
     }
   }
   const isPolyrepo = !hasRootGit && subRepos.length > 0;
+  try {
+    const { preTrustDirectory } = await import("../workspace-manager-E434Z45T.js");
+    preTrustDirectory(fullPath);
+  } catch {
+  }
   let hooksInstalled = 0;
   if (hasRootGit) {
     hooksInstalled = installGitHooks(join48(fullPath, ".git"));
@@ -16469,7 +16552,7 @@ program.command("up").description("Start dashboard (and Traefik if enabled)").op
   console.log(chalk61.bold("Starting Panopticon...\n"));
   if (traefikEnabled && !options.skipTraefik) {
     try {
-      const { generatePanopticonTraefikConfig: generatePanopticonTraefikConfig2, ensureProjectCerts: ensureProjectCerts2, generateTlsConfig: generateTlsConfig2, cleanupStaleTlsSections } = await import("../traefik-QN7R5I6V.js");
+      const { generatePanopticonTraefikConfig: generatePanopticonTraefikConfig2, ensureProjectCerts: ensureProjectCerts2, generateTlsConfig: generateTlsConfig2, cleanupStaleTlsSections } = await import("../traefik-WFMQX2LY.js");
       cleanupStaleTlsSections();
       if (generatePanopticonTraefikConfig2()) {
         console.log(chalk61.dim("  Regenerated Traefik config from template"));