panopticon-cli 0.3.7 → 0.4.0

package/dist/chunk-4BIZ4OVN.js

@@ -0,0 +1,827 @@
+import {
+  AGENTS_DIR
+} from "./chunk-U4LCHEVU.js";
+
+// src/lib/agents.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync3, readdirSync as readdirSync3, appendFileSync, unlinkSync as unlinkSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/lib/tmux.ts
+import { execSync } from "child_process";
+import { writeFileSync, chmodSync } from "fs";
+function listSessions() {
+  try {
+    const output = execSync('tmux list-sessions -F "#{session_name}|#{session_created}|#{session_attached}|#{session_windows}"', {
+      encoding: "utf8"
+    });
+    return output.trim().split("\n").filter(Boolean).map((line) => {
+      const [name, created, attached, windows] = line.split("|");
+      return {
+        name,
+        created: new Date(parseInt(created) * 1e3),
+        attached: attached === "1",
+        windows: parseInt(windows)
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function sessionExists(name) {
+  try {
+    execSync(`tmux has-session -t ${name} 2>/dev/null`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createSession(name, cwd, initialCommand, options) {
+  const escapedCwd = cwd.replace(/"/g, '\\"');
+  let envFlags = "";
+  if (options?.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      envFlags += ` -e ${key}="${value.replace(/"/g, '\\"')}"`;
+    }
+  }
+  if (initialCommand && (initialCommand.includes("`") || initialCommand.includes("\n") || initialCommand.length > 500)) {
+    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags}`);
+    execSync("sleep 0.5");
+    const tmpFile = `/tmp/pan-cmd-${name}.sh`;
+    writeFileSync(tmpFile, initialCommand);
+    chmodSync(tmpFile, "755");
+    execSync(`tmux send-keys -t ${name} "bash ${tmpFile}"`);
+    execSync(`tmux send-keys -t ${name} C-m`);
+  } else if (initialCommand) {
+    const cmd = `tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags} "${initialCommand.replace(/"/g, '\\"')}"`;
+    execSync(cmd);
+  } else {
+    execSync(`tmux new-session -d -s ${name} -c "${escapedCwd}"${envFlags}`);
+  }
+}
+function killSession(name) {
+  execSync(`tmux kill-session -t ${name}`);
+}
+function sendKeys(sessionName, keys) {
+  const escapedKeys = keys.replace(/"/g, '\\"');
+  execSync(`tmux send-keys -t ${sessionName} "${escapedKeys}"`);
+  execSync(`tmux send-keys -t ${sessionName} C-m`);
+}
+function getAgentSessions() {
+  return listSessions().filter((s) => s.name.startsWith("agent-"));
+}
+
+// src/lib/hooks.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync as writeFileSync2, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+function getHookDir(agentId) {
+  return join(AGENTS_DIR, agentId);
+}
+function getHookFile(agentId) {
+  return join(getHookDir(agentId), "hook.json");
+}
+function getMailDir(agentId) {
+  return join(getHookDir(agentId), "mail");
+}
+function initHook(agentId) {
+  const hookDir = getHookDir(agentId);
+  const mailDir = getMailDir(agentId);
+  mkdirSync(hookDir, { recursive: true });
+  mkdirSync(mailDir, { recursive: true });
+  const hookFile = getHookFile(agentId);
+  if (!existsSync(hookFile)) {
+    const hook = {
+      agentId,
+      items: []
+    };
+    writeFileSync2(hookFile, JSON.stringify(hook, null, 2));
+  }
+}
+function getHook(agentId) {
+  const hookFile = getHookFile(agentId);
+  if (!existsSync(hookFile)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(hookFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function pushToHook(agentId, item) {
+  initHook(agentId);
+  const hook = getHook(agentId) || { agentId, items: [] };
+  const newItem = {
+    ...item,
+    id: `hook-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  hook.items.push(newItem);
+  writeFileSync2(getHookFile(agentId), JSON.stringify(hook, null, 2));
+  return newItem;
+}
+function checkHook(agentId) {
+  const hook = getHook(agentId);
+  if (!hook || hook.items.length === 0) {
+    const mailDir = getMailDir(agentId);
+    if (existsSync(mailDir)) {
+      const mails = readdirSync(mailDir).filter((f) => f.endsWith(".json"));
+      if (mails.length > 0) {
+        const mailItems = mails.map((file) => {
+          try {
+            const content = readFileSync(join(mailDir, file), "utf-8");
+            return JSON.parse(content);
+          } catch {
+            return null;
+          }
+        }).filter(Boolean);
+        return {
+          hasWork: mailItems.length > 0,
+          urgentCount: mailItems.filter((i) => i.priority === "urgent").length,
+          items: mailItems
+        };
+      }
+    }
+    return { hasWork: false, urgentCount: 0, items: [] };
+  }
+  const now = /* @__PURE__ */ new Date();
+  const activeItems = hook.items.filter((item) => {
+    if (item.expiresAt) {
+      return new Date(item.expiresAt) > now;
+    }
+    return true;
+  });
+  const priorityOrder = { urgent: 0, high: 1, normal: 2, low: 3 };
+  activeItems.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  return {
+    hasWork: activeItems.length > 0,
+    urgentCount: activeItems.filter((i) => i.priority === "urgent").length,
+    items: activeItems
+  };
+}
+function popFromHook(agentId, itemId) {
+  const hook = getHook(agentId);
+  if (!hook) return false;
+  const index = hook.items.findIndex((i) => i.id === itemId);
+  if (index === -1) return false;
+  hook.items.splice(index, 1);
+  hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync2(getHookFile(agentId), JSON.stringify(hook, null, 2));
+  return true;
+}
+function clearHook(agentId) {
+  const hook = getHook(agentId);
+  if (!hook) return;
+  hook.items = [];
+  hook.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync2(getHookFile(agentId), JSON.stringify(hook, null, 2));
+}
+function sendMail(toAgentId, from, message, priority = "normal") {
+  initHook(toAgentId);
+  const mailDir = getMailDir(toAgentId);
+  const mailItem = {
+    id: `mail-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    type: "message",
+    priority,
+    source: from,
+    payload: { message },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync2(
+    join(mailDir, `${mailItem.id}.json`),
+    JSON.stringify(mailItem, null, 2)
+  );
+}
+function generateFixedPointPrompt(agentId) {
+  const { hasWork, urgentCount, items } = checkHook(agentId);
+  if (!hasWork) return null;
+  const lines = [
+    "# FPP: Work Found on Your Hook",
+    "",
+    '> "Any runnable action is a fixed point and must resolve before the system can rest."',
+    ""
+  ];
+  if (urgentCount > 0) {
+    lines.push(`\u26A0\uFE0F **${urgentCount} URGENT item(s) require immediate attention**`);
+    lines.push("");
+  }
+  lines.push(`## Pending Work Items (${items.length})`);
+  lines.push("");
+  for (const item of items) {
+    const priorityEmoji = {
+      urgent: "\u{1F534}",
+      high: "\u{1F7E0}",
+      normal: "\u{1F7E2}",
+      low: "\u26AA"
+    }[item.priority];
+    lines.push(`### ${priorityEmoji} ${item.type.toUpperCase()}: ${item.id}`);
+    lines.push(`- Source: ${item.source}`);
+    lines.push(`- Created: ${item.createdAt}`);
+    if (item.payload.issueId) {
+      lines.push(`- Issue: ${item.payload.issueId}`);
+    }
+    if (item.payload.message) {
+      lines.push(`- Message: ${item.payload.message}`);
+    }
+    if (item.payload.action) {
+      lines.push(`- Action: ${item.payload.action}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("Execute these items in priority order. Use `bd hook pop <id>` after completing each item.");
+  return lines.join("\n");
+}
+
+// src/lib/cv.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
+function getCVFile(agentId) {
+  return join2(AGENTS_DIR, agentId, "cv.json");
+}
+function getAgentCV(agentId) {
+  const cvFile = getCVFile(agentId);
+  if (existsSync2(cvFile)) {
+    try {
+      return JSON.parse(readFileSync2(cvFile, "utf-8"));
+    } catch {
+    }
+  }
+  const cv = {
+    agentId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastActive: (/* @__PURE__ */ new Date()).toISOString(),
+    runtime: "claude",
+    model: "sonnet",
+    stats: {
+      totalIssues: 0,
+      successCount: 0,
+      failureCount: 0,
+      abandonedCount: 0,
+      avgDuration: 0,
+      successRate: 0
+    },
+    skillsUsed: [],
+    recentWork: []
+  };
+  saveAgentCV(cv);
+  return cv;
+}
+function saveAgentCV(cv) {
+  const dir = join2(AGENTS_DIR, cv.agentId);
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync3(getCVFile(cv.agentId), JSON.stringify(cv, null, 2));
+}
+function startWork(agentId, issueId, skills) {
+  const cv = getAgentCV(agentId);
+  const entry = {
+    issueId,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    outcome: "in_progress",
+    skills
+  };
+  cv.recentWork.unshift(entry);
+  cv.stats.totalIssues++;
+  cv.lastActive = (/* @__PURE__ */ new Date()).toISOString();
+  if (skills) {
+    for (const skill of skills) {
+      if (!cv.skillsUsed.includes(skill)) {
+        cv.skillsUsed.push(skill);
+      }
+    }
+  }
+  if (cv.recentWork.length > 50) {
+    cv.recentWork = cv.recentWork.slice(0, 50);
+  }
+  saveAgentCV(cv);
+}
+function getAgentRankings() {
+  const rankings = [];
+  if (!existsSync2(AGENTS_DIR)) return rankings;
+  const dirs = readdirSync2(AGENTS_DIR, { withFileTypes: true }).filter(
+    (d) => d.isDirectory()
+  );
+  for (const dir of dirs) {
+    const cv = getAgentCV(dir.name);
+    if (cv.stats.totalIssues > 0) {
+      rankings.push({
+        agentId: dir.name,
+        successRate: cv.stats.successRate,
+        totalIssues: cv.stats.totalIssues,
+        avgDuration: cv.stats.avgDuration
+      });
+    }
+  }
+  rankings.sort((a, b) => {
+    if (b.successRate !== a.successRate) {
+      return b.successRate - a.successRate;
+    }
+    return b.totalIssues - a.totalIssues;
+  });
+  return rankings;
+}
+function formatCV(cv) {
+  const lines = [
+    `# Agent CV: ${cv.agentId}`,
+    "",
+    `Runtime: ${cv.runtime} (${cv.model})`,
+    `Created: ${cv.createdAt}`,
+    `Last Active: ${cv.lastActive}`,
+    "",
+    "## Statistics",
+    "",
+    `- Total Issues: ${cv.stats.totalIssues}`,
+    `- Success Rate: ${(cv.stats.successRate * 100).toFixed(1)}%`,
+    `- Successes: ${cv.stats.successCount}`,
+    `- Failures: ${cv.stats.failureCount}`,
+    `- Abandoned: ${cv.stats.abandonedCount}`,
+    `- Avg Duration: ${cv.stats.avgDuration} minutes`,
+    ""
+  ];
+  if (cv.skillsUsed.length > 0) {
+    lines.push("## Skills Used");
+    lines.push("");
+    lines.push(cv.skillsUsed.join(", "));
+    lines.push("");
+  }
+  if (cv.recentWork.length > 0) {
+    lines.push("## Recent Work");
+    lines.push("");
+    for (const work of cv.recentWork.slice(0, 10)) {
+      const statusIcon = {
+        success: "\u2713",
+        failed: "\u2717",
+        abandoned: "\u2298",
+        in_progress: "\u25CF"
+      }[work.outcome];
+      const duration = work.duration ? ` (${work.duration}m)` : "";
+      lines.push(`${statusIcon} ${work.issueId}${duration}`);
+      if (work.failureReason) {
+        lines.push(`  Reason: ${work.failureReason}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/lib/agents.ts
+var execAsync = promisify(exec);
+function getReadySignalPath(agentId) {
+  return join3(getAgentDir(agentId), "ready.json");
+}
+function clearReadySignal(agentId) {
+  const readyPath = getReadySignalPath(agentId);
+  if (existsSync3(readyPath)) {
+    try {
+      unlinkSync2(readyPath);
+    } catch {
+    }
+  }
+}
+async function waitForReadySignal(agentId, timeoutSeconds = 30) {
+  const readyPath = getReadySignalPath(agentId);
+  for (let i = 0; i < timeoutSeconds; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    if (existsSync3(readyPath)) {
+      try {
+        const content = readFileSync3(readyPath, "utf-8");
+        const signal = JSON.parse(content);
+        if (signal.ready === true) {
+          return true;
+        }
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function getAgentDir(agentId) {
+  return join3(AGENTS_DIR, agentId);
+}
+function getAgentState(agentId) {
+  const stateFile = join3(getAgentDir(agentId), "state.json");
+  if (!existsSync3(stateFile)) return null;
+  const content = readFileSync3(stateFile, "utf8");
+  return JSON.parse(content);
+}
+function saveAgentState(state) {
+  const dir = getAgentDir(state.id);
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync4(
+    join3(dir, "state.json"),
+    JSON.stringify(state, null, 2)
+  );
+}
+function getAgentRuntimeState(agentId) {
+  const stateFile = join3(getAgentDir(agentId), "state.json");
+  if (!existsSync3(stateFile)) {
+    return {
+      state: "uninitialized",
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  try {
+    const content = readFileSync3(stateFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveAgentRuntimeState(agentId, state) {
+  const dir = getAgentDir(agentId);
+  mkdirSync3(dir, { recursive: true });
+  const existing = getAgentRuntimeState(agentId);
+  const merged = {
+    ...existing || { state: "uninitialized", lastActivity: (/* @__PURE__ */ new Date()).toISOString() },
+    ...state
+  };
+  writeFileSync4(
+    join3(dir, "state.json"),
+    JSON.stringify(merged, null, 2)
+  );
+}
+function appendActivity(agentId, entry) {
+  const dir = getAgentDir(agentId);
+  mkdirSync3(dir, { recursive: true });
+  const activityFile = join3(dir, "activity.jsonl");
+  appendFileSync(activityFile, JSON.stringify(entry) + "\n");
+  if (existsSync3(activityFile)) {
+    try {
+      const lines = readFileSync3(activityFile, "utf8").trim().split("\n");
+      if (lines.length > 100) {
+        const trimmed = lines.slice(-100);
+        writeFileSync4(activityFile, trimmed.join("\n") + "\n");
+      }
+    } catch (error) {
+    }
+  }
+}
+function getActivity(agentId, limit = 100) {
+  const activityFile = join3(getAgentDir(agentId), "activity.jsonl");
+  if (!existsSync3(activityFile)) {
+    return [];
+  }
+  try {
+    const lines = readFileSync3(activityFile, "utf8").trim().split("\n");
+    const entries = lines.filter((line) => line.trim()).map((line) => JSON.parse(line)).slice(-limit);
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function saveSessionId(agentId, sessionId) {
+  const dir = getAgentDir(agentId);
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync4(join3(dir, "session.id"), sessionId);
+}
+function getSessionId(agentId) {
+  const sessionFile = join3(getAgentDir(agentId), "session.id");
+  if (!existsSync3(sessionFile)) {
+    return null;
+  }
+  try {
+    return readFileSync3(sessionFile, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+async function spawnAgent(options) {
+  const agentId = `agent-${options.issueId.toLowerCase()}`;
+  if (sessionExists(agentId)) {
+    throw new Error(`Agent ${agentId} already running. Use 'pan work tell' to message it.`);
+  }
+  initHook(agentId);
+  const state = {
+    id: agentId,
+    issueId: options.issueId,
+    workspace: options.workspace,
+    runtime: options.runtime || "claude",
+    model: options.model || "sonnet",
+    status: "starting",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    // Initialize Phase 4 fields
+    complexity: options.difficulty,
+    handoffCount: 0,
+    costSoFar: 0
+  };
+  saveAgentState(state);
+  let prompt = options.prompt || "";
+  const { hasWork, items } = checkHook(agentId);
+  if (hasWork) {
+    const fixedPointPrompt = generateFixedPointPrompt(agentId);
+    if (fixedPointPrompt) {
+      prompt = fixedPointPrompt + "\n\n---\n\n" + prompt;
+    }
+  }
+  const promptFile = join3(getAgentDir(agentId), "initial-prompt.md");
+  if (prompt) {
+    writeFileSync4(promptFile, prompt);
+  }
+  checkAndSetupHooks();
+  writeTaskCache(agentId, options.issueId);
+  clearReadySignal(agentId);
+  let claudeCmd;
+  if (prompt) {
+    const launcherScript = join3(getAgentDir(agentId), "launcher.sh");
+    const launcherContent = `#!/bin/bash
+prompt=$(cat "${promptFile}")
+exec claude --dangerously-skip-permissions --model ${state.model} "$prompt"
+`;
+    writeFileSync4(launcherScript, launcherContent, { mode: 493 });
+    claudeCmd = `bash "${launcherScript}"`;
+  } else {
+    claudeCmd = `claude --dangerously-skip-permissions --model ${state.model}`;
+  }
+  createSession(agentId, options.workspace, claudeCmd, {
+    env: {
+      PANOPTICON_AGENT_ID: agentId
+    }
+  });
+  state.status = "running";
+  saveAgentState(state);
+  startWork(agentId, options.issueId);
+  return state;
+}
+function listRunningAgents() {
+  const tmuxSessions = getAgentSessions();
+  const tmuxNames = new Set(tmuxSessions.map((s) => s.name));
+  const agents = [];
+  if (!existsSync3(AGENTS_DIR)) return agents;
+  const dirs = readdirSync3(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const dir of dirs) {
+    const state = getAgentState(dir.name);
+    if (state) {
+      agents.push({
+        ...state,
+        tmuxActive: tmuxNames.has(state.id)
+      });
+    }
+  }
+  return agents;
+}
+function stopAgent(agentId) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  if (sessionExists(normalizedId)) {
+    killSession(normalizedId);
+  }
+  const state = getAgentState(normalizedId);
+  if (state) {
+    state.status = "stopped";
+    saveAgentState(state);
+  }
+}
+async function messageAgent(agentId, message) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  const runtimeState = getAgentRuntimeState(normalizedId);
+  if (runtimeState?.state === "suspended") {
+    console.log(`[agents] Auto-resuming suspended agent ${normalizedId} to deliver message`);
+    const result = await resumeAgent(normalizedId, message);
+    if (!result.success) {
+      throw new Error(`Failed to auto-resume agent: ${result.error}`);
+    }
+    return;
+  }
+  if (!sessionExists(normalizedId)) {
+    throw new Error(`Agent ${normalizedId} not running`);
+  }
+  sendKeys(normalizedId, message);
+  const mailDir = join3(getAgentDir(normalizedId), "mail");
+  mkdirSync3(mailDir, { recursive: true });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  writeFileSync4(
+    join3(mailDir, `${timestamp}.md`),
+    `# Message
+
+${message}
+`
+  );
+}
+async function resumeAgent(agentId, message) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  const runtimeState = getAgentRuntimeState(normalizedId);
+  if (!runtimeState || runtimeState.state !== "suspended") {
+    return {
+      success: false,
+      error: `Cannot resume agent in state: ${runtimeState?.state || "unknown"}`
+    };
+  }
+  const sessionId = getSessionId(normalizedId);
+  if (!sessionId) {
+    return {
+      success: false,
+      error: "No saved session ID found"
+    };
+  }
+  const agentState = getAgentState(normalizedId);
+  if (!agentState) {
+    return {
+      success: false,
+      error: "Agent state not found"
+    };
+  }
+  if (sessionExists(normalizedId)) {
+    return {
+      success: false,
+      error: "Agent session already exists"
+    };
+  }
+  try {
+    clearReadySignal(normalizedId);
+    const claudeCmd = `claude --resume "${sessionId}" --dangerously-skip-permissions`;
+    createSession(normalizedId, agentState.workspace, claudeCmd, {
+      env: {
+        PANOPTICON_AGENT_ID: normalizedId
+      }
+    });
+    if (message) {
+      const ready = await waitForReadySignal(normalizedId, 30);
+      if (ready) {
+        sendKeys(normalizedId, message);
+      } else {
+        console.error("Claude SessionStart hook did not fire during resume, message not sent");
+      }
+    }
+    saveAgentRuntimeState(normalizedId, {
+      state: "active",
+      resumedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (agentState) {
+      agentState.status = "running";
+      agentState.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+      saveAgentState(agentState);
+    }
+    return { success: true };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: `Failed to resume agent: ${msg}`
+    };
+  }
+}
+function detectCrashedAgents() {
+  const agents = listRunningAgents();
+  return agents.filter(
+    (agent) => agent.status === "running" && !agent.tmuxActive
+  );
+}
+function recoverAgent(agentId) {
+  const normalizedId = agentId.startsWith("agent-") ? agentId : `agent-${agentId.toLowerCase()}`;
+  const state = getAgentState(normalizedId);
+  if (!state) {
+    return null;
+  }
+  if (sessionExists(normalizedId)) {
+    return state;
+  }
+  const healthFile = join3(getAgentDir(normalizedId), "health.json");
+  let health = { consecutiveFailures: 0, killCount: 0, recoveryCount: 0 };
+  if (existsSync3(healthFile)) {
+    try {
+      health = { ...health, ...JSON.parse(readFileSync3(healthFile, "utf-8")) };
+    } catch {
+    }
+  }
+  health.recoveryCount = (health.recoveryCount || 0) + 1;
+  writeFileSync4(healthFile, JSON.stringify(health, null, 2));
+  const recoveryPrompt = generateRecoveryPrompt(state);
+  const claudeCmd = `claude --dangerously-skip-permissions --model ${state.model} "${recoveryPrompt.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+  createSession(normalizedId, state.workspace, claudeCmd);
+  state.status = "running";
+  state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  saveAgentState(state);
+  return state;
+}
+function generateRecoveryPrompt(state) {
+  const lines = [
+    "# Agent Recovery",
+    "",
+    "\u26A0\uFE0F This agent session was recovered after a crash.",
+    "",
+    "## Previous Context",
+    `- Issue: ${state.issueId}`,
+    `- Workspace: ${state.workspace}`,
+    `- Started: ${state.startedAt}`,
+    "",
+    "## Recovery Steps",
+    "1. Check beads for context: `bd show " + state.issueId + "`",
+    "2. Review recent git commits: `git log --oneline -10`",
+    "3. Check hook for pending work: `pan work hook check`",
+    "4. Resume from last known state",
+    "",
+    "## FPP Reminder",
+    '> "Any runnable action is a fixed point and must resolve before the system can rest."',
+    ""
+  ];
+  const { hasWork } = checkHook(state.id);
+  if (hasWork) {
+    const fixedPointPrompt = generateFixedPointPrompt(state.id);
+    if (fixedPointPrompt) {
+      lines.push("---");
+      lines.push("");
+      lines.push(fixedPointPrompt);
+    }
+  }
+  return lines.join("\n");
+}
+function autoRecoverAgents() {
+  const crashed = detectCrashedAgents();
+  const recovered = [];
+  const failed = [];
+  for (const agent of crashed) {
+    try {
+      const result = recoverAgent(agent.id);
+      if (result) {
+        recovered.push(agent.id);
+      } else {
+        failed.push(agent.id);
+      }
+    } catch (error) {
+      failed.push(agent.id);
+    }
+  }
+  return { recovered, failed };
+}
+function checkAndSetupHooks() {
+  const settingsPath = join3(homedir(), ".claude", "settings.json");
+  const hookPath = join3(homedir(), ".panopticon", "bin", "heartbeat-hook");
+  if (existsSync3(settingsPath)) {
+    try {
+      const settingsContent = readFileSync3(settingsPath, "utf-8");
+      const settings = JSON.parse(settingsContent);
+      const postToolUse = settings?.hooks?.PostToolUse || [];
+      const hookConfigured = postToolUse.some(
+        (hookConfig) => hookConfig.hooks?.some(
+          (hook) => hook.command === hookPath || hook.command?.includes("panopticon") || hook.command?.includes("heartbeat-hook")
+        )
+      );
+      if (hookConfigured) {
+        return;
+      }
+    } catch {
+    }
+  }
+  try {
+    console.log("Configuring Panopticon heartbeat hooks...");
+    exec("pan setup hooks", (error) => {
+      if (error) {
+        console.warn("\u26A0 Failed to auto-configure hooks. Run `pan setup hooks` manually.");
+      } else {
+        console.log("\u2713 Heartbeat hooks configured");
+      }
+    });
+  } catch (error) {
+    console.warn("\u26A0 Failed to auto-configure hooks. Run `pan setup hooks` manually.");
+  }
+}
+function writeTaskCache(agentId, issueId) {
+  const cacheDir = join3(getAgentDir(agentId));
+  mkdirSync3(cacheDir, { recursive: true });
+  const cacheFile = join3(cacheDir, "current-task.json");
+  writeFileSync4(
+    cacheFile,
+    JSON.stringify({
+      id: issueId,
+      title: `Working on ${issueId}`,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2)
+  );
+}
+
+export {
+  sessionExists,
+  killSession,
+  sendKeys,
+  pushToHook,
+  checkHook,
+  popFromHook,
+  clearHook,
+  sendMail,
+  generateFixedPointPrompt,
+  getAgentCV,
+  getAgentRankings,
+  formatCV,
+  getAgentDir,
+  getAgentState,
+  saveAgentState,
+  getAgentRuntimeState,
+  saveAgentRuntimeState,
+  appendActivity,
+  getActivity,
+  saveSessionId,
+  getSessionId,
+  spawnAgent,
+  listRunningAgents,
+  stopAgent,
+  messageAgent,
+  resumeAgent,
+  detectCrashedAgents,
+  recoverAgent,
+  autoRecoverAgents
+};
+//# sourceMappingURL=chunk-4BIZ4OVN.js.map