panopticon-cli 0.4.4 → 0.4.6

package/dist/chunk-VTDDVLCK.js

@@ -0,0 +1,1977 @@
+import {
+  checkHook,
+  getModelId,
+  init_hooks,
+  init_tmux,
+  init_work_type_router,
+  popFromHook,
+  pushToHook,
+  sendKeys
+} from "./chunk-PUR532O7.js";
+import {
+  init_projects,
+  projects_exports
+} from "./chunk-K45YD6A3.js";
+import {
+  COSTS_DIR,
+  PANOPTICON_HOME,
+  init_paths
+} from "./chunk-KGPRXDMX.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS,
+  init_esm_shims
+} from "./chunk-ZHC57RCV.js";
+
+// src/lib/cost.ts
+import { join } from "path";
+function calculateCost(usage, pricing) {
+  let cost = 0;
+  let inputMultiplier = 1;
+  let outputMultiplier = 1;
+  const totalInputTokens = usage.inputTokens + (usage.cacheReadTokens || 0) + (usage.cacheWriteTokens || 0);
+  if ((pricing.model === "claude-sonnet-4" || pricing.model === "claude-sonnet-4.5") && totalInputTokens > 2e5) {
+    inputMultiplier = 2;
+    outputMultiplier = 1.5;
+  }
+  cost += usage.inputTokens / 1e3 * pricing.inputPer1k * inputMultiplier;
+  cost += usage.outputTokens / 1e3 * pricing.outputPer1k * outputMultiplier;
+  if (usage.cacheReadTokens && pricing.cacheReadPer1k) {
+    cost += usage.cacheReadTokens / 1e3 * pricing.cacheReadPer1k;
+  }
+  if (usage.cacheWriteTokens) {
+    const ttl = usage.cacheTTL || "5m";
+    const cacheWritePrice = ttl === "1h" ? pricing.cacheWrite1hPer1k : pricing.cacheWrite5mPer1k;
+    if (cacheWritePrice) {
+      cost += usage.cacheWriteTokens / 1e3 * cacheWritePrice;
+    }
+  }
+  return Math.round(cost * 1e6) / 1e6;
+}
+function getPricing(provider, model) {
+  let pricing = DEFAULT_PRICING.find(
+    (p) => p.provider === provider && p.model === model
+  );
+  if (!pricing) {
+    pricing = DEFAULT_PRICING.find(
+      (p) => p.provider === provider && model.startsWith(p.model)
+    );
+  }
+  return pricing || null;
+}
+var DEFAULT_PRICING, BUDGETS_FILE;
+var init_cost = __esm({
+  "src/lib/cost.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    DEFAULT_PRICING = [
+      // Anthropic - 4.6 series
+      { provider: "anthropic", model: "claude-opus-4.6", inputPer1k: 5e-3, outputPer1k: 0.025, cacheReadPer1k: 5e-4, cacheWrite5mPer1k: 625e-5, cacheWrite1hPer1k: 0.01, currency: "USD" },
+      { provider: "anthropic", model: "claude-sonnet-4.5", inputPer1k: 3e-3, outputPer1k: 0.015, cacheReadPer1k: 3e-4, cacheWrite5mPer1k: 375e-5, cacheWrite1hPer1k: 6e-3, currency: "USD" },
+      { provider: "anthropic", model: "claude-haiku-4.5", inputPer1k: 1e-3, outputPer1k: 5e-3, cacheReadPer1k: 1e-4, cacheWrite5mPer1k: 125e-5, cacheWrite1hPer1k: 2e-3, currency: "USD" },
+      // Anthropic - 4.x series
+      { provider: "anthropic", model: "claude-opus-4-1", inputPer1k: 0.015, outputPer1k: 0.075, cacheReadPer1k: 15e-4, cacheWrite5mPer1k: 0.01875, cacheWrite1hPer1k: 0.03, currency: "USD" },
+      { provider: "anthropic", model: "claude-opus-4", inputPer1k: 0.015, outputPer1k: 0.075, cacheReadPer1k: 15e-4, cacheWrite5mPer1k: 0.01875, cacheWrite1hPer1k: 0.03, currency: "USD" },
+      { provider: "anthropic", model: "claude-sonnet-4", inputPer1k: 3e-3, outputPer1k: 0.015, cacheReadPer1k: 3e-4, cacheWrite5mPer1k: 375e-5, cacheWrite1hPer1k: 6e-3, currency: "USD" },
+      // Anthropic - Legacy
+      { provider: "anthropic", model: "claude-haiku-3", inputPer1k: 25e-5, outputPer1k: 125e-5, cacheReadPer1k: 3e-5, cacheWrite5mPer1k: 3e-4, cacheWrite1hPer1k: 5e-4, currency: "USD" },
+      // OpenAI
+      { provider: "openai", model: "gpt-4-turbo", inputPer1k: 0.01, outputPer1k: 0.03, currency: "USD" },
+      { provider: "openai", model: "gpt-4o", inputPer1k: 5e-3, outputPer1k: 0.015, currency: "USD" },
+      { provider: "openai", model: "gpt-4o-mini", inputPer1k: 15e-5, outputPer1k: 6e-4, currency: "USD" },
+      // Google
+      { provider: "google", model: "gemini-1.5-pro", inputPer1k: 125e-5, outputPer1k: 5e-3, currency: "USD" },
+      { provider: "google", model: "gemini-1.5-flash", inputPer1k: 75e-6, outputPer1k: 3e-4, currency: "USD" },
+      // Moonshot AI (Kimi)
+      { provider: "custom", model: "kimi-for-coding", inputPer1k: 6e-4, outputPer1k: 2e-3, cacheReadPer1k: 6e-5, cacheWrite5mPer1k: 75e-5, currency: "USD" },
+      { provider: "custom", model: "kimi-k2.5", inputPer1k: 6e-4, outputPer1k: 2e-3, cacheReadPer1k: 6e-5, cacheWrite5mPer1k: 75e-5, currency: "USD" }
+    ];
+    BUDGETS_FILE = join(COSTS_DIR, "budgets.json");
+  }
+});
+
+// src/lib/cost-parsers/jsonl-parser.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join as join2, basename } from "path";
+import { homedir } from "os";
+function getProjectDirs() {
+  if (!existsSync(CLAUDE_PROJECTS_DIR)) {
+    return [];
+  }
+  return readdirSync(CLAUDE_PROJECTS_DIR).map((name) => join2(CLAUDE_PROJECTS_DIR, name)).filter((path) => {
+    try {
+      return statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+function getSessionFiles(projectDir) {
+  if (!existsSync(projectDir)) {
+    return [];
+  }
+  return readdirSync(projectDir).filter((name) => name.endsWith(".jsonl")).map((name) => join2(projectDir, name)).sort((a, b) => {
+    try {
+      return statSync(b).mtime.getTime() - statSync(a).mtime.getTime();
+    } catch {
+      return 0;
+    }
+  });
+}
+function getAllSessionFiles() {
+  const files = [];
+  for (const projectDir of getProjectDirs()) {
+    files.push(...getSessionFiles(projectDir));
+  }
+  return files.sort((a, b) => {
+    try {
+      return statSync(b).mtime.getTime() - statSync(a).mtime.getTime();
+    } catch {
+      return 0;
+    }
+  });
+}
+function normalizeModelName(model) {
+  if (model.includes("claude")) {
+    let normalizedModel = model;
+    if (model.includes("opus-4-6") || model.includes("opus-4.6")) {
+      normalizedModel = "claude-opus-4.6";
+    } else if (model.includes("opus-4-1") || model.includes("opus-4.1")) {
+      normalizedModel = "claude-opus-4-1";
+    } else if (model.includes("opus-4") || model.includes("opus")) {
+      normalizedModel = "claude-opus-4";
+    }
+    if (model.includes("sonnet-4-5") || model.includes("sonnet-4.5")) {
+      normalizedModel = "claude-sonnet-4.5";
+    } else if (model.includes("sonnet-4") || model.includes("sonnet")) {
+      normalizedModel = "claude-sonnet-4";
+    }
+    if (model.includes("haiku-4-5") || model.includes("haiku-4.5")) {
+      normalizedModel = "claude-haiku-4.5";
+    } else if (model.includes("haiku-3")) {
+      normalizedModel = "claude-haiku-3";
+    } else if (model.includes("haiku")) {
+      normalizedModel = "claude-haiku-4.5";
+    }
+    return { provider: "anthropic", model: normalizedModel };
+  }
+  if (model.includes("gpt")) {
+    return { provider: "openai", model };
+  }
+  if (model.includes("gemini")) {
+    return { provider: "google", model };
+  }
+  return { provider: "anthropic", model: "claude-sonnet-4" };
+}
+function parseClaudeSession(sessionFile) {
+  if (!existsSync(sessionFile)) {
+    return null;
+  }
+  const content = readFileSync(sessionFile, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim());
+  let sessionId = "";
+  let startTime = "";
+  let endTime = "";
+  let primaryModel = "";
+  let messageCount = 0;
+  const totalUsage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0
+  };
+  const modelBreakdown = {};
+  let totalCostV2 = 0;
+  for (const line of lines) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.sessionId && !sessionId) {
+        sessionId = msg.sessionId;
+      }
+      if (msg.timestamp) {
+        if (!startTime || msg.timestamp < startTime) {
+          startTime = msg.timestamp;
+        }
+        if (!endTime || msg.timestamp > endTime) {
+          endTime = msg.timestamp;
+        }
+      }
+      const usage = msg.message?.usage || msg.usage;
+      const modelId = msg.message?.model || msg.model;
+      if (usage) {
+        totalUsage.inputTokens += usage.input_tokens || 0;
+        totalUsage.outputTokens += usage.output_tokens || 0;
+        totalUsage.cacheReadTokens = (totalUsage.cacheReadTokens || 0) + (usage.cache_read_input_tokens || 0);
+        totalUsage.cacheWriteTokens = (totalUsage.cacheWriteTokens || 0) + (usage.cache_creation_input_tokens || 0);
+        messageCount++;
+        if (modelId) {
+          const { provider: provider2, model: normalizedModel } = normalizeModelName(modelId);
+          const pricing2 = getPricing(provider2, normalizedModel);
+          if (pricing2) {
+            const msgUsage = {
+              inputTokens: usage.input_tokens || 0,
+              outputTokens: usage.output_tokens || 0,
+              cacheReadTokens: usage.cache_read_input_tokens || 0,
+              cacheWriteTokens: usage.cache_creation_input_tokens || 0
+            };
+            const msgCost = calculateCost(msgUsage, pricing2);
+            totalCostV2 += msgCost;
+            if (!modelBreakdown[modelId]) {
+              modelBreakdown[modelId] = {
+                cost: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                messageCount: 0
+              };
+            }
+            modelBreakdown[modelId].cost += msgCost;
+            modelBreakdown[modelId].inputTokens += msgUsage.inputTokens;
+            modelBreakdown[modelId].outputTokens += msgUsage.outputTokens;
+            modelBreakdown[modelId].messageCount++;
+          }
+        }
+      }
+      if (modelId && !primaryModel) {
+        primaryModel = modelId;
+      }
+    } catch {
+    }
+  }
+  if (totalUsage.inputTokens === 0 && totalUsage.outputTokens === 0) {
+    return null;
+  }
+  if (!sessionId) {
+    sessionId = basename(sessionFile, ".jsonl");
+  }
+  if (!primaryModel) {
+    primaryModel = "claude-sonnet-4";
+  }
+  const normalizedModels = Object.keys(modelBreakdown).map((id) => normalizeModelName(id).model);
+  const modelDisplay = normalizedModels.length > 0 ? normalizedModels.length > 1 ? normalizedModels.join(" \u2192 ") : normalizedModels[0] : normalizeModelName(primaryModel).model;
+  const { provider, model } = normalizeModelName(primaryModel);
+  const pricing = getPricing(provider, model);
+  const cost = pricing ? calculateCost(totalUsage, pricing) : 0;
+  return {
+    sessionId,
+    sessionFile,
+    startTime: startTime || (/* @__PURE__ */ new Date()).toISOString(),
+    endTime: endTime || (/* @__PURE__ */ new Date()).toISOString(),
+    model: modelDisplay,
+    usage: totalUsage,
+    cost,
+    // DEPRECATED: First-model pricing
+    cost_v2: totalCostV2 > 0 ? totalCostV2 : void 0,
+    // NEW: Accurate per-message pricing
+    messageCount,
+    modelBreakdown: Object.keys(modelBreakdown).length > 0 ? modelBreakdown : void 0
+    // NEW: Cost breakdown by model
+  };
+}
+var CLAUDE_PROJECTS_DIR;
+var init_jsonl_parser = __esm({
+  "src/lib/cost-parsers/jsonl-parser.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_cost();
+    CLAUDE_PROJECTS_DIR = join2(homedir(), ".claude", "projects");
+  }
+});
+
+// src/lib/cloister/specialist-handoff-logger.ts
+import { existsSync as existsSync2, mkdirSync, appendFileSync, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+function ensureLogDir() {
+  const logDir = join3(PANOPTICON_HOME, "logs");
+  if (!existsSync2(logDir)) {
+    mkdirSync(logDir, { recursive: true });
+  }
+}
+function logSpecialistHandoff(event) {
+  ensureLogDir();
+  const line = JSON.stringify(event) + "\n";
+  appendFileSync(SPECIALIST_HANDOFF_LOG_FILE, line, "utf-8");
+}
+function createSpecialistHandoff(fromSpecialist, toSpecialist, issueId, priority, context) {
+  return {
+    id: `${toSpecialist}-${issueId}-${Date.now()}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    issueId,
+    fromSpecialist,
+    toSpecialist,
+    status: "queued",
+    priority,
+    context
+  };
+}
+var SPECIALIST_HANDOFF_LOG_FILE;
+var init_specialist_handoff_logger = __esm({
+  "src/lib/cloister/specialist-handoff-logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    SPECIALIST_HANDOFF_LOG_FILE = join3(PANOPTICON_HOME, "logs", "specialist-handoffs.jsonl");
+  }
+});
+
+// src/lib/cloister/specialists.ts
+var specialists_exports = {};
+__export(specialists_exports, {
+  checkSpecialistQueue: () => checkSpecialistQueue,
+  clearSessionId: () => clearSessionId,
+  completeSpecialistTask: () => completeSpecialistTask,
+  countContextTokens: () => countContextTokens,
+  disableSpecialist: () => disableSpecialist,
+  enableSpecialist: () => enableSpecialist,
+  ensureProjectSpecialistDir: () => ensureProjectSpecialistDir,
+  exitGracePeriod: () => exitGracePeriod,
+  findSessionFile: () => findSessionFile,
+  getAllProjectSpecialistStatuses: () => getAllProjectSpecialistStatuses,
+  getAllSpecialistStatus: () => getAllSpecialistStatus,
+  getAllSpecialists: () => getAllSpecialists,
+  getEnabledSpecialists: () => getEnabledSpecialists,
+  getFeedbackStats: () => getFeedbackStats,
+  getGracePeriodState: () => getGracePeriodState,
+  getNextSpecialistTask: () => getNextSpecialistTask,
+  getPendingFeedback: () => getPendingFeedback,
+  getProjectSpecialistDir: () => getProjectSpecialistDir,
+  getProjectSpecialistMetadata: () => getProjectSpecialistMetadata,
+  getSessionFilePath: () => getSessionFilePath,
+  getSessionId: () => getSessionId,
+  getSpecialistMetadata: () => getSpecialistMetadata,
+  getSpecialistState: () => getSpecialistState,
+  getSpecialistStatus: () => getSpecialistStatus,
+  getTmuxSessionName: () => getTmuxSessionName,
+  incrementProjectRunCount: () => incrementProjectRunCount,
+  initSpecialistsDirectory: () => initSpecialistsDirectory,
+  initializeEnabledSpecialists: () => initializeEnabledSpecialists,
+  initializeSpecialist: () => initializeSpecialist,
+  isEnabled: () => isEnabled,
+  isInitialized: () => isInitialized,
+  isRunning: () => isRunning,
+  listProjectsWithSpecialists: () => listProjectsWithSpecialists,
+  listSessionFiles: () => listSessionFiles,
+  listSpecialistsForProject: () => listSpecialistsForProject,
+  loadRegistry: () => loadRegistry,
+  pauseGracePeriod: () => pauseGracePeriod,
+  recordWake: () => recordWake,
+  resumeGracePeriod: () => resumeGracePeriod,
+  saveRegistry: () => saveRegistry,
+  sendFeedbackToAgent: () => sendFeedbackToAgent,
+  setCurrentRun: () => setCurrentRun,
+  setSessionId: () => setSessionId,
+  signalSpecialistCompletion: () => signalSpecialistCompletion,
+  spawnEphemeralSpecialist: () => spawnEphemeralSpecialist,
+  startGracePeriod: () => startGracePeriod,
+  submitToSpecialistQueue: () => submitToSpecialistQueue,
+  terminateSpecialist: () => terminateSpecialist,
+  updateContextTokens: () => updateContextTokens,
+  updateProjectSpecialistMetadata: () => updateProjectSpecialistMetadata,
+  updateRunStatus: () => updateRunStatus,
+  updateSpecialistMetadata: () => updateSpecialistMetadata,
+  wakeSpecialist: () => wakeSpecialist,
+  wakeSpecialistOrQueue: () => wakeSpecialistOrQueue,
+  wakeSpecialistWithTask: () => wakeSpecialistWithTask
+});
+import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, unlinkSync, appendFileSync as appendFileSync2 } from "fs";
+import { join as join4, basename as basename2 } from "path";
+import { homedir as homedir2 } from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+function initSpecialistsDirectory() {
+  if (!existsSync3(SPECIALISTS_DIR)) {
+    mkdirSync2(SPECIALISTS_DIR, { recursive: true });
+  }
+  if (!existsSync3(REGISTRY_FILE)) {
+    const registry = {
+      version: "2.0",
+      // Updated for per-project structure
+      defaults: {
+        contextRuns: 5,
+        digestModel: null,
+        retention: {
+          maxDays: 30,
+          maxRuns: 50
+        }
+      },
+      projects: {},
+      // Keep legacy specialists for backward compatibility during transition
+      specialists: DEFAULT_SPECIALISTS,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    saveRegistry(registry);
+  } else {
+    migrateRegistryIfNeeded();
+  }
+}
+function migrateRegistryIfNeeded() {
+  try {
+    const content = readFileSync3(REGISTRY_FILE, "utf-8");
+    const registry = JSON.parse(content);
+    if (registry.version === "2.0" || registry.projects) {
+      return;
+    }
+    console.log("[specialists] Migrating registry to per-project structure...");
+    const migratedRegistry = {
+      version: "2.0",
+      defaults: {
+        contextRuns: 5,
+        digestModel: null,
+        retention: {
+          maxDays: 30,
+          maxRuns: 50
+        }
+      },
+      projects: {},
+      specialists: registry.specialists,
+      // Keep for backward compat
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    saveRegistry(migratedRegistry);
+    console.log("[specialists] Registry migration complete");
+  } catch (error) {
+    console.error("[specialists] Failed to migrate registry:", error);
+  }
+}
+function loadRegistry() {
+  initSpecialistsDirectory();
+  try {
+    const content = readFileSync3(REGISTRY_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error("Failed to load specialist registry:", error);
+    return {
+      version: "1.0",
+      defaults: {
+        contextRuns: 5,
+        digestModel: null,
+        retention: { maxDays: 30, maxRuns: 50 }
+      },
+      projects: {},
+      specialists: DEFAULT_SPECIALISTS,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+function saveRegistry(registry) {
+  if (!existsSync3(SPECIALISTS_DIR)) {
+    mkdirSync2(SPECIALISTS_DIR, { recursive: true });
+  }
+  registry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const content = JSON.stringify(registry, null, 2);
+    writeFileSync(REGISTRY_FILE, content, "utf-8");
+  } catch (error) {
+    console.error("Failed to save specialist registry:", error);
+    throw error;
+  }
+}
+function getSessionFilePath(name) {
+  return join4(SPECIALISTS_DIR, `${name}.session`);
+}
+function getSessionId(name) {
+  const sessionFile = getSessionFilePath(name);
+  if (!existsSync3(sessionFile)) {
+    return null;
+  }
+  try {
+    return readFileSync3(sessionFile, "utf-8").trim();
+  } catch (error) {
+    console.error(`Failed to read session file for ${name}:`, error);
+    return null;
+  }
+}
+function setSessionId(name, sessionId) {
+  initSpecialistsDirectory();
+  const sessionFile = getSessionFilePath(name);
+  try {
+    writeFileSync(sessionFile, sessionId.trim(), "utf-8");
+  } catch (error) {
+    console.error(`Failed to write session file for ${name}:`, error);
+    throw error;
+  }
+}
+function clearSessionId(name) {
+  const sessionFile = getSessionFilePath(name);
+  if (!existsSync3(sessionFile)) {
+    return false;
+  }
+  try {
+    unlinkSync(sessionFile);
+    return true;
+  } catch (error) {
+    console.error(`Failed to delete session file for ${name}:`, error);
+    throw error;
+  }
+}
+function getSpecialistMetadata(name) {
+  const registry = loadRegistry();
+  return (registry.specialists ?? []).find((s) => s.name === name) || null;
+}
+function updateSpecialistMetadata(name, updates) {
+  const registry = loadRegistry();
+  const specialists = registry.specialists ?? [];
+  const index = specialists.findIndex((s) => s.name === name);
+  if (index === -1) {
+    throw new Error(`Specialist ${name} not found in registry`);
+  }
+  specialists[index] = {
+    ...specialists[index],
+    ...updates,
+    name
+    // Ensure name doesn't change
+  };
+  registry.specialists = specialists;
+  saveRegistry(registry);
+}
+function getAllSpecialists() {
+  const registry = loadRegistry();
+  return registry.specialists ?? [];
+}
+function isInitialized(name) {
+  return getSessionId(name) !== null;
+}
+function getSpecialistState(name) {
+  return isInitialized(name) ? "sleeping" : "uninitialized";
+}
+function getTmuxSessionName(name, projectKey) {
+  if (projectKey) {
+    return `specialist-${projectKey}-${name}`;
+  }
+  return `specialist-${name}`;
+}
+function recordWake(name, sessionId) {
+  const updates = {
+    lastWake: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (sessionId) {
+    updates.sessionId = sessionId;
+  }
+  updateSpecialistMetadata(name, updates);
+}
+async function spawnEphemeralSpecialist(projectKey, specialistType, task) {
+  ensureProjectSpecialistDir(projectKey, specialistType);
+  const { loadContextDigest } = await import("./specialist-context-SNCJ7O7G.js");
+  const contextDigest = loadContextDigest(projectKey, specialistType);
+  const { createRunLog: createRunLog2 } = await import("./specialist-logs-A7ODEK2T.js");
+  const { runId, filePath: logFilePath } = createRunLog2(
+    projectKey,
+    specialistType,
+    task.issueId,
+    contextDigest || void 0
+  );
+  setCurrentRun(projectKey, specialistType, runId);
+  incrementProjectRunCount(projectKey, specialistType);
+  const taskPrompt = await buildTaskPrompt(projectKey, specialistType, task, contextDigest);
+  const tmuxSession = getTmuxSessionName(specialistType, projectKey);
+  const cwd = process.env.HOME || "/home/exedev";
+  try {
+    let model = "claude-sonnet-4-5";
+    try {
+      const workTypeId = `specialist-${specialistType}`;
+      model = getModelId(workTypeId);
+    } catch (error) {
+      console.warn(`Warning: Could not resolve model for ${specialistType}, using default`);
+    }
+    const permissionFlags = specialistType === "merge-agent" ? "--dangerously-skip-permissions --permission-mode bypassPermissions" : "--dangerously-skip-permissions";
+    const agentDir = join4(homedir2(), ".panopticon", "agents", tmuxSession);
+    await execAsync(`mkdir -p "${agentDir}"`, { encoding: "utf-8" });
+    const promptFile = join4(agentDir, "task-prompt.md");
+    writeFileSync(promptFile, taskPrompt);
+    const launcherScript = join4(agentDir, "launcher.sh");
+    writeFileSync(launcherScript, `#!/bin/bash
+cd "${cwd}"
+prompt=$(cat "${promptFile}")
+
+# Run Claude and tee output to log file
+claude ${permissionFlags} --model ${model} "$prompt" 2>&1 | tee -a "${logFilePath}"
+
+# Signal completion
+echo ""
+echo "## Specialist completed task"
+`, { mode: 493 });
+    await execAsync(
+      `tmux new-session -d -s "${tmuxSession}" "bash '${launcherScript}'"`,
+      { encoding: "utf-8" }
+    );
+    const { saveAgentRuntimeState } = await import("./agents-54LDKMHR.js");
+    saveAgentRuntimeState(tmuxSession, {
+      state: "active",
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      currentIssue: task.issueId
+    });
+    console.log(`[specialist] Spawned ephemeral ${specialistType} for ${projectKey}/${task.issueId} (run: ${runId})`);
+    return {
+      success: true,
+      runId,
+      tmuxSession,
+      message: `Spawned specialist ${specialistType} for ${task.issueId}`
+    };
+  } catch (error) {
+    console.error(`[specialist] Failed to spawn ${specialistType}:`, error);
+    setCurrentRun(projectKey, specialistType, null);
+    return {
+      success: false,
+      message: `Failed to spawn specialist: ${error.message}`,
+      error: error.message
+    };
+  }
+}
+async function buildTaskPrompt(projectKey, specialistType, task, contextDigest) {
+  const { getSpecialistPromptOverride } = await import("./projects-ESIB34QQ.js");
+  const customPrompt = getSpecialistPromptOverride(projectKey, specialistType);
+  let prompt = `# ${specialistType} Task - ${task.issueId}
+
+`;
+  if (contextDigest) {
+    prompt += `## Context from Recent Runs
+
+${contextDigest}
+
+`;
+  }
+  if (customPrompt) {
+    prompt += `## Project-Specific Guidelines
+
+${customPrompt}
+
+`;
+  }
+  prompt += `## Current Task
+
+`;
+  prompt += `Issue: ${task.issueId}
+`;
+  if (task.branch) prompt += `Branch: ${task.branch}
+`;
+  if (task.workspace) prompt += `Workspace: ${task.workspace}
+`;
+  if (task.prUrl) prompt += `PR URL: ${task.prUrl}
+`;
+  prompt += `
+`;
+  switch (specialistType) {
+    case "review-agent":
+      prompt += `Your task:
+1. Review all changes in the branch
+2. Check for code quality issues, security concerns, and best practices
+3. Verify test FILES exist for new code (DO NOT run tests)
+4. Provide specific, actionable feedback
+5. Update status via API when done
+
+IMPORTANT: DO NOT run tests. You are the REVIEW agent.
+
+Update status via API:
+- If issues found: POST to /api/workspaces/${task.issueId}/review-status with {"reviewStatus":"blocked","reviewNotes":"..."}
+- If review passes: POST with {"reviewStatus":"passed"} then queue test-agent`;
+      break;
+    case "test-agent":
+      prompt += `Your task:
+1. Run the full test suite
+2. Analyze any failures in detail
+3. Identify root causes
+4. Update status via API when done
+
+Update status via API:
+- If tests pass: POST to /api/workspaces/${task.issueId}/review-status with {"testStatus":"passed"}
+- If tests fail: POST with {"testStatus":"failed","testNotes":"..."}`;
+      break;
+    case "merge-agent":
+      prompt += `Your task:
+1. Fetch the latest main branch
+2. Attempt to merge ${task.branch} into main
+3. Resolve conflicts intelligently if needed
+4. Run tests to verify merge is clean
+5. Complete merge if tests pass`;
+      break;
+  }
+  prompt += `
+
+When you complete your task, report your findings and status.`;
+  return prompt;
+}
+function startGracePeriod(projectKey, specialistType, duration = 6e4) {
+  const key = `${projectKey}-${specialistType}`;
+  gracePeriodStates.set(key, {
+    active: true,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    duration,
+    paused: false
+  });
+  console.log(`[specialist] Grace period started for ${projectKey}/${specialistType} (${duration}ms)`);
+  setTimeout(() => {
+    const state = gracePeriodStates.get(key);
+    if (state && state.active && !state.paused) {
+      terminateSpecialist(projectKey, specialistType);
+    }
+  }, duration);
+}
+function pauseGracePeriod(projectKey, specialistType) {
+  const key = `${projectKey}-${specialistType}`;
+  const state = gracePeriodStates.get(key);
+  if (!state || !state.active) {
+    return false;
+  }
+  const elapsed = Date.now() - new Date(state.startedAt).getTime();
+  const remaining = state.duration - elapsed;
+  state.paused = true;
+  state.pausedAt = (/* @__PURE__ */ new Date()).toISOString();
+  state.remainingTime = remaining;
+  gracePeriodStates.set(key, state);
+  console.log(`[specialist] Grace period paused for ${projectKey}/${specialistType}`);
+  return true;
+}
+function resumeGracePeriod(projectKey, specialistType) {
+  const key = `${projectKey}-${specialistType}`;
+  const state = gracePeriodStates.get(key);
+  if (!state || !state.active || !state.paused) {
+    return false;
+  }
+  state.paused = false;
+  state.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  state.pausedAt = void 0;
+  gracePeriodStates.set(key, state);
+  console.log(`[specialist] Grace period resumed for ${projectKey}/${specialistType}`);
+  setTimeout(() => {
+    const currentState = gracePeriodStates.get(key);
+    if (currentState && currentState.active && !currentState.paused) {
+      terminateSpecialist(projectKey, specialistType);
+    }
+  }, state.remainingTime || 0);
+  return true;
+}
+function exitGracePeriod(projectKey, specialistType) {
+  const key = `${projectKey}-${specialistType}`;
+  gracePeriodStates.delete(key);
+  terminateSpecialist(projectKey, specialistType);
+}
+function getGracePeriodState(projectKey, specialistType) {
+  const key = `${projectKey}-${specialistType}`;
+  return gracePeriodStates.get(key) || null;
+}
+function signalSpecialistCompletion(projectKey, specialistType, result) {
+  const metadata = getProjectSpecialistMetadata(projectKey, specialistType);
+  updateRunStatus(projectKey, specialistType, result.status);
+  if (metadata.currentRun) {
+    const { finalizeRunLog: finalizeRunLog2 } = (init_specialist_logs(), __toCommonJS(specialist_logs_exports));
+    try {
+      finalizeRunLog2(projectKey, specialistType, metadata.currentRun, {
+        status: result.status,
+        notes: result.notes
+      });
+    } catch (error) {
+      console.error(`[specialist] Failed to finalize log:`, error);
+    }
+  }
+  startGracePeriod(projectKey, specialistType, 6e4);
+  console.log(`[specialist] ${specialistType} completed for ${projectKey} (status: ${result.status})`);
+}
+async function terminateSpecialist(projectKey, specialistType) {
+  const tmuxSession = getTmuxSessionName(specialistType, projectKey);
+  const metadata = getProjectSpecialistMetadata(projectKey, specialistType);
+  try {
+    await execAsync(`tmux kill-session -t "${tmuxSession}"`);
+    console.log(`[specialist] Terminated ${projectKey}/${specialistType}`);
+  } catch (error) {
+    console.error(`[specialist] Failed to kill tmux session ${tmuxSession}:`, error);
+  }
+  if (metadata.currentRun) {
+    const { finalizeRunLog: finalizeRunLog2 } = await import("./specialist-logs-A7ODEK2T.js");
+    try {
+      finalizeRunLog2(projectKey, specialistType, metadata.currentRun, {
+        status: metadata.lastRunStatus || "incomplete",
+        notes: "Specialist terminated"
+      });
+    } catch (error) {
+      console.error(`[specialist] Failed to finalize log:`, error);
+    }
+    setCurrentRun(projectKey, specialistType, null);
+  }
+  const key = `${projectKey}-${specialistType}`;
+  gracePeriodStates.delete(key);
+  const { saveAgentRuntimeState } = await import("./agents-54LDKMHR.js");
+  saveAgentRuntimeState(tmuxSession, {
+    state: "suspended",
+    lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const { scheduleDigestGeneration } = await import("./specialist-context-SNCJ7O7G.js");
+  scheduleDigestGeneration(projectKey, specialistType);
+  scheduleLogCleanup(projectKey, specialistType);
+}
+function scheduleLogCleanup(projectKey, specialistType) {
+  Promise.resolve().then(async () => {
+    try {
+      const { cleanupOldLogs: cleanupOldLogs2 } = await import("./specialist-logs-A7ODEK2T.js");
+      const { getSpecialistRetention } = await import("./projects-ESIB34QQ.js");
+      const retention = getSpecialistRetention(projectKey);
+      const deleted = cleanupOldLogs2(projectKey, specialistType, { maxDays: retention.max_days, maxRuns: retention.max_runs });
+      if (deleted > 0) {
+        console.log(`[specialist] Cleaned up ${deleted} old logs for ${projectKey}/${specialistType}`);
+      }
+    } catch (error) {
+      console.error(`[specialist] Log cleanup failed for ${projectKey}/${specialistType}:`, error);
+    }
+  });
+}
+function getProjectSpecialistDir(projectKey, specialistType) {
+  return join4(SPECIALISTS_DIR, projectKey, specialistType);
+}
+function ensureProjectSpecialistDir(projectKey, specialistType) {
+  const specialistDir = getProjectSpecialistDir(projectKey, specialistType);
+  const runsDir = join4(specialistDir, "runs");
+  const contextDir = join4(specialistDir, "context");
+  if (!existsSync3(runsDir)) {
+    mkdirSync2(runsDir, { recursive: true });
+  }
+  if (!existsSync3(contextDir)) {
+    mkdirSync2(contextDir, { recursive: true });
+  }
+}
+function getProjectSpecialistMetadata(projectKey, specialistType) {
+  const registry = loadRegistry();
+  if (!registry.projects[projectKey]) {
+    registry.projects[projectKey] = {};
+  }
+  if (!registry.projects[projectKey][specialistType]) {
+    registry.projects[projectKey][specialistType] = {
+      runCount: 0,
+      lastRunAt: null,
+      lastRunStatus: null,
+      currentRun: null
+    };
+    saveRegistry(registry);
+  }
+  return registry.projects[projectKey][specialistType];
+}
+function updateProjectSpecialistMetadata(projectKey, specialistType, updates) {
+  const registry = loadRegistry();
+  if (!registry.projects[projectKey]) {
+    registry.projects[projectKey] = {};
+  }
+  if (!registry.projects[projectKey][specialistType]) {
+    registry.projects[projectKey][specialistType] = {
+      runCount: 0,
+      lastRunAt: null,
+      lastRunStatus: null,
+      currentRun: null
+    };
+  }
+  registry.projects[projectKey][specialistType] = {
+    ...registry.projects[projectKey][specialistType],
+    ...updates
+  };
+  saveRegistry(registry);
+}
+function incrementProjectRunCount(projectKey, specialistType) {
+  const metadata = getProjectSpecialistMetadata(projectKey, specialistType);
+  updateProjectSpecialistMetadata(projectKey, specialistType, {
+    runCount: metadata.runCount + 1,
+    lastRunAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function setCurrentRun(projectKey, specialistType, runId) {
+  updateProjectSpecialistMetadata(projectKey, specialistType, { currentRun: runId });
+}
+function updateRunStatus(projectKey, specialistType, status) {
+  updateProjectSpecialistMetadata(projectKey, specialistType, { lastRunStatus: status });
+}
+function listProjectsWithSpecialists() {
+  const registry = loadRegistry();
+  return Object.keys(registry.projects);
+}
+function listSpecialistsForProject(projectKey) {
+  const registry = loadRegistry();
+  const project = registry.projects[projectKey];
+  if (!project) {
+    return [];
+  }
+  return Object.keys(project);
+}
+async function getAllProjectSpecialistStatuses() {
+  const registry = loadRegistry();
+  const results = [];
+  for (const [projectKey, specialists] of Object.entries(registry.projects)) {
+    for (const [specialistType, metadata] of Object.entries(specialists)) {
+      const tmuxSession = getTmuxSessionName(specialistType, projectKey);
+      const running = await isRunning(specialistType, projectKey);
+      results.push({
+        projectKey,
+        specialistType,
+        metadata,
+        isRunning: running,
+        tmuxSession
+      });
+    }
+  }
+  return results;
+}
+function updateContextTokens(name, tokens) {
+  updateSpecialistMetadata(name, { contextTokens: tokens });
+}
+function listSessionFiles() {
+  initSpecialistsDirectory();
+  try {
+    const files = readdirSync2(SPECIALISTS_DIR);
+    const sessionFiles = files.filter((f) => f.endsWith(".session"));
+    return sessionFiles.map((f) => f.replace(".session", ""));
+  } catch (error) {
+    console.error("Failed to list session files:", error);
+    return [];
+  }
+}
+function enableSpecialist(name) {
+  updateSpecialistMetadata(name, { enabled: true });
+}
+function disableSpecialist(name) {
+  updateSpecialistMetadata(name, { enabled: false });
+}
+function isEnabled(name) {
+  const metadata = getSpecialistMetadata(name);
+  return metadata?.enabled ?? false;
+}
+function getEnabledSpecialists() {
+  return getAllSpecialists().filter((s) => s.enabled);
+}
+function findSessionFile(sessionId) {
+  try {
+    const allFiles = getAllSessionFiles();
+    for (const file of allFiles) {
+      const fileSessionId = basename2(file, ".jsonl");
+      if (fileSessionId === sessionId) {
+        return file;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function countContextTokens(name) {
+  const sessionId = getSessionId(name);
+  if (!sessionId) {
+    return null;
+  }
+  const sessionFile = findSessionFile(sessionId);
+  if (!sessionFile) {
+    return null;
+  }
+  const sessionUsage = parseClaudeSession(sessionFile);
+  if (!sessionUsage) {
+    return null;
+  }
+  return sessionUsage.usage.inputTokens + sessionUsage.usage.outputTokens + (sessionUsage.usage.cacheReadTokens || 0) + (sessionUsage.usage.cacheWriteTokens || 0);
+}
+async function isRunning(name, projectKey) {
+  const tmuxSession = getTmuxSessionName(name, projectKey);
+  try {
+    await execAsync(`tmux has-session -t ${tmuxSession}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getSpecialistStatus(name, projectKey) {
+  const metadata = getSpecialistMetadata(name) || {
+    name,
+    displayName: name,
+    description: "",
+    enabled: false,
+    autoWake: false
+  };
+  const sessionId = getSessionId(name);
+  const running = await isRunning(name, projectKey);
+  const contextTokens = countContextTokens(name);
+  const { getAgentRuntimeState } = await import("./agents-54LDKMHR.js");
+  const tmuxSession = getTmuxSessionName(name, projectKey);
+  const runtimeState = getAgentRuntimeState(tmuxSession);
+  let state;
+  if (runtimeState) {
+    switch (runtimeState.state) {
+      case "active":
+        state = "active";
+        break;
+      case "idle":
+        state = "sleeping";
+        break;
+      case "suspended":
+        state = "sleeping";
+        break;
+      case "uninitialized":
+      default:
+        state = "uninitialized";
+        break;
+    }
+  } else {
+    if (running && sessionId) {
+      state = "sleeping";
+    } else if (sessionId) {
+      state = "sleeping";
+    } else {
+      state = "uninitialized";
+    }
+  }
+  return {
+    ...metadata,
+    sessionId: sessionId || void 0,
+    contextTokens: contextTokens || void 0,
+    state,
+    isRunning: running,
+    tmuxSession: getTmuxSessionName(name, projectKey),
+    currentIssue: runtimeState?.currentIssue
+  };
+}
+async function getAllSpecialistStatus() {
+  const specialists = getAllSpecialists();
+  return Promise.all(specialists.map((metadata) => getSpecialistStatus(metadata.name)));
+}
+async function initializeSpecialist(name) {
+  if (await isRunning(name)) {
+    return {
+      success: false,
+      message: `Specialist ${name} is already running`,
+      error: "already_running"
+    };
+  }
+  if (getSessionId(name)) {
+    return {
+      success: false,
+      message: `Specialist ${name} is already initialized. Use wake to start it.`,
+      error: "already_initialized"
+    };
+  }
+  const tmuxSession = getTmuxSessionName(name);
+  const cwd = process.env.HOME || "/home/eltmon";
+  let model = "claude-sonnet-4-5";
+  try {
+    const workTypeId = `specialist-${name}`;
+    model = getModelId(workTypeId);
+  } catch (error) {
+    console.warn(`Warning: Could not resolve model for ${name}, using default model`);
+  }
+  const identityPrompt = `You are the ${name} specialist agent for Panopticon.
+Your role: ${name === "merge-agent" ? "Resolve merge conflicts and ensure clean integrations" : name === "review-agent" ? "Review code changes and provide quality feedback" : name === "test-agent" ? "Execute and analyze test results" : "Assist with development tasks"}
+
+You will be woken up when your services are needed. For now, acknowledge your initialization and wait.
+Say: "I am the ${name} specialist, ready and waiting for tasks."`;
+  try {
+    const agentDir = join4(homedir2(), ".panopticon", "agents", tmuxSession);
+    await execAsync(`mkdir -p "${agentDir}"`, { encoding: "utf-8" });
+    const promptFile = join4(agentDir, "identity-prompt.md");
+    const launcherScript = join4(agentDir, "launcher.sh");
+    writeFileSync(promptFile, identityPrompt);
+    writeFileSync(launcherScript, `#!/bin/bash
+cd "${cwd}"
+prompt=$(cat "${promptFile}")
+exec claude --dangerously-skip-permissions --model ${model} "$prompt"
+`, { mode: 493 });
+    await execAsync(
+      `tmux new-session -d -s "${tmuxSession}" "bash '${launcherScript}'"`,
+      { encoding: "utf-8" }
+    );
+    recordWake(name);
+    return {
+      success: true,
+      message: `Specialist ${name} initialized and started`,
+      tmuxSession
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Failed to initialize specialist ${name}: ${errorMessage}`,
+      error: errorMessage
+    };
+  }
+}
+async function initializeEnabledSpecialists() {
+  const enabled = getEnabledSpecialists();
+  const results = [];
+  for (const specialist of enabled) {
+    const sessionId = getSessionId(specialist.name);
+    if (!sessionId) {
+      console.log(`  \u2192 Auto-initializing specialist: ${specialist.name}`);
+      const result = await initializeSpecialist(specialist.name);
+      results.push({
+        name: specialist.name,
+        success: result.success,
+        message: result.message
+      });
+      if (results.length < enabled.length) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      }
+    } else {
+      results.push({
+        name: specialist.name,
+        success: true,
+        message: `Already initialized with session ${sessionId.substring(0, 8)}...`
+      });
+    }
+  }
+  return results;
+}
+async function resetSpecialist(name) {
+  const tmuxSession = getTmuxSessionName(name);
+  try {
+    await execAsync(`tmux send-keys -t "${tmuxSession}" C-c`, { encoding: "utf-8" });
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    sendKeys(tmuxSession, "cd ~");
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    await execAsync(`tmux send-keys -t "${tmuxSession}" C-u`, { encoding: "utf-8" });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  } catch (error) {
+    console.error(`[specialist] Failed to reset ${name}:`, error);
+  }
+}
+async function wakeSpecialist(name, taskPrompt, options = {}) {
+  const { waitForReady = true, startIfNotRunning = true, issueId } = options;
+  const tmuxSession = getTmuxSessionName(name);
+  const sessionId = getSessionId(name);
+  const wasAlreadyRunning = await isRunning(name);
+  if (!wasAlreadyRunning) {
+    if (!startIfNotRunning) {
+      return {
+        success: false,
+        message: `Specialist ${name} is not running`,
+        wasAlreadyRunning: false,
+        error: "not_running"
+      };
+    }
+    const cwd = process.env.HOME || "/home/eltmon";
+    try {
+      const modelFlag = name === "merge-agent" ? "--model opus" : "";
+      const permissionFlags = name === "merge-agent" ? "--dangerously-skip-permissions --permission-mode bypassPermissions" : "--dangerously-skip-permissions";
+      const claudeCmd = sessionId ? `claude --resume "${sessionId}" ${modelFlag} ${permissionFlags}` : `claude ${modelFlag} ${permissionFlags}`;
+      await execAsync(
+        `tmux new-session -d -s "${tmuxSession}" -c "${cwd}" "${claudeCmd}"`,
+        { encoding: "utf-8" }
+      );
+      if (waitForReady) {
+        await new Promise((resolve) => setTimeout(resolve, 3e3));
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        message: `Failed to start specialist ${name}: ${msg}`,
+        wasAlreadyRunning: false,
+        error: msg
+      };
+    }
+  }
+  await resetSpecialist(name);
+  try {
+    const isLargePrompt = taskPrompt.length > 500 || taskPrompt.includes("\n");
+    if (isLargePrompt) {
+      if (!existsSync3(TASKS_DIR)) {
+        mkdirSync2(TASKS_DIR, { recursive: true });
+      }
+      const taskFile = join4(TASKS_DIR, `${name}-${Date.now()}.md`);
+      writeFileSync(taskFile, taskPrompt, "utf-8");
+      const shortMessage = `Read and execute the task in: ${taskFile}`;
+      sendKeys(tmuxSession, shortMessage);
+    } else {
+      sendKeys(tmuxSession, taskPrompt);
+    }
+    recordWake(name, sessionId || void 0);
+    const { saveAgentRuntimeState } = await import("./agents-54LDKMHR.js");
+    saveAgentRuntimeState(tmuxSession, {
+      state: "active",
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      currentIssue: issueId
+    });
+    return {
+      success: true,
+      message: wasAlreadyRunning ? `Sent task to running specialist ${name}` : `Started specialist ${name} and sent task`,
+      tmuxSession,
+      wasAlreadyRunning
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message: `Failed to send task to specialist ${name}: ${msg}`,
+      tmuxSession,
+      wasAlreadyRunning,
+      error: msg
+    };
+  }
+}
+async function wakeSpecialistWithTask(name, task) {
+  let prompt;
+  switch (name) {
+    case "merge-agent":
+      prompt = `New merge task for ${task.issueId}:
+
+Branch: ${task.branch || "unknown"}
+Workspace: ${task.workspace || "unknown"}
+${task.prUrl ? `PR URL: ${task.prUrl}` : ""}
+
+Your task:
+1. Fetch the latest main branch
+2. Attempt to merge ${task.branch} into main
+3. If conflicts arise, resolve them intelligently based on context
+4. Run the test suite to verify the merge is clean
+5. If tests pass, complete the merge and push
+6. If tests fail, analyze the failures and either fix them or report back
+
+When done, provide feedback on:
+- Any conflicts encountered and how you resolved them
+- Test results
+- Any patterns you notice that future agents should be aware of
+
+Use the send-feedback-to-agent skill to report findings back to the issue agent.`;
+      break;
+    case "review-agent":
+      prompt = `New review task for ${task.issueId}:
+
+Branch: ${task.branch || "unknown"}
+Workspace: ${task.workspace || "unknown"}
+${task.prUrl ? `PR URL: ${task.prUrl}` : ""}
+
+Your task:
+1. Review all changes in the branch compared to main
+2. Check for code quality issues, security concerns, and best practices
+3. Verify test FILES exist for new code (DO NOT run tests - test-agent does that)
+4. Provide specific, actionable feedback
+
+IMPORTANT: DO NOT run tests (npm test). You are the REVIEW agent - you only review code.
+The TEST agent will run tests in the next step.
+
+## How to Review Changes
+
+**Step 1:** Get the list of changed files:
+\`\`\`bash
+cd ${task.workspace || "unknown"} && git diff --name-only main...HEAD
+\`\`\`
+
+**Step 2:** Read the CURRENT version of each changed file using the Read tool.
+Review the actual file contents \u2014 do NOT rely solely on diff output.
+
+**Step 3:** If you need to see what specifically changed, use:
+\`\`\`bash
+cd ${task.workspace || "unknown"} && git diff main...HEAD -- <file>
+\`\`\`
+
+## Avoiding False Positives
+
+**CRITICAL:** When reviewing diffs, understand that:
+- Lines starting with \`+\` are ADDITIONS (new code)
+- Lines starting with \`-\` are DELETIONS (removed code)
+- Lines without prefix are CONTEXT (unchanged surrounding code)
+- The SAME content may appear in both \`-\` and \`+\` sections when code is moved or reformatted \u2014 this is NOT duplication
+- A section shown in diff context does NOT mean it appears twice in the actual file
+- **Always read the actual file** to verify before claiming duplicate or redundant content
+
+Do NOT flag:
+- Code that appears in both removed and added hunks (it was moved, not duplicated)
+- Diff context lines as "duplicate sections" \u2014 they exist once in the real file
+- Reformatted/restructured code as "duplicated"
+
+## REQUIRED: Update Status via API
+
+You MUST execute these curl commands and verify they succeed. Do NOT just describe them - actually RUN them with Bash.
+
+If issues found:
+\`\`\`bash
+# EXECUTE THIS - verify you see JSON response with reviewStatus
+curl -s -X POST http://localhost:3011/api/workspaces/${task.issueId}/review-status -H "Content-Type: application/json" -d '{"reviewStatus":"blocked","reviewNotes":"[describe issues]"}' | jq .
+\`\`\`
+Then use send-feedback-to-agent skill to notify issue agent.
+
+If review passes:
+\`\`\`bash
+# EXECUTE THIS FIRST - verify you see JSON response with reviewStatus:"passed"
+curl -s -X POST http://localhost:3011/api/workspaces/${task.issueId}/review-status -H "Content-Type: application/json" -d '{"reviewStatus":"passed"}' | jq .
+
+# THEN EXECUTE THIS - verify you see JSON response with queued task
+curl -s -X POST http://localhost:3011/api/specialists/test-agent/queue -H "Content-Type: application/json" -d '{"issueId":"${task.issueId}","workspace":"${task.workspace}","branch":"${task.branch}"}' | jq .
+\`\`\`
+
+\u26A0\uFE0F VERIFICATION: After running each curl, confirm you see valid JSON output. If you get an error, report it.`;
+      break;
+    case "test-agent":
+      prompt = `New test task for ${task.issueId}:
+
+Branch: ${task.branch || "unknown"}
+Workspace: ${task.workspace || "unknown"}
+
+Your task:
+1. Run the full test suite on the feature branch
+2. Run the same test suite on the main branch (baseline)
+3. Compare results: identify which failures are NEW vs pre-existing
+4. Only fail the feature branch for NEW regressions
+5. Update status via API when done
+
+## CRITICAL: Bash Timeout for Test Commands
+
+**ALWAYS use timeout: 300000 (5 minutes) when running test commands.**
+Test suites commonly take 2-5 minutes. The default bash timeout is only 2 minutes and WILL cause premature failures.
+Do NOT run test commands in background mode \u2014 run them directly with a 5-minute timeout.
+
+Example:
+\`\`\`bash
+cd ${task.workspace || "unknown"} && npm test 2>&1 | tail -30
+# Use timeout: 300000 for this command
+\`\`\`
+
+## CRITICAL: Baseline Comparison
+
+**You MUST compare test results against the main branch baseline.**
+
+Pre-existing failures that also occur on main branch should NOT block the feature branch.
+
+Steps:
+1. Run \`npm test\` (or detected command) on the feature branch - record results (timeout: 300000)
+2. Run tests on main branch baseline (timeout: 300000): \`cd ${task.context?.workspace ? task.context.workspace.replace(/workspaces\/feature-[^/]+/, "") : "unknown"} && npm test 2>&1 | tail -30\`
+3. Compare: any test that fails on BOTH branches is pre-existing
+4. Only NEW failures (pass on main, fail on feature) should block
+
+**Pass criteria:** The feature branch introduces ZERO new test failures compared to main.
+**Fail criteria:** The feature branch introduces one or more NEW test failures not present on main.
+
+Report pre-existing failures as informational notes, but do NOT block the feature for them.
+
+## REQUIRED: Update Status via API
+
+You MUST execute the appropriate curl command and verify it succeeds. Do NOT just describe it - actually RUN it with Bash.
+
+If NO new regressions (tests PASS):
+\`\`\`bash
+# EXECUTE THIS - verify you see JSON response with testStatus:"passed"
+curl -s -X POST http://localhost:3011/api/workspaces/${task.issueId}/review-status -H "Content-Type: application/json" -d '{"testStatus":"passed","testNotes":"[summary including pre-existing failures if any]"}' | jq .
+\`\`\`
+
+If NEW regressions found (tests FAIL):
+\`\`\`bash
+# EXECUTE THIS - verify you see JSON response with testStatus:"failed"
+curl -s -X POST http://localhost:3011/api/workspaces/${task.issueId}/review-status -H "Content-Type: application/json" -d '{"testStatus":"failed","testNotes":"[describe NEW failures only]"}' | jq .
+\`\`\`
+Then use send-feedback-to-agent skill to notify issue agent of NEW failures only.
+
+\u26A0\uFE0F VERIFICATION: After running curl, confirm you see valid JSON output with the updated status. If you get an error or empty response, the update FAILED - report this.
+
+IMPORTANT: Do NOT hand off to merge-agent. Human clicks Merge button when ready.`;
+      break;
+    default:
+      prompt = `Task for ${task.issueId}: Please process this task and report findings.`;
+  }
+  return wakeSpecialist(name, prompt, { issueId: task.issueId });
+}
+async function wakeSpecialistOrQueue(name, task, options = {}) {
+  const { priority = "normal", source = "handoff" } = options;
+  const running = await isRunning(name);
+  const { getAgentRuntimeState } = await import("./agents-54LDKMHR.js");
+  const tmuxSession = getTmuxSessionName(name);
+  const runtimeState = getAgentRuntimeState(tmuxSession);
+  const idle = runtimeState?.state === "idle" || runtimeState?.state === "suspended";
+  if (running && !idle) {
+    try {
+      submitToSpecialistQueue(name, {
+        priority,
+        source,
+        issueId: task.issueId,
+        workspace: task.workspace,
+        branch: task.branch,
+        prUrl: task.prUrl,
+        context: task.context
+      });
+      console.log(`[specialist] ${name} busy, queued task for ${task.issueId} (priority: ${priority})`);
+      return {
+        success: true,
+        queued: true,
+        message: `Specialist ${name} is busy. Task queued with ${priority} priority.`
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        queued: false,
+        message: `Failed to queue task for ${name}: ${msg}`,
+        error: msg
+      };
+    }
+  }
+  const { saveAgentRuntimeState } = await import("./agents-54LDKMHR.js");
+  saveAgentRuntimeState(tmuxSession, {
+    state: "active",
+    lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+    currentIssue: task.issueId
+  });
+  console.log(`[specialist] ${name} marked active (preventing concurrent wakes)`);
+  try {
+    const wakeResult = await wakeSpecialistWithTask(name, task);
+    if (!wakeResult.success) {
+      saveAgentRuntimeState(tmuxSession, {
+        state: "idle",
+        lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+        currentIssue: void 0
+      });
+    }
+    return {
+      success: wakeResult.success,
+      queued: false,
+      message: wakeResult.message,
+      error: wakeResult.error
+    };
+  } catch (error) {
+    saveAgentRuntimeState(tmuxSession, {
+      state: "idle",
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      currentIssue: void 0
+    });
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      queued: false,
+      message: `Failed to wake specialist ${name}: ${msg}`,
+      error: msg
+    };
+  }
+}
+function submitToSpecialistQueue(specialistName, task) {
+  const item = {
+    type: "task",
+    priority: task.priority,
+    source: task.source,
+    payload: {
+      issueId: task.issueId,
+      context: {
+        ...task.context,
+        prUrl: task.prUrl,
+        workspace: task.workspace,
+        branch: task.branch,
+        filesChanged: task.filesChanged
+      }
+    }
+  };
+  const queueItem = pushToHook(specialistName, item);
+  const handoffEvent = createSpecialistHandoff(
+    task.source,
+    // From (e.g., 'review-agent' or 'issue-agent')
+    specialistName,
+    // To specialist
+    task.issueId,
+    task.priority,
+    {
+      workspace: task.workspace,
+      branch: task.branch,
+      prUrl: task.prUrl,
+      source: task.source
+    }
+  );
+  logSpecialistHandoff(handoffEvent);
+  return queueItem;
+}
+function checkSpecialistQueue(specialistName) {
+  return checkHook(specialistName);
+}
+function completeSpecialistTask(specialistName, itemId) {
+  return popFromHook(specialistName, itemId);
+}
+function getNextSpecialistTask(specialistName) {
+  const { items } = checkSpecialistQueue(specialistName);
+  return items.length > 0 ? items[0] : null;
+}
+async function sendFeedbackToAgent(feedback) {
+  const { fromSpecialist, toIssueId, summary, details } = feedback;
+  if (!existsSync3(FEEDBACK_DIR)) {
+    mkdirSync2(FEEDBACK_DIR, { recursive: true });
+  }
+  const fullFeedback = {
+    ...feedback,
+    id: `feedback-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    const line = JSON.stringify(fullFeedback) + "\n";
+    appendFileSync2(FEEDBACK_LOG, line, "utf-8");
+  } catch (error) {
+    console.error(`[specialist] Failed to log feedback:`, error);
+  }
+  const agentSession = `agent-${toIssueId.toLowerCase()}`;
+  try {
+    const { messageAgent } = await import("./agents-54LDKMHR.js");
+    const feedbackMessage = formatFeedbackForAgent(fullFeedback);
+    await messageAgent(agentSession, feedbackMessage);
+    console.log(`[specialist] Sent feedback from ${fromSpecialist} to ${agentSession}`);
+    return true;
+  } catch (err) {
+    console.log(`[specialist] Could not send feedback to ${agentSession}:`, err);
+    return false;
+  }
+}
+function formatFeedbackForAgent(feedback) {
+  const { fromSpecialist, feedbackType, category, summary, details, actionItems, patterns, suggestions } = feedback;
+  const typeEmoji = {
+    success: "\u2705",
+    failure: "\u274C",
+    warning: "\u26A0\uFE0F",
+    insight: "\u{1F4A1}"
+  }[feedbackType];
+  let message = `
+${typeEmoji} **Feedback from ${fromSpecialist}** (${category})
+
+`;
+  message += `**Summary:** ${summary}
+
+`;
+  message += `**Details:**
+${details}
+`;
+  if (actionItems?.length) {
+    message += `
+**Action Items:**
+`;
+    actionItems.forEach((item, i) => {
+      message += `${i + 1}. ${item}
+`;
+    });
+  }
+  if (patterns?.length) {
+    message += `
+**Patterns Noticed:**
+`;
+    patterns.forEach((pattern) => {
+      message += `- ${pattern}
+`;
+    });
+  }
+  if (suggestions?.length) {
+    message += `
+**Suggestions:**
+`;
+    suggestions.forEach((suggestion) => {
+      message += `- ${suggestion}
+`;
+    });
+  }
+  return message;
+}
+function getPendingFeedback(issueId) {
+  if (!existsSync3(FEEDBACK_LOG)) {
+    return [];
+  }
+  try {
+    const content = readFileSync3(FEEDBACK_LOG, "utf-8");
+    const lines = content.trim().split("\n").filter((l) => l.length > 0);
+    const allFeedback = lines.map((line) => JSON.parse(line));
+    return allFeedback.filter((f) => f.toIssueId.toLowerCase() === issueId.toLowerCase());
+  } catch (error) {
+    console.error(`[specialist] Failed to read feedback log:`, error);
+    return [];
+  }
+}
+function getFeedbackStats() {
+  const stats = {
+    bySpecialist: {
+      "merge-agent": 0,
+      "review-agent": 0,
+      "test-agent": 0
+    },
+    byType: {},
+    total: 0
+  };
+  if (!existsSync3(FEEDBACK_LOG)) {
+    return stats;
+  }
+  try {
+    const content = readFileSync3(FEEDBACK_LOG, "utf-8");
+    const lines = content.trim().split("\n").filter((l) => l.length > 0);
+    for (const line of lines) {
+      const feedback = JSON.parse(line);
+      stats.bySpecialist[feedback.fromSpecialist] = (stats.bySpecialist[feedback.fromSpecialist] || 0) + 1;
+      stats.byType[feedback.feedbackType] = (stats.byType[feedback.feedbackType] || 0) + 1;
+      stats.total++;
+    }
+  } catch (error) {
+    console.error(`[specialist] Failed to read feedback stats:`, error);
+  }
+  return stats;
+}
+var execAsync, SPECIALISTS_DIR, REGISTRY_FILE, TASKS_DIR, DEFAULT_SPECIALISTS, gracePeriodStates, FEEDBACK_DIR, FEEDBACK_LOG;
+var init_specialists = __esm({
+  "src/lib/cloister/specialists.ts"() {
+    init_esm_shims();
+    init_paths();
+    init_jsonl_parser();
+    init_specialist_handoff_logger();
+    init_work_type_router();
+    init_tmux();
+    init_hooks();
+    execAsync = promisify(exec);
+    SPECIALISTS_DIR = join4(PANOPTICON_HOME, "specialists");
+    REGISTRY_FILE = join4(SPECIALISTS_DIR, "registry.json");
+    TASKS_DIR = join4(SPECIALISTS_DIR, "tasks");
+    DEFAULT_SPECIALISTS = [
+      {
+        name: "merge-agent",
+        displayName: "Merge Agent",
+        description: "PR merging and conflict resolution",
+        enabled: true,
+        autoWake: true
+      },
+      {
+        name: "review-agent",
+        displayName: "Review Agent",
+        description: "Code review and quality checks",
+        enabled: true,
+        autoWake: true
+      },
+      {
+        name: "test-agent",
+        displayName: "Test Agent",
+        description: "Test execution and analysis",
+        enabled: true,
+        autoWake: true
+      }
+    ];
+    gracePeriodStates = /* @__PURE__ */ new Map();
+    FEEDBACK_DIR = join4(PANOPTICON_HOME, "specialists", "feedback");
+    FEEDBACK_LOG = join4(FEEDBACK_DIR, "feedback.jsonl");
+  }
+});
+
+// src/lib/cloister/specialist-logs.ts
+var specialist_logs_exports = {};
+__export(specialist_logs_exports, {
+  MAX_LOG_SIZE: () => MAX_LOG_SIZE,
+  appendToRunLog: () => appendToRunLog,
+  checkLogSizeLimit: () => checkLogSizeLimit,
+  cleanupAllLogs: () => cleanupAllLogs,
+  cleanupOldLogs: () => cleanupOldLogs,
+  createRunLog: () => createRunLog,
+  finalizeRunLog: () => finalizeRunLog,
+  generateRunId: () => generateRunId,
+  getRecentRunLogs: () => getRecentRunLogs,
+  getRunLog: () => getRunLog,
+  getRunLogPath: () => getRunLogPath,
+  getRunLogSize: () => getRunLogSize,
+  getRunsDirectory: () => getRunsDirectory,
+  isRunLogActive: () => isRunLogActive,
+  listRunLogs: () => listRunLogs,
+  parseLogMetadata: () => parseLogMetadata
+});
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, appendFileSync as appendFileSync3, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join5, basename as basename3 } from "path";
+function getRunsDirectory(projectKey, specialistType) {
+  return join5(SPECIALISTS_DIR2, projectKey, specialistType, "runs");
+}
+function generateRunId(issueId) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").substring(0, 19);
+  return `${timestamp}-${issueId}`;
+}
+function getRunLogPath(projectKey, specialistType, runId) {
+  const runsDir = getRunsDirectory(projectKey, specialistType);
+  return join5(runsDir, `${runId}.log`);
+}
+function ensureRunsDirectory(projectKey, specialistType) {
+  const runsDir = getRunsDirectory(projectKey, specialistType);
+  if (!existsSync4(runsDir)) {
+    mkdirSync3(runsDir, { recursive: true });
+  }
+}
+function createRunLog(projectKey, specialistType, issueId, contextSeed) {
+  ensureRunsDirectory(projectKey, specialistType);
+  const runId = generateRunId(issueId);
+  const filePath = getRunLogPath(projectKey, specialistType, runId);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const header = `# ${specialistType} Run - ${issueId}
+Project: ${projectKey}
+Started: ${startedAt}
+Issue: ${issueId}
+Run ID: ${runId}
+
+## Context Seed
+${contextSeed ? contextSeed : "[No context digest available]"}
+
+## Session Transcript
+`;
+  writeFileSync2(filePath, header, "utf-8");
+  return { runId, filePath };
+}
+function appendToRunLog(projectKey, specialistType, runId, content) {
+  const filePath = getRunLogPath(projectKey, specialistType, runId);
+  if (!existsSync4(filePath)) {
+    throw new Error(`Run log not found: ${filePath}`);
+  }
+  appendFileSync3(filePath, content, "utf-8");
+}
+function finalizeRunLog(projectKey, specialistType, runId, result) {
+  const filePath = getRunLogPath(projectKey, specialistType, runId);
+  if (!existsSync4(filePath)) {
+    throw new Error(`Run log not found: ${filePath}`);
+  }
+  const content = readFileSync4(filePath, "utf-8");
+  const startMatch = content.match(/^Started: (.+)$/m);
+  const startedAt = startMatch ? new Date(startMatch[1]) : /* @__PURE__ */ new Date();
+  const finishedAt = /* @__PURE__ */ new Date();
+  const duration = finishedAt.getTime() - startedAt.getTime();
+  const durationSeconds = Math.floor(duration / 1e3);
+  const minutes = Math.floor(durationSeconds / 60);
+  const seconds = durationSeconds % 60;
+  const durationStr = `${minutes}m ${seconds}s`;
+  const resultSection = `
+
+## Result
+Status: ${result.status}
+${result.notes ? `Notes: ${result.notes}` : ""}
+Duration: ${durationStr}
+Finished: ${finishedAt.toISOString()}
+`;
+  appendFileSync3(filePath, resultSection, "utf-8");
+}
+function getRunLog(projectKey, specialistType, runId) {
+  const filePath = getRunLogPath(projectKey, specialistType, runId);
+  if (!existsSync4(filePath)) {
+    return null;
+  }
+  try {
+    return readFileSync4(filePath, "utf-8");
+  } catch (error) {
+    console.error(`Failed to read run log ${runId}:`, error);
+    return null;
+  }
+}
+function parseLogMetadata(logContent) {
+  const metadata = {};
+  const projectMatch = logContent.match(/^Project: (.+)$/m);
+  const startedMatch = logContent.match(/^Started: (.+)$/m);
+  const issueMatch = logContent.match(/^Issue: (.+)$/m);
+  const runIdMatch = logContent.match(/^Run ID: (.+)$/m);
+  const statusMatch = logContent.match(/^Status: (.+)$/m);
+  const notesMatch = logContent.match(/^Notes: (.+)$/m);
+  const finishedMatch = logContent.match(/^Finished: (.+)$/m);
+  const durationMatch = logContent.match(/^Duration: (.+)$/m);
+  if (projectMatch) metadata.project = projectMatch[1].trim();
+  if (startedMatch) metadata.startedAt = startedMatch[1].trim();
+  if (issueMatch) metadata.issueId = issueMatch[1].trim();
+  if (runIdMatch) metadata.runId = runIdMatch[1].trim();
+  if (statusMatch) metadata.status = statusMatch[1].trim();
+  if (notesMatch) metadata.notes = notesMatch[1].trim();
+  if (finishedMatch) metadata.finishedAt = finishedMatch[1].trim();
+  if (durationMatch) {
+    const durationStr = durationMatch[1].trim();
+    const minutesMatch = durationStr.match(/(\d+)m/);
+    const secondsMatch = durationStr.match(/(\d+)s/);
+    const minutes = minutesMatch ? parseInt(minutesMatch[1], 10) : 0;
+    const seconds = secondsMatch ? parseInt(secondsMatch[1], 10) : 0;
+    metadata.duration = (minutes * 60 + seconds) * 1e3;
+  }
+  return metadata;
+}
+function listRunLogs(projectKey, specialistType, options = {}) {
+  const runsDir = getRunsDirectory(projectKey, specialistType);
+  if (!existsSync4(runsDir)) {
+    return [];
+  }
+  try {
+    const files = readdirSync3(runsDir).filter((f) => f.endsWith(".log")).map((f) => {
+      const filePath = join5(runsDir, f);
+      const stats = statSync2(filePath);
+      const runId = basename3(f, ".log");
+      const content = readFileSync4(filePath, "utf-8");
+      const metadata = parseLogMetadata(content);
+      return {
+        runId,
+        filePath,
+        metadata: {
+          runId,
+          project: projectKey,
+          specialistType,
+          issueId: metadata.issueId || "unknown",
+          startedAt: metadata.startedAt || stats.birthtime.toISOString(),
+          finishedAt: metadata.finishedAt,
+          status: metadata.status,
+          duration: metadata.duration,
+          notes: metadata.notes
+        },
+        fileSize: stats.size,
+        createdAt: stats.birthtime
+      };
+    });
+    files.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    const { limit, offset = 0 } = options;
+    if (limit !== void 0) {
+      return files.slice(offset, offset + limit);
+    }
+    return files.slice(offset);
+  } catch (error) {
+    console.error(`Failed to list run logs for ${projectKey}/${specialistType}:`, error);
+    return [];
+  }
+}
+function getRecentRunLogs(projectKey, specialistType, count) {
+  return listRunLogs(projectKey, specialistType, { limit: count });
+}
+function cleanupOldLogs(projectKey, specialistType, retention) {
+  const { maxDays, maxRuns } = retention;
+  const allLogs = listRunLogs(projectKey, specialistType);
+  if (allLogs.length === 0) {
+    return 0;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const cutoffDate = new Date(now.getTime() - maxDays * 24 * 60 * 60 * 1e3);
+  let deletedCount = 0;
+  allLogs.forEach((log, index) => {
+    if (index < maxRuns) {
+      return;
+    }
+    if (log.createdAt >= cutoffDate) {
+      return;
+    }
+    try {
+      unlinkSync2(log.filePath);
+      deletedCount++;
+      console.log(`[specialist-logs] Deleted old log: ${log.runId}`);
+    } catch (error) {
+      console.error(`[specialist-logs] Failed to delete ${log.runId}:`, error);
+    }
+  });
+  return deletedCount;
+}
+function isRunLogActive(projectKey, specialistType, runId) {
+  const content = getRunLog(projectKey, specialistType, runId);
+  if (!content) {
+    return false;
+  }
+  return !content.includes("## Result");
+}
+function getRunLogSize(projectKey, specialistType, runId) {
+  const filePath = getRunLogPath(projectKey, specialistType, runId);
+  if (!existsSync4(filePath)) {
+    return null;
+  }
+  try {
+    const stats = statSync2(filePath);
+    return stats.size;
+  } catch (error) {
+    return null;
+  }
+}
+function checkLogSizeLimit(projectKey, specialistType, runId) {
+  const size = getRunLogSize(projectKey, specialistType, runId);
+  if (size === null) {
+    return null;
+  }
+  if (size >= MAX_LOG_SIZE) {
+    return {
+      exceeded: true,
+      size,
+      limit: MAX_LOG_SIZE
+    };
+  }
+  return null;
+}
+function cleanupAllLogs() {
+  const { listProjectsWithSpecialists: listProjectsWithSpecialists2 } = (init_specialists(), __toCommonJS(specialists_exports));
+  const { getSpecialistRetention } = (init_projects(), __toCommonJS(projects_exports));
+  const results = {
+    totalDeleted: 0,
+    byProject: {}
+  };
+  const projects = listProjectsWithSpecialists2();
+  for (const projectKey of projects) {
+    results.byProject[projectKey] = {};
+    const retention = getSpecialistRetention(projectKey);
+    const specialistTypes = ["review-agent", "test-agent", "merge-agent"];
+    for (const specialistType of specialistTypes) {
+      const deleted = cleanupOldLogs(projectKey, specialistType, retention);
+      if (deleted > 0) {
+        results.byProject[projectKey][specialistType] = deleted;
+        results.totalDeleted += deleted;
+      }
+    }
+  }
+  console.log(`[specialist-logs] Cleanup complete: deleted ${results.totalDeleted} old logs`);
+  return results;
+}
+var SPECIALISTS_DIR2, MAX_LOG_SIZE;
+var init_specialist_logs = __esm({
+  "src/lib/cloister/specialist-logs.ts"() {
+    init_esm_shims();
+    init_paths();
+    SPECIALISTS_DIR2 = join5(PANOPTICON_HOME, "specialists");
+    MAX_LOG_SIZE = 10 * 1024 * 1024;
+  }
+});
+
+export {
+  getProjectDirs,
+  getSessionFiles,
+  parseClaudeSession,
+  init_jsonl_parser,
+  getRunsDirectory,
+  generateRunId,
+  getRunLogPath,
+  createRunLog,
+  appendToRunLog,
+  finalizeRunLog,
+  getRunLog,
+  parseLogMetadata,
+  listRunLogs,
+  getRecentRunLogs,
+  cleanupOldLogs,
+  isRunLogActive,
+  getRunLogSize,
+  MAX_LOG_SIZE,
+  checkLogSizeLimit,
+  cleanupAllLogs,
+  init_specialist_logs,
+  initSpecialistsDirectory,
+  loadRegistry,
+  saveRegistry,
+  getSessionFilePath,
+  getSessionId,
+  setSessionId,
+  clearSessionId,
+  getSpecialistMetadata,
+  updateSpecialistMetadata,
+  getAllSpecialists,
+  isInitialized,
+  getSpecialistState,
+  getTmuxSessionName,
+  recordWake,
+  spawnEphemeralSpecialist,
+  startGracePeriod,
+  pauseGracePeriod,
+  resumeGracePeriod,
+  exitGracePeriod,
+  getGracePeriodState,
+  signalSpecialistCompletion,
+  terminateSpecialist,
+  getProjectSpecialistDir,
+  ensureProjectSpecialistDir,
+  getProjectSpecialistMetadata,
+  updateProjectSpecialistMetadata,
+  incrementProjectRunCount,
+  setCurrentRun,
+  updateRunStatus,
+  listProjectsWithSpecialists,
+  listSpecialistsForProject,
+  getAllProjectSpecialistStatuses,
+  updateContextTokens,
+  listSessionFiles,
+  enableSpecialist,
+  disableSpecialist,
+  isEnabled,
+  getEnabledSpecialists,
+  findSessionFile,
+  countContextTokens,
+  isRunning,
+  getSpecialistStatus,
+  getAllSpecialistStatus,
+  initializeSpecialist,
+  initializeEnabledSpecialists,
+  wakeSpecialist,
+  wakeSpecialistWithTask,
+  wakeSpecialistOrQueue,
+  submitToSpecialistQueue,
+  checkSpecialistQueue,
+  completeSpecialistTask,
+  getNextSpecialistTask,
+  sendFeedbackToAgent,
+  getPendingFeedback,
+  getFeedbackStats,
+  init_specialists
+};
+//# sourceMappingURL=chunk-VTDDVLCK.js.map