panopticon-cli 0.5.1 → 0.5.3

package/dist/{chunk-OWHXCGVO.js → chunk-2V2DQ3IX.js}

@@ -10,7 +10,7 @@ import {
   pushToHook,
   sendKeysAsync,
   waitForClaudePrompt
-} from "./chunk-FTCPTHIJ.js";
+} from "./chunk-HRU7S4TA.js";
 import {
   init_pipeline_notifier,
   notifyPipeline
@@ -23,11 +23,11 @@ import {
   init_settings,
   loadSettings,
   setupCredentialFileAuth
-} from "./chunk-HJSM6E6U.js";
+} from "./chunk-USYP2SBE.js";
 import {
   init_projects,
   projects_exports
-} from "./chunk-2V4NF7J2.js";
+} from "./chunk-RLZQB7HS.js";
 import {
   COSTS_DIR,
   PANOPTICON_HOME,
@@ -42,6 +42,7 @@ import {
 } from "./chunk-ZHC57RCV.js";
 
 // src/lib/cost.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "fs";
 import { join } from "path";
 function calculateCost(usage, pricing) {
   let cost = 0;
@@ -77,6 +78,218 @@ function getPricing(provider, model) {
   }
   return pricing || null;
 }
+function getCostFile(date) {
+  return join(COSTS_DIR, `costs-${date}.jsonl`);
+}
+function getCurrentDateString() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function readCosts(startDate, endDate) {
+  const entries = [];
+  const start = new Date(startDate);
+  const end = new Date(endDate);
+  for (let date = start; date <= end; date.setDate(date.getDate() + 1)) {
+    const dateStr = date.toISOString().split("T")[0];
+    const costFile = getCostFile(dateStr);
+    if (existsSync(costFile)) {
+      const content = readFileSync(costFile, "utf-8");
+      const lines = content.split("\n").filter((line) => line.trim());
+      for (const line of lines) {
+        try {
+          entries.push(JSON.parse(line));
+        } catch {
+        }
+      }
+    }
+  }
+  return entries;
+}
+function readTodayCosts() {
+  const today = getCurrentDateString();
+  return readCosts(today, today);
+}
+function readIssueCosts(issueId, days = 30) {
+  const end = /* @__PURE__ */ new Date();
+  const start = /* @__PURE__ */ new Date();
+  start.setDate(start.getDate() - days);
+  const allCosts = readCosts(
+    start.toISOString().split("T")[0],
+    end.toISOString().split("T")[0]
+  );
+  return allCosts.filter((entry) => entry.issueId === issueId);
+}
+function summarizeCosts(entries) {
+  const summary = {
+    totalCost: 0,
+    currency: "USD",
+    period: {
+      start: entries[0]?.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      end: entries[entries.length - 1]?.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+    },
+    byProvider: {},
+    byModel: {},
+    byIssue: {},
+    byFeature: {},
+    entryCount: entries.length,
+    totalTokens: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      total: 0
+    }
+  };
+  for (const entry of entries) {
+    summary.totalCost += entry.cost;
+    summary.byProvider[entry.provider] = (summary.byProvider[entry.provider] || 0) + entry.cost;
+    summary.byModel[entry.model] = (summary.byModel[entry.model] || 0) + entry.cost;
+    if (entry.issueId) {
+      summary.byIssue[entry.issueId] = (summary.byIssue[entry.issueId] || 0) + entry.cost;
+    }
+    if (entry.featureId) {
+      summary.byFeature[entry.featureId] = (summary.byFeature[entry.featureId] || 0) + entry.cost;
+    }
+    summary.totalTokens.input += entry.usage.inputTokens;
+    summary.totalTokens.output += entry.usage.outputTokens;
+    summary.totalTokens.cacheRead += entry.usage.cacheReadTokens || 0;
+    summary.totalTokens.cacheWrite += entry.usage.cacheWriteTokens || 0;
+  }
+  summary.totalTokens.total = summary.totalTokens.input + summary.totalTokens.output + summary.totalTokens.cacheRead + summary.totalTokens.cacheWrite;
+  summary.totalCost = Math.round(summary.totalCost * 100) / 100;
+  return summary;
+}
+function getDailySummary(date) {
+  const targetDate = date || getCurrentDateString();
+  const entries = readCosts(targetDate, targetDate);
+  return summarizeCosts(entries);
+}
+function getWeeklySummary() {
+  const end = /* @__PURE__ */ new Date();
+  const start = /* @__PURE__ */ new Date();
+  start.setDate(start.getDate() - 7);
+  const entries = readCosts(
+    start.toISOString().split("T")[0],
+    end.toISOString().split("T")[0]
+  );
+  return summarizeCosts(entries);
+}
+function getMonthlySummary() {
+  const end = /* @__PURE__ */ new Date();
+  const start = /* @__PURE__ */ new Date();
+  start.setDate(start.getDate() - 30);
+  const entries = readCosts(
+    start.toISOString().split("T")[0],
+    end.toISOString().split("T")[0]
+  );
+  return summarizeCosts(entries);
+}
+function loadBudgets() {
+  if (!existsSync(BUDGETS_FILE)) {
+    return [];
+  }
+  try {
+    const content = readFileSync(BUDGETS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+function saveBudgets(budgets) {
+  mkdirSync(COSTS_DIR, { recursive: true });
+  writeFileSync(BUDGETS_FILE, JSON.stringify(budgets, null, 2));
+}
+function createBudget(budget) {
+  const budgets = loadBudgets();
+  const newBudget = {
+    ...budget,
+    id: `budget-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    spent: 0
+  };
+  budgets.push(newBudget);
+  saveBudgets(budgets);
+  return newBudget;
+}
+function getBudget(id) {
+  const budgets = loadBudgets();
+  return budgets.find((b) => b.id === id) || null;
+}
+function getAllBudgets() {
+  return loadBudgets();
+}
+function checkBudget(id) {
+  const budget = getBudget(id);
+  if (!budget) {
+    return {
+      budget: null,
+      remaining: 0,
+      percentUsed: 0,
+      exceeded: false,
+      alert: false
+    };
+  }
+  const remaining = budget.limit - budget.spent;
+  const percentUsed = budget.spent / budget.limit;
+  return {
+    budget,
+    remaining,
+    percentUsed,
+    exceeded: percentUsed >= 1,
+    alert: percentUsed >= budget.alertThreshold
+  };
+}
+function deleteBudget(id) {
+  const budgets = loadBudgets();
+  const index = budgets.findIndex((b) => b.id === id);
+  if (index === -1) return false;
+  budgets.splice(index, 1);
+  saveBudgets(budgets);
+  return true;
+}
+function generateReport(startDate, endDate) {
+  const entries = readCosts(startDate, endDate);
+  const summary = summarizeCosts(entries);
+  const lines = [
+    "# Cost Report",
+    "",
+    `**Period:** ${startDate} to ${endDate}`,
+    "",
+    "## Summary",
+    "",
+    `- **Total Cost:** $${summary.totalCost.toFixed(2)}`,
+    `- **Total Entries:** ${summary.entryCount}`,
+    `- **Total Tokens:** ${summary.totalTokens.total.toLocaleString()}`,
+    `  - Input: ${summary.totalTokens.input.toLocaleString()}`,
+    `  - Output: ${summary.totalTokens.output.toLocaleString()}`,
+    "",
+    "## By Provider",
+    ""
+  ];
+  for (const [provider, cost] of Object.entries(summary.byProvider)) {
+    lines.push(`- **${provider}:** $${cost.toFixed(2)}`);
+  }
+  lines.push("");
+  lines.push("## By Model");
+  lines.push("");
+  for (const [model, cost] of Object.entries(summary.byModel)) {
+    lines.push(`- **${model}:** $${cost.toFixed(2)}`);
+  }
+  if (Object.keys(summary.byIssue).length > 0) {
+    lines.push("");
+    lines.push("## By Issue");
+    lines.push("");
+    const sortedIssues = Object.entries(summary.byIssue).sort(([, a], [, b]) => b - a);
+    for (const [issue, cost] of sortedIssues.slice(0, 10)) {
+      lines.push(`- **${issue}:** $${cost.toFixed(2)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatCost(cost, currency = "USD") {
+  if (currency === "USD") {
+    return `$${cost.toFixed(4)}`;
+  }
+  return `${cost.toFixed(4)} ${currency}`;
+}
 var DEFAULT_PRICING, BUDGETS_FILE;
 var init_cost = __esm({
   "src/lib/cost.ts"() {
@@ -110,14 +323,14 @@ var init_cost = __esm({
 });
 
 // src/lib/cost-parsers/jsonl-parser.ts
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync } from "fs";
 import { join as join2, basename } from "path";
 import { homedir } from "os";
 function getProjectDirs() {
-  if (!existsSync(CLAUDE_PROJECTS_DIR)) {
+  if (!existsSync2(CLAUDE_PROJECTS_DIR)) {
     return [];
   }
-  return readdirSync(CLAUDE_PROJECTS_DIR).map((name) => join2(CLAUDE_PROJECTS_DIR, name)).filter((path) => {
+  return readdirSync2(CLAUDE_PROJECTS_DIR).map((name) => join2(CLAUDE_PROJECTS_DIR, name)).filter((path) => {
     try {
       return statSync(path).isDirectory();
     } catch {
@@ -126,10 +339,10 @@ function getProjectDirs() {
   });
 }
 function getSessionFiles(projectDir) {
-  if (!existsSync(projectDir)) {
+  if (!existsSync2(projectDir)) {
     return [];
   }
-  return readdirSync(projectDir).filter((name) => name.endsWith(".jsonl")).map((name) => join2(projectDir, name)).sort((a, b) => {
+  return readdirSync2(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 {
@@ -183,10 +396,10 @@ function normalizeModelName(model) {
   return { provider: "anthropic", model: "claude-sonnet-4" };
 }
 function parseClaudeSession(sessionFile) {
-  if (!existsSync(sessionFile)) {
+  if (!existsSync2(sessionFile)) {
     return null;
   }
-  const content = readFileSync(sessionFile, "utf-8");
+  const content = readFileSync2(sessionFile, "utf-8");
   const lines = content.split("\n").filter((line) => line.trim());
   let sessionId = "";
   let startTime = "";
@@ -297,18 +510,18 @@ var init_jsonl_parser = __esm({
 });
 
 // src/lib/cloister/specialist-handoff-logger.ts
-import { existsSync as existsSync2, mkdirSync, appendFileSync, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, appendFileSync as appendFileSync2, readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
 function ensureLogDir() {
   const logDir = join3(PANOPTICON_HOME, "logs");
-  if (!existsSync2(logDir)) {
-    mkdirSync(logDir, { recursive: true });
+  if (!existsSync3(logDir)) {
+    mkdirSync2(logDir, { recursive: true });
   }
 }
 function logSpecialistHandoff(event) {
   ensureLogDir();
   const line = JSON.stringify(event) + "\n";
-  appendFileSync(SPECIALIST_HANDOFF_LOG_FILE, line, "utf-8");
+  appendFileSync2(SPECIALIST_HANDOFF_LOG_FILE, line, "utf-8");
 }
 function createSpecialistHandoff(fromSpecialist, toSpecialist, issueId, priority, context) {
   return {
@@ -391,7 +604,7 @@ __export(specialists_exports, {
   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 { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync3, unlinkSync, appendFileSync as appendFileSync3 } from "fs";
 import { join as join4, basename as basename2 } from "path";
 import { homedir as homedir2 } from "os";
 import { exec } from "child_process";
@@ -403,13 +616,13 @@ async function resolveWorkspaceGitInfo(workspace, taskBranch) {
   if (!workspace || workspace === "unknown") {
     return { gitDirs, branch, isPolyrepo: false };
   }
-  if (existsSync3(join4(workspace, ".git"))) {
+  if (existsSync4(join4(workspace, ".git"))) {
     gitDirs.push(workspace);
   } else {
     try {
-      const entries = readdirSync2(workspace, { withFileTypes: true });
+      const entries = readdirSync3(workspace, { withFileTypes: true });
       for (const entry of entries) {
-        if (entry.isDirectory() && existsSync3(join4(workspace, entry.name, ".git"))) {
+        if (entry.isDirectory() && existsSync4(join4(workspace, entry.name, ".git"))) {
           gitDirs.push(join4(workspace, entry.name));
         }
       }
@@ -450,10 +663,10 @@ function buildTmuxEnvFlags(env) {
   return flags;
 }
 function initSpecialistsDirectory() {
-  if (!existsSync3(SPECIALISTS_DIR)) {
-    mkdirSync2(SPECIALISTS_DIR, { recursive: true });
+  if (!existsSync4(SPECIALISTS_DIR)) {
+    mkdirSync3(SPECIALISTS_DIR, { recursive: true });
   }
-  if (!existsSync3(REGISTRY_FILE)) {
+  if (!existsSync4(REGISTRY_FILE)) {
     const registry = {
       version: "2.0",
       // Updated for per-project structure
@@ -477,7 +690,7 @@ function initSpecialistsDirectory() {
 }
 function migrateRegistryIfNeeded() {
   try {
-    const content = readFileSync3(REGISTRY_FILE, "utf-8");
+    const content = readFileSync4(REGISTRY_FILE, "utf-8");
     const registry = JSON.parse(content);
     if (registry.version === "2.0" || registry.projects) {
       return;
@@ -507,7 +720,7 @@ function migrateRegistryIfNeeded() {
 function loadRegistry() {
   initSpecialistsDirectory();
   try {
-    const content = readFileSync3(REGISTRY_FILE, "utf-8");
+    const content = readFileSync4(REGISTRY_FILE, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     console.error("Failed to load specialist registry:", error);
@@ -525,53 +738,59 @@ function loadRegistry() {
   }
 }
 function saveRegistry(registry) {
-  if (!existsSync3(SPECIALISTS_DIR)) {
-    mkdirSync2(SPECIALISTS_DIR, { recursive: true });
+  if (!existsSync4(SPECIALISTS_DIR)) {
+    mkdirSync3(SPECIALISTS_DIR, { recursive: true });
   }
   registry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   try {
     const content = JSON.stringify(registry, null, 2);
-    writeFileSync(REGISTRY_FILE, content, "utf-8");
+    writeFileSync2(REGISTRY_FILE, content, "utf-8");
   } catch (error) {
     console.error("Failed to save specialist registry:", error);
     throw error;
   }
 }
-function getSessionFilePath(name) {
+function getSessionFilePath(name, projectKey) {
+  if (projectKey) {
+    return join4(SPECIALISTS_DIR, "projects", projectKey, `${name}.session`);
+  }
   return join4(SPECIALISTS_DIR, `${name}.session`);
 }
-function getSessionId(name) {
-  const sessionFile = getSessionFilePath(name);
-  if (!existsSync3(sessionFile)) {
+function getSessionId(name, projectKey) {
+  const sessionFile = getSessionFilePath(name, projectKey);
+  if (!existsSync4(sessionFile)) {
     return null;
   }
   try {
-    return readFileSync3(sessionFile, "utf-8").trim();
+    return readFileSync4(sessionFile, "utf-8").trim();
   } catch (error) {
-    console.error(`Failed to read session file for ${name}:`, error);
+    console.error(`Failed to read session file for ${name} (${projectKey ?? "global"}):`, error);
     return null;
   }
 }
-function setSessionId(name, sessionId) {
-  initSpecialistsDirectory();
-  const sessionFile = getSessionFilePath(name);
+function setSessionId(name, sessionId, projectKey) {
+  const sessionFile = getSessionFilePath(name, projectKey);
+  const dir = projectKey ? join4(SPECIALISTS_DIR, "projects", projectKey) : SPECIALISTS_DIR;
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
   try {
-    writeFileSync(sessionFile, sessionId.trim(), "utf-8");
+    writeFileSync2(sessionFile, sessionId.trim(), "utf-8");
   } catch (error) {
-    console.error(`Failed to write session file for ${name}:`, error);
+    console.error(`Failed to write session file for ${name} (${projectKey ?? "global"}):`, error);
     throw error;
   }
 }
-function clearSessionId(name) {
-  const sessionFile = getSessionFilePath(name);
-  if (!existsSync3(sessionFile)) {
+function clearSessionId(name, projectKey) {
+  const sessionFile = getSessionFilePath(name, projectKey);
+  if (!existsSync4(sessionFile)) {
     return false;
   }
   try {
     unlinkSync(sessionFile);
     return true;
   } catch (error) {
-    console.error(`Failed to delete session file for ${name}:`, error);
+    console.error(`Failed to delete session file for ${name} (${projectKey ?? "global"}):`, error);
     throw error;
   }
 }
@@ -622,9 +841,9 @@ function recordWake(name, sessionId) {
 }
 async function spawnEphemeralSpecialist(projectKey, specialistType, task) {
   ensureProjectSpecialistDir(projectKey, specialistType);
-  const { loadContextDigest } = await import("./specialist-context-WGUUYDWY.js");
+  const { loadContextDigest } = await import("./specialist-context-53AWO6AE.js");
   const contextDigest = loadContextDigest(projectKey, specialistType);
-  const { createRunLog: createRunLog2 } = await import("./specialist-logs-XJB5TCKJ.js");
+  const { createRunLog: createRunLog2 } = await import("./specialist-logs-QREUJ4HN.js");
   const { runId, filePath: logFilePath } = createRunLog2(
     projectKey,
     specialistType,
@@ -633,10 +852,31 @@ async function spawnEphemeralSpecialist(projectKey, specialistType, task) {
   );
   setCurrentRun(projectKey, specialistType, runId);
   incrementProjectRunCount(projectKey, specialistType);
-  const taskPrompt = await buildTaskPrompt(projectKey, specialistType, task, contextDigest);
+  const taskPrompt = task.promptOverride ?? await buildTaskPrompt(projectKey, specialistType, task, contextDigest);
+  if (task.promptOverride) {
+    console.log(`[specialist] Using promptOverride for ${projectKey}/${task.issueId} (${taskPrompt.length} chars)`);
+  }
   const tmuxSession = getTmuxSessionName(specialistType, projectKey);
-  const cwd = process.env.HOME || "/home/exedev";
+  const cwd = homedir2();
   try {
+    try {
+      const { stdout: sessions } = await execAsync('tmux list-sessions -F "#{session_name}" 2>/dev/null || echo ""', { encoding: "utf-8" });
+      if (sessions.split("\n").map((s) => s.trim()).includes(tmuxSession)) {
+        const { getAgentRuntimeState } = await import("./agents-DMPT32H7.js");
+        const existingState = getAgentRuntimeState(tmuxSession);
+        if (existingState?.state === "active") {
+          return {
+            success: false,
+            message: `Specialist ${specialistType} (${projectKey}) is already running task ${existingState.currentIssue ?? "unknown"}`,
+            error: "specialist_busy"
+          };
+        }
+        console.log(`[specialist] Killing stale ${tmuxSession} session before respawn`);
+        await execAsync(`tmux kill-session -t "${tmuxSession}"`, { encoding: "utf-8" }).catch(() => {
+        });
+      }
+    } catch {
+    }
     let model = "claude-sonnet-4-6";
     try {
       const workTypeId = `specialist-${specialistType}`;
@@ -656,9 +896,9 @@ async function spawnEphemeralSpecialist(projectKey, specialistType, task) {
     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);
+    writeFileSync2(promptFile, taskPrompt);
     const launcherScript = join4(agentDir, "launcher.sh");
-    writeFileSync(launcherScript, `#!/bin/bash
+    writeFileSync2(launcherScript, `#!/bin/bash
 cd "${cwd}"
 prompt=$(cat "${promptFile}")
 
@@ -673,7 +913,7 @@ echo "## Specialist completed task"
       `tmux new-session -d -s "${tmuxSession}"${envFlags} "bash '${launcherScript}'"`,
       { encoding: "utf-8" }
     );
-    const { saveAgentRuntimeState } = await import("./agents-5OPQKM5K.js");
+    const { saveAgentRuntimeState } = await import("./agents-DMPT32H7.js");
     saveAgentRuntimeState(tmuxSession, {
       state: "active",
       lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -697,7 +937,7 @@ echo "## Specialist completed task"
   }
 }
 async function buildTaskPrompt(projectKey, specialistType, task, contextDigest) {
-  const { getSpecialistPromptOverride } = await import("./projects-CFX3RTDL.js");
+  const { getSpecialistPromptOverride } = await import("./projects-KVM3MN3Y.js");
   const customPrompt = getSpecialistPromptOverride(projectKey, specialistType);
   let prompt = `# ${specialistType} Task - ${task.issueId}
 
@@ -867,7 +1107,7 @@ async function terminateSpecialist(projectKey, specialistType) {
     console.error(`[specialist] Failed to kill tmux session ${tmuxSession}:`, error);
   }
   if (metadata.currentRun) {
-    const { finalizeRunLog: finalizeRunLog2 } = await import("./specialist-logs-XJB5TCKJ.js");
+    const { finalizeRunLog: finalizeRunLog2 } = await import("./specialist-logs-QREUJ4HN.js");
     try {
       finalizeRunLog2(projectKey, specialistType, metadata.currentRun, {
         status: metadata.lastRunStatus || "incomplete",
@@ -880,20 +1120,20 @@ async function terminateSpecialist(projectKey, specialistType) {
   }
   const key = `${projectKey}-${specialistType}`;
   gracePeriodStates.delete(key);
-  const { saveAgentRuntimeState } = await import("./agents-5OPQKM5K.js");
+  const { saveAgentRuntimeState } = await import("./agents-DMPT32H7.js");
   saveAgentRuntimeState(tmuxSession, {
     state: "suspended",
     lastActivity: (/* @__PURE__ */ new Date()).toISOString()
   });
-  const { scheduleDigestGeneration } = await import("./specialist-context-WGUUYDWY.js");
+  const { scheduleDigestGeneration } = await import("./specialist-context-53AWO6AE.js");
   scheduleDigestGeneration(projectKey, specialistType);
   scheduleLogCleanup(projectKey, specialistType);
 }
 function scheduleLogCleanup(projectKey, specialistType) {
   Promise.resolve().then(async () => {
     try {
-      const { cleanupOldLogs: cleanupOldLogs2 } = await import("./specialist-logs-XJB5TCKJ.js");
-      const { getSpecialistRetention } = await import("./projects-CFX3RTDL.js");
+      const { cleanupOldLogs: cleanupOldLogs2 } = await import("./specialist-logs-QREUJ4HN.js");
+      const { getSpecialistRetention } = await import("./projects-KVM3MN3Y.js");
       const retention = getSpecialistRetention(projectKey);
       const deleted = cleanupOldLogs2(projectKey, specialistType, { maxDays: retention.max_days, maxRuns: retention.max_runs });
       if (deleted > 0) {
@@ -911,11 +1151,11 @@ 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 (!existsSync4(runsDir)) {
+    mkdirSync3(runsDir, { recursive: true });
   }
-  if (!existsSync3(contextDir)) {
-    mkdirSync2(contextDir, { recursive: true });
+  if (!existsSync4(contextDir)) {
+    mkdirSync3(contextDir, { recursive: true });
   }
 }
 function getProjectSpecialistMetadata(projectKey, specialistType) {
@@ -1002,7 +1242,7 @@ function updateContextTokens(name, tokens) {
 function listSessionFiles() {
   initSpecialistsDirectory();
   try {
-    const files = readdirSync2(SPECIALISTS_DIR);
+    const files = readdirSync3(SPECIALISTS_DIR);
     const sessionFiles = files.filter((f) => f.endsWith(".session"));
     return sessionFiles.map((f) => f.replace(".session", ""));
   } catch (error) {
@@ -1055,7 +1295,17 @@ async function isRunning(name, projectKey) {
   const tmuxSession = getTmuxSessionName(name, projectKey);
   try {
     await execAsync(`tmux has-session -t ${tmuxSession}`);
-    return true;
+    const { stdout } = await execAsync(
+      `tmux list-panes -t ${tmuxSession} -F "#{pane_pid}" 2>/dev/null`,
+      { encoding: "utf-8" }
+    );
+    const panePid = stdout.trim();
+    if (!panePid) return false;
+    const { stdout: children } = await execAsync(
+      `ps --ppid ${panePid} --no-headers 2>/dev/null || echo ""`,
+      { encoding: "utf-8" }
+    );
+    return children.trim().length > 0;
   } catch {
     return false;
   }
@@ -1068,10 +1318,10 @@ async function getSpecialistStatus(name, projectKey) {
     enabled: false,
     autoWake: false
   };
-  const sessionId = getSessionId(name);
+  const sessionId = getSessionId(name, projectKey);
   const running = await isRunning(name, projectKey);
   const contextTokens = countContextTokens(name);
-  const { getAgentRuntimeState } = await import("./agents-5OPQKM5K.js");
+  const { getAgentRuntimeState } = await import("./agents-DMPT32H7.js");
   const tmuxSession = getTmuxSessionName(name, projectKey);
   const runtimeState = getAgentRuntimeState(tmuxSession);
   let state;
@@ -1156,9 +1406,9 @@ Say: "I am the ${name} specialist, ready and waiting for tasks."`;
     await execAsync(`mkdir -p "${agentDir}"`, { encoding: "utf-8" });
     const promptFile = join4(agentDir, "identity-prompt.md");
     const launcherScript = join4(agentDir, "launcher.sh");
-    writeFileSync(promptFile, identityPrompt);
+    writeFileSync2(promptFile, identityPrompt);
     const newSessionId = randomUUID();
-    writeFileSync(launcherScript, `#!/bin/bash
+    writeFileSync2(launcherScript, `#!/bin/bash
 cd "${cwd}"
 prompt=$(cat "${promptFile}")
 exec claude --dangerously-skip-permissions --session-id "${newSessionId}" --model ${model} "$prompt"
@@ -1225,6 +1475,20 @@ async function wakeSpecialist(name, taskPrompt, options = {}) {
   const tmuxSession = getTmuxSessionName(name);
   const sessionId = getSessionId(name);
   const wasAlreadyRunning = await isRunning(name);
+  if (wasAlreadyRunning && !options.skipBusyGuard) {
+    const { getAgentRuntimeState } = await import("./agents-DMPT32H7.js");
+    const runtimeState = getAgentRuntimeState(tmuxSession);
+    if (runtimeState?.state === "active") {
+      console.warn(`[specialist] ${name} is busy (working on ${runtimeState.currentIssue}), refusing to interrupt`);
+      return {
+        success: false,
+        message: `Specialist ${name} is busy (working on ${runtimeState.currentIssue}). Use wakeSpecialistOrQueue() instead.`,
+        tmuxSession,
+        wasAlreadyRunning: true,
+        error: "specialist_busy"
+      };
+    }
+  }
   if (!wasAlreadyRunning) {
     if (!startIfNotRunning) {
       return {
@@ -1290,11 +1554,11 @@ async function wakeSpecialist(name, taskPrompt, options = {}) {
     const isLargePrompt = taskPrompt.length > 500 || taskPrompt.includes("\n");
     let messageToSend;
     if (isLargePrompt) {
-      if (!existsSync3(TASKS_DIR)) {
-        mkdirSync2(TASKS_DIR, { recursive: true });
+      if (!existsSync4(TASKS_DIR)) {
+        mkdirSync3(TASKS_DIR, { recursive: true });
       }
       const taskFile = join4(TASKS_DIR, `${name}-${Date.now()}.md`);
-      writeFileSync(taskFile, taskPrompt, "utf-8");
+      writeFileSync2(taskFile, taskPrompt, "utf-8");
       messageToSend = `Read and execute the task in: ${taskFile}`;
     } else {
       messageToSend = taskPrompt;
@@ -1318,7 +1582,7 @@ async function wakeSpecialist(name, taskPrompt, options = {}) {
       }
     }
     recordWake(name, sessionId || void 0);
-    const { saveAgentRuntimeState } = await import("./agents-5OPQKM5K.js");
+    const { saveAgentRuntimeState } = await import("./agents-DMPT32H7.js");
     saveAgentRuntimeState(tmuxSession, {
       state: "active",
       lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1341,7 +1605,7 @@ async function wakeSpecialist(name, taskPrompt, options = {}) {
     };
   }
 }
-async function wakeSpecialistWithTask(name, task) {
+async function wakeSpecialistWithTask(name, task, options = {}) {
   const apiPort = process.env.API_PORT || process.env.PORT || "3011";
   const apiUrl = process.env.DASHBOARD_URL || `http://localhost:${apiPort}`;
   let prompt;
@@ -1420,14 +1684,14 @@ CRITICAL: Do NOT delete the feature branch.`;
           if (totalChangedFiles === 0) {
             staleBranch = true;
             console.log(`[specialist] review-agent: stale branch detected for ${task.issueId} \u2014 0 files changed vs main`);
-            const { setReviewStatus } = await import("./review-status-TDPSOU5J.js");
+            const { setReviewStatus } = await import("./review-status-XKUKZF6J.js");
             setReviewStatus(task.issueId.toUpperCase(), {
               reviewStatus: "passed",
               reviewNotes: "No changes to review \u2014 branch identical to main (already merged or stale)"
             });
             console.log(`[specialist] review-agent: auto-passed ${task.issueId} (stale branch)`);
             const tmuxSession = getTmuxSessionName("review-agent");
-            const { saveAgentRuntimeState } = await import("./agents-5OPQKM5K.js");
+            const { saveAgentRuntimeState } = await import("./agents-DMPT32H7.js");
             saveAgentRuntimeState(tmuxSession, {
               state: "idle",
               lastActivity: (/* @__PURE__ */ new Date()).toISOString()
@@ -1532,7 +1796,7 @@ curl -s -X POST ${apiUrl}/api/specialists/test-agent/queue -H "Content-Type: app
       const testWorkspace = task.workspace || "unknown";
       const testGitInfo = await resolveWorkspaceGitInfo(task.workspace, task.branch);
       const testIsPolyrepo = testGitInfo.isPolyrepo;
-      const { extractTeamPrefix, findProjectByTeam } = await import("./projects-CFX3RTDL.js");
+      const { extractTeamPrefix, findProjectByTeam } = await import("./projects-KVM3MN3Y.js");
       const testTeamPrefix = extractTeamPrefix(task.issueId);
       const testProjectConfig = testTeamPrefix ? findProjectByTeam(testTeamPrefix) : null;
       const testConfigs = testProjectConfig?.tests;
@@ -1666,12 +1930,12 @@ IMPORTANT: Do NOT hand off to merge-agent. Human clicks Merge button when ready.
     default:
       prompt = `Task for ${task.issueId}: Please process this task and report findings.`;
   }
-  return wakeSpecialist(name, prompt, { issueId: task.issueId });
+  return wakeSpecialist(name, prompt, { issueId: task.issueId, skipBusyGuard: options.skipBusyGuard });
 }
 async function wakeSpecialistOrQueue(name, task, options = {}) {
   const { priority = "normal", source = "handoff" } = options;
   const running = await isRunning(name);
-  const { getAgentRuntimeState } = await import("./agents-5OPQKM5K.js");
+  const { getAgentRuntimeState } = await import("./agents-DMPT32H7.js");
   const tmuxSession = getTmuxSessionName(name);
   const runtimeState = getAgentRuntimeState(tmuxSession);
   const idle = runtimeState?.state === "idle" || runtimeState?.state === "suspended";
@@ -1702,7 +1966,7 @@ async function wakeSpecialistOrQueue(name, task, options = {}) {
       };
     }
   }
-  const { saveAgentRuntimeState } = await import("./agents-5OPQKM5K.js");
+  const { saveAgentRuntimeState } = await import("./agents-DMPT32H7.js");
   saveAgentRuntimeState(tmuxSession, {
     state: "active",
     lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1710,7 +1974,7 @@ async function wakeSpecialistOrQueue(name, task, options = {}) {
   });
   console.log(`[specialist] ${name} marked active (preventing concurrent wakes)`);
   try {
-    const wakeResult = await wakeSpecialistWithTask(name, task);
+    const wakeResult = await wakeSpecialistWithTask(name, task, { skipBusyGuard: true });
     if (!wakeResult.success) {
       saveAgentRuntimeState(tmuxSession, {
         state: "idle",
@@ -1786,8 +2050,8 @@ function getNextSpecialistTask(specialistName) {
 }
 async function sendFeedbackToAgent(feedback) {
   const { fromSpecialist, toIssueId, summary, details } = feedback;
-  if (!existsSync3(FEEDBACK_DIR)) {
-    mkdirSync2(FEEDBACK_DIR, { recursive: true });
+  if (!existsSync4(FEEDBACK_DIR)) {
+    mkdirSync3(FEEDBACK_DIR, { recursive: true });
   }
   const fullFeedback = {
     ...feedback,
@@ -1796,13 +2060,13 @@ async function sendFeedbackToAgent(feedback) {
   };
   try {
     const line = JSON.stringify(fullFeedback) + "\n";
-    appendFileSync2(FEEDBACK_LOG, line, "utf-8");
+    appendFileSync3(FEEDBACK_LOG, line, "utf-8");
   } catch (error) {
     console.error(`[specialist] Failed to log feedback:`, error);
   }
   const agentSession = `agent-${toIssueId.toLowerCase()}`;
   const feedbackMessage = formatFeedbackForAgent(fullFeedback);
-  const { writeFeedbackFile } = await import("./feedback-writer-VRMMWWTW.js");
+  const { writeFeedbackFile } = await import("./feedback-writer-T43PI5S2.js");
   const specialistMap = {
     "review-agent": "review-agent",
     "test-agent": "test-agent",
@@ -1822,7 +2086,7 @@ async function sendFeedbackToAgent(feedback) {
     return false;
   }
   try {
-    const { messageAgent } = await import("./agents-5OPQKM5K.js");
+    const { messageAgent } = await import("./agents-DMPT32H7.js");
     const msg = `SPECIALIST FEEDBACK: ${fromSpecialist} reported ${feedback.feedbackType.toUpperCase()} for ${toIssueId}.
 Read and address: ${fileResult.relativePath}`;
     await messageAgent(agentSession, msg);
@@ -1881,11 +2145,11 @@ ${details}
   return message;
 }
 function getPendingFeedback(issueId) {
-  if (!existsSync3(FEEDBACK_LOG)) {
+  if (!existsSync4(FEEDBACK_LOG)) {
     return [];
   }
   try {
-    const content = readFileSync3(FEEDBACK_LOG, "utf-8");
+    const content = readFileSync4(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());
@@ -1904,11 +2168,11 @@ function getFeedbackStats() {
     byType: {},
     total: 0
   };
-  if (!existsSync3(FEEDBACK_LOG)) {
+  if (!existsSync4(FEEDBACK_LOG)) {
     return stats;
   }
   try {
-    const content = readFileSync3(FEEDBACK_LOG, "utf-8");
+    const content = readFileSync4(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);
@@ -1987,7 +2251,7 @@ __export(specialist_logs_exports, {
   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 { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, appendFileSync as appendFileSync4, readFileSync as readFileSync5, readdirSync as readdirSync4, statSync as statSync2, unlinkSync as unlinkSync2 } from "fs";
 import { join as join5, basename as basename3 } from "path";
 function getSpecialistsDir() {
   return join5(getPanopticonHome(), "specialists");
@@ -2005,8 +2269,8 @@ function getRunLogPath(projectKey, specialistType, runId) {
 }
 function ensureRunsDirectory(projectKey, specialistType) {
   const runsDir = getRunsDirectory(projectKey, specialistType);
-  if (!existsSync4(runsDir)) {
-    mkdirSync3(runsDir, { recursive: true });
+  if (!existsSync5(runsDir)) {
+    mkdirSync4(runsDir, { recursive: true });
   }
 }
 function createRunLog(projectKey, specialistType, issueId, contextSeed) {
@@ -2025,22 +2289,22 @@ ${contextSeed ? contextSeed : "[No context digest available]"}
 
 ## Session Transcript
 `;
-  writeFileSync2(filePath, header, "utf-8");
+  writeFileSync3(filePath, header, "utf-8");
   return { runId, filePath };
 }
 function appendToRunLog(projectKey, specialistType, runId, content) {
   const filePath = getRunLogPath(projectKey, specialistType, runId);
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     throw new Error(`Run log not found: ${filePath}`);
   }
-  appendFileSync3(filePath, content, "utf-8");
+  appendFileSync4(filePath, content, "utf-8");
 }
 function finalizeRunLog(projectKey, specialistType, runId, result) {
   const filePath = getRunLogPath(projectKey, specialistType, runId);
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     throw new Error(`Run log not found: ${filePath}`);
   }
-  const content = readFileSync4(filePath, "utf-8");
+  const content = readFileSync5(filePath, "utf-8");
   const startMatch = content.match(/^Started: (.+)$/m);
   const startedAt = startMatch ? new Date(startMatch[1]) : /* @__PURE__ */ new Date();
   const finishedAt = /* @__PURE__ */ new Date();
@@ -2057,15 +2321,15 @@ ${result.notes ? `Notes: ${result.notes}` : ""}
 Duration: ${durationStr}
 Finished: ${finishedAt.toISOString()}
 `;
-  appendFileSync3(filePath, resultSection, "utf-8");
+  appendFileSync4(filePath, resultSection, "utf-8");
 }
 function getRunLog(projectKey, specialistType, runId) {
   const filePath = getRunLogPath(projectKey, specialistType, runId);
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     return null;
   }
   try {
-    return readFileSync4(filePath, "utf-8");
+    return readFileSync5(filePath, "utf-8");
   } catch (error) {
     console.error(`Failed to read run log ${runId}:`, error);
     return null;
@@ -2100,15 +2364,15 @@ function parseLogMetadata(logContent) {
 }
 function listRunLogs(projectKey, specialistType, options = {}) {
   const runsDir = getRunsDirectory(projectKey, specialistType);
-  if (!existsSync4(runsDir)) {
+  if (!existsSync5(runsDir)) {
     return [];
   }
   try {
-    const files = readdirSync3(runsDir).filter((f) => f.endsWith(".log")).map((f) => {
+    const files = readdirSync4(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 content = readFileSync5(filePath, "utf-8");
       const metadata = parseLogMetadata(content);
       return {
         runId,
@@ -2181,7 +2445,7 @@ function isRunLogActive(projectKey, specialistType, runId) {
 }
 function getRunLogSize(projectKey, specialistType, runId) {
   const filePath = getRunLogPath(projectKey, specialistType, runId);
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     return null;
   }
   try {
@@ -2238,6 +2502,19 @@ var init_specialist_logs = __esm({
 });
 
 export {
+  readTodayCosts,
+  readIssueCosts,
+  summarizeCosts,
+  getDailySummary,
+  getWeeklySummary,
+  getMonthlySummary,
+  createBudget,
+  getAllBudgets,
+  checkBudget,
+  deleteBudget,
+  generateReport,
+  formatCost,
+  init_cost,
   getProjectDirs,
   getSessionFiles,
   parseClaudeSession,
@@ -2316,4 +2593,4 @@ export {
   getFeedbackStats,
   init_specialists
 };
-//# sourceMappingURL=chunk-OWHXCGVO.js.map
+//# sourceMappingURL=chunk-2V2DQ3IX.js.map