panopticon-cli 0.4.4 → 0.4.6

package/dist/chunk-Z24TY3XN.js

@@ -0,0 +1,916 @@
+import {
+  capturePane,
+  checkHook,
+  createSession,
+  generateFixedPointPrompt,
+  getAgentSessions,
+  getModelId,
+  initHook,
+  init_hooks,
+  init_tmux,
+  init_work_type_router,
+  killSession,
+  sendKeys,
+  sessionExists
+} from "./chunk-PUR532O7.js";
+import {
+  getProviderEnv,
+  getProviderForModel,
+  init_providers,
+  init_settings,
+  loadSettings
+} from "./chunk-KQAEUOML.js";
+import {
+  AGENTS_DIR,
+  PANOPTICON_HOME,
+  init_paths
+} from "./chunk-KGPRXDMX.js";
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-ZHC57RCV.js";
+
+// src/lib/cv.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "fs";
+import { join } from "path";
+function getCVFile(agentId) {
+  return join(AGENTS_DIR, agentId, "cv.json");
+}
+function getAgentCV(agentId) {
+  const cvFile = getCVFile(agentId);
+  if (existsSync(cvFile)) {
+    try {
+      return JSON.parse(readFileSync(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 = join(AGENTS_DIR, cv.agentId);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(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 (!existsSync(AGENTS_DIR)) return rankings;
+  const dirs = readdirSync(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");
+}
+var init_cv = __esm({
+  "src/lib/cv.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+  }
+});
+
+// src/lib/cloister/config.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { parse, stringify } from "@iarna/toml";
+import { join as join2 } from "path";
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const defaultVal = defaults[key];
+    const overrideVal = overrides[key];
+    if (overrideVal === void 0) continue;
+    if (typeof defaultVal === "object" && defaultVal !== null && !Array.isArray(defaultVal) && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(overrideVal)) {
+      result[key] = deepMerge(defaultVal, overrideVal);
+    } else {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function loadCloisterConfig() {
+  if (!existsSync2(PANOPTICON_HOME)) {
+    mkdirSync2(PANOPTICON_HOME, { recursive: true });
+  }
+  if (!existsSync2(CLOISTER_CONFIG_FILE)) {
+    saveCloisterConfig(DEFAULT_CLOISTER_CONFIG);
+    return DEFAULT_CLOISTER_CONFIG;
+  }
+  try {
+    const content = readFileSync2(CLOISTER_CONFIG_FILE, "utf-8");
+    const parsed = parse(content);
+    return deepMerge(DEFAULT_CLOISTER_CONFIG, parsed);
+  } catch (error) {
+    console.error("Failed to load Cloister config:", error);
+    console.error("Using default configuration");
+    return DEFAULT_CLOISTER_CONFIG;
+  }
+}
+function saveCloisterConfig(config) {
+  if (!existsSync2(PANOPTICON_HOME)) {
+    mkdirSync2(PANOPTICON_HOME, { recursive: true });
+  }
+  try {
+    const content = stringify(config);
+    writeFileSync2(CLOISTER_CONFIG_FILE, content, "utf-8");
+  } catch (error) {
+    console.error("Failed to save Cloister config:", error);
+    throw error;
+  }
+}
+function getHealthThresholdsMs() {
+  const config = loadCloisterConfig();
+  return {
+    stale: config.thresholds.stale * 60 * 1e3,
+    warning: config.thresholds.warning * 60 * 1e3,
+    stuck: config.thresholds.stuck * 60 * 1e3
+  };
+}
+var CLOISTER_CONFIG_FILE, DEFAULT_CLOISTER_CONFIG;
+var init_config = __esm({
+  "src/lib/cloister/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    CLOISTER_CONFIG_FILE = join2(PANOPTICON_HOME, "cloister.toml");
+    DEFAULT_CLOISTER_CONFIG = {
+      startup: {
+        auto_start: true
+      },
+      thresholds: {
+        stale: 5,
+        warning: 15,
+        stuck: 30
+      },
+      auto_actions: {
+        poke_on_warning: true,
+        kill_on_stuck: false,
+        // Manual by default for safety
+        restart_on_kill: false
+      },
+      monitoring: {
+        check_interval: 60,
+        // 1 minute
+        heartbeat_sources: ["jsonl_mtime", "tmux_activity", "git_activity"]
+      },
+      notifications: {
+        slack_webhook: void 0,
+        email: void 0
+      },
+      specialists: {
+        merge_agent: {
+          enabled: true,
+          auto_wake: false
+          // Only wake on explicit "Approve & Merge" click
+        },
+        review_agent: {
+          enabled: true,
+          auto_wake: false
+          // Only wake on explicit request
+        },
+        test_agent: {
+          enabled: false,
+          // Not yet implemented
+          auto_wake: false
+        }
+      },
+      model_selection: {
+        default_model: "sonnet",
+        complexity_routing: {
+          trivial: "haiku",
+          simple: "haiku",
+          medium: "sonnet",
+          complex: "sonnet",
+          expert: "opus"
+        },
+        specialist_models: {
+          merge_agent: "sonnet",
+          review_agent: "sonnet",
+          test_agent: "haiku",
+          planning_agent: "opus"
+        }
+      },
+      handoffs: {
+        auto_triggers: {
+          planning_complete: {
+            enabled: true,
+            from_model: "opus",
+            to_model: "sonnet"
+          },
+          stuck_escalation: {
+            enabled: true,
+            haiku_to_sonnet_minutes: 10,
+            sonnet_to_opus_minutes: 20
+          },
+          test_failure: {
+            enabled: true,
+            from_model: "haiku",
+            to_model: "sonnet",
+            trigger_on: "any_failure"
+          },
+          implementation_complete: {
+            enabled: true,
+            // Auto-handoff to test-agent when implementation done
+            to_specialist: "test-agent"
+          }
+        }
+      },
+      cost_tracking: {
+        display_enabled: true,
+        log_to_jsonl: true
+      },
+      auto_restart: {
+        enabled: true,
+        max_retries: 3,
+        backoff_seconds: [30, 60, 120]
+        // 30s, 1m, 2m
+      },
+      cost_limits: {
+        per_agent_usd: 10,
+        per_issue_usd: 25,
+        daily_total_usd: 100,
+        alert_threshold: 0.8
+        // Alert at 80%
+      },
+      retention: {
+        agent_state_days: 30,
+        health_staleness_hours: 24
+      }
+    };
+  }
+});
+
+// src/lib/agents.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, appendFileSync, unlinkSync } from "fs";
+import { join as join3 } from "path";
+import { homedir } from "os";
+import { exec } from "child_process";
+import { promisify } from "util";
+function getProviderEnvForModel(model) {
+  const provider = getProviderForModel(model);
+  if (provider.name === "anthropic") return {};
+  const settings = loadSettings();
+  const apiKey = settings.api_keys?.[provider.name];
+  if (apiKey) {
+    return getProviderEnv(provider, apiKey);
+  }
+  console.warn(`Warning: No API key configured for ${provider.displayName}, falling back to Anthropic`);
+  return {};
+}
+function getReadySignalPath(agentId) {
+  return join3(getAgentDir(agentId), "ready.json");
+}
+function clearReadySignal(agentId) {
+  const readyPath = getReadySignalPath(agentId);
+  if (existsSync3(readyPath)) {
+    try {
+      unlinkSync(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 });
+  writeFileSync3(
+    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
+  };
+  writeFileSync3(
+    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);
+        writeFileSync3(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 });
+  writeFileSync3(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;
+  }
+}
+function determineModel(options) {
+  console.log(`[DEBUG] determineModel called with:`, { model: options.model, workType: options.workType, phase: options.phase, agentType: options.agentType, difficulty: options.difficulty });
+  if (options.model) {
+    console.log(`[DEBUG] Using explicit model: ${options.model}`);
+    return options.model;
+  }
+  try {
+    if (options.workType) {
+      return getModelId(options.workType);
+    }
+    if (options.phase) {
+      const workType = `issue-agent:${options.phase}`;
+      return getModelId(workType);
+    }
+    if (options.agentType && options.agentType !== "work-agent") {
+      if (options.agentType === "planning-agent") {
+        return getModelId("planning-agent");
+      }
+      const workType = `specialist-${options.agentType}`;
+      return getModelId(workType);
+    }
+    if (options.difficulty) {
+      const settings = loadSettings();
+      if (settings.models.complexity[options.difficulty]) {
+        console.warn(`Using legacy complexity-based routing for ${options.difficulty}. Consider migrating to work types.`);
+        return settings.models.complexity[options.difficulty];
+      }
+    }
+    try {
+      const cloisterConfig = loadCloisterConfig();
+      const defaultModel = cloisterConfig.model_selection?.default_model || "sonnet";
+      const modelMap = {
+        "opus": "claude-opus-4-6",
+        "sonnet": "claude-sonnet-4-5",
+        "haiku": "claude-haiku-4-5"
+      };
+      return modelMap[defaultModel] || "claude-sonnet-4-5";
+    } catch {
+      return "claude-sonnet-4-5";
+    }
+  } catch (error) {
+    console.warn("Warning: Could not resolve model using work type router, using default");
+    return options.model || "claude-sonnet-4-5";
+  }
+}
+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 selectedModel = determineModel(options);
+  console.log(`[DEBUG] Selected model: ${selectedModel}`);
+  const state = {
+    id: agentId,
+    issueId: options.issueId,
+    workspace: options.workspace,
+    runtime: options.runtime || "claude",
+    model: selectedModel,
+    status: "starting",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    // Initialize Phase 4 fields (legacy)
+    complexity: options.difficulty,
+    handoffCount: 0,
+    costSoFar: 0,
+    // Work type system (PAN-118)
+    phase: options.phase,
+    workType: options.workType
+  };
+  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) {
+    writeFileSync3(promptFile, prompt);
+  }
+  checkAndSetupHooks();
+  writeTaskCache(agentId, options.issueId);
+  clearReadySignal(agentId);
+  const providerEnv = getProviderEnvForModel(selectedModel);
+  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"
+`;
+    writeFileSync3(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,
+      ...providerEnv
+      // Add provider-specific env vars (BASE_URL, AUTH_TOKEN, etc.)
+    }
+  });
+  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 = readdirSync2(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)) {
+    try {
+      const output = capturePane(normalizedId, 5e3);
+      if (output) {
+        const agentDir = getAgentDir(normalizedId);
+        mkdirSync3(agentDir, { recursive: true });
+        writeFileSync3(join3(agentDir, "output.log"), output);
+      }
+    } catch {
+    }
+    killSession(normalizedId);
+  }
+  const state = getAgentState(normalizedId);
+  if (state) {
+    if (!state.id) state.id = normalizedId;
+    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;
+  }
+  const { loadRemoteAgentState, sendToRemoteAgent } = await import("./remote-agents-Z3R2A5BN.js");
+  const remoteState = loadRemoteAgentState(normalizedId);
+  if (remoteState && remoteState.vmName) {
+    console.log(`[agents] Sending message to remote agent ${normalizedId} on ${remoteState.vmName}`);
+    await sendToRemoteAgent(normalizedId, remoteState.vmName, message);
+    const mailDir2 = join3(getAgentDir(normalizedId), "mail");
+    mkdirSync3(mailDir2, { recursive: true });
+    const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    writeFileSync3(
+      join3(mailDir2, `${timestamp2}.md`),
+      `# Message
+
+${message}
+`
+    );
+    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, "-");
+  writeFileSync3(
+    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 providerEnv = agentState.model ? getProviderEnvForModel(agentState.model) : {};
+    const claudeCmd = `claude --resume "${sessionId}" --dangerously-skip-permissions`;
+    createSession(normalizedId, agentState.workspace, claudeCmd, {
+      env: {
+        PANOPTICON_AGENT_ID: normalizedId,
+        ...providerEnv
+      }
+    });
+    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 (!state.id) state.id = normalizedId;
+  if (!state.workspace || !state.model) {
+    console.error(`[agents] Cannot recover ${normalizedId}: state.json missing workspace or model`);
+    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;
+  writeFileSync3(healthFile, JSON.stringify(health, null, 2));
+  const recoveryPrompt = generateRecoveryPrompt(state);
+  const providerEnv = state.model ? getProviderEnvForModel(state.model) : {};
+  const claudeCmd = `claude --dangerously-skip-permissions --model ${state.model} "${recoveryPrompt.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+  createSession(normalizedId, state.workspace, claudeCmd, {
+    env: {
+      PANOPTICON_AGENT_ID: normalizedId,
+      ...providerEnv
+    }
+  });
+  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");
+  writeFileSync3(
+    cacheFile,
+    JSON.stringify({
+      id: issueId,
+      title: `Working on ${issueId}`,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2)
+  );
+}
+var execAsync;
+var init_agents = __esm({
+  "src/lib/agents.ts"() {
+    init_esm_shims();
+    init_paths();
+    init_tmux();
+    init_hooks();
+    init_cv();
+    init_config();
+    init_settings();
+    init_work_type_router();
+    init_providers();
+    execAsync = promisify(exec);
+  }
+});
+
+export {
+  getAgentCV,
+  getAgentRankings,
+  formatCV,
+  init_cv,
+  loadCloisterConfig,
+  getHealthThresholdsMs,
+  init_config,
+  getAgentDir,
+  getAgentState,
+  saveAgentState,
+  getAgentRuntimeState,
+  saveAgentRuntimeState,
+  appendActivity,
+  getActivity,
+  saveSessionId,
+  getSessionId,
+  spawnAgent,
+  listRunningAgents,
+  stopAgent,
+  messageAgent,
+  resumeAgent,
+  detectCrashedAgents,
+  recoverAgent,
+  autoRecoverAgents,
+  init_agents
+};
+//# sourceMappingURL=chunk-Z24TY3XN.js.map