sisyphi 0.1.0

package/dist/daemon.js

@@ -0,0 +1,983 @@
+#!/usr/bin/env node
+import {
+  daemonPidPath,
+  globalConfigPath,
+  globalDir,
+  projectConfigPath,
+  projectOrchestratorPromptPath,
+  reportFilePath,
+  reportsDir,
+  sessionDir,
+  sessionsDir,
+  socketPath,
+  statePath
+} from "./chunk-5WP7O7D3.js";
+
+// src/daemon/index.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, existsSync as existsSync4 } from "fs";
+
+// src/shared/config.ts
+import { readFileSync } from "fs";
+var DEFAULT_CONFIG = {
+  pollIntervalMs: 1e3
+};
+function readJsonFile(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function loadConfig(cwd) {
+  const global = readJsonFile(globalConfigPath());
+  const project = readJsonFile(projectConfigPath(cwd));
+  return { ...DEFAULT_CONFIG, ...global, ...project };
+}
+
+// src/daemon/server.ts
+import { createServer } from "net";
+import { unlinkSync, existsSync as existsSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync5, mkdirSync as mkdirSync3 } from "fs";
+import { join as join2 } from "path";
+
+// src/daemon/session-manager.ts
+import { v4 as uuidv4 } from "uuid";
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+
+// src/daemon/state.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, renameSync } from "fs";
+import { dirname, join } from "path";
+import { randomUUID } from "crypto";
+var sessionLocks = /* @__PURE__ */ new Map();
+async function withSessionLock(sessionId, fn) {
+  const prev = sessionLocks.get(sessionId) ?? Promise.resolve();
+  let resolve3;
+  const next = new Promise((r) => {
+    resolve3 = r;
+  });
+  sessionLocks.set(sessionId, next);
+  await prev;
+  try {
+    return fn();
+  } finally {
+    resolve3();
+  }
+}
+function atomicWrite(filePath, data) {
+  const dir = dirname(filePath);
+  const tmpPath = join(dir, `.state.${randomUUID()}.tmp`);
+  writeFileSync(tmpPath, data, "utf-8");
+  renameSync(tmpPath, filePath);
+}
+function createSession(id, task, cwd) {
+  const dir = sessionDir(cwd, id);
+  mkdirSync(dir, { recursive: true });
+  const session = {
+    id,
+    task,
+    cwd,
+    status: "active",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tasks: [],
+    agents: [],
+    orchestratorCycles: []
+  };
+  atomicWrite(statePath(cwd, id), JSON.stringify(session, null, 2));
+  return session;
+}
+function getSession(cwd, sessionId) {
+  const content = readFileSync2(statePath(cwd, sessionId), "utf-8");
+  return JSON.parse(content);
+}
+function saveSession(session) {
+  atomicWrite(statePath(session.cwd, session.id), JSON.stringify(session, null, 2));
+}
+async function addTask(cwd, sessionId, description, initialStatus) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const nextNum = session.tasks.length + 1;
+    const task = {
+      id: `t${nextNum}`,
+      description,
+      status: initialStatus !== void 0 ? initialStatus : "pending"
+    };
+    session.tasks.push(task);
+    saveSession(session);
+    return task;
+  });
+}
+async function updateTask(cwd, sessionId, taskId, updates) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const task = session.tasks.find((t) => t.id === taskId);
+    if (!task) throw new Error(`Task ${taskId} not found in session ${sessionId}`);
+    if (updates.status) task.status = updates.status;
+    if (updates.description) task.description = updates.description;
+    saveSession(session);
+  });
+}
+async function addAgent(cwd, sessionId, agent) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.agents.push(agent);
+    saveSession(session);
+  });
+}
+async function updateAgent(cwd, sessionId, agentId, updates) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const agent = session.agents.find((a) => a.id === agentId);
+    if (!agent) throw new Error(`Agent ${agentId} not found in session ${sessionId}`);
+    Object.assign(agent, updates);
+    saveSession(session);
+  });
+}
+async function addOrchestratorCycle(cwd, sessionId, cycle) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.orchestratorCycles.push(cycle);
+    saveSession(session);
+  });
+}
+async function updateSessionStatus(cwd, sessionId, status, completionReport) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.status = status;
+    if (completionReport !== void 0) {
+      session.completionReport = completionReport;
+    }
+    saveSession(session);
+  });
+}
+async function appendAgentToLastCycle(cwd, sessionId, agentId) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const cycles = session.orchestratorCycles;
+    if (cycles.length === 0) return;
+    cycles[cycles.length - 1].agentsSpawned.push(agentId);
+    saveSession(session);
+  });
+}
+async function completeSession(cwd, sessionId, report) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.status = "completed";
+    session.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    session.completionReport = report;
+    saveSession(session);
+  });
+}
+async function appendAgentReport(cwd, sessionId, agentId, entry) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const agent = session.agents.find((a) => a.id === agentId);
+    if (!agent) throw new Error(`Agent ${agentId} not found in session ${sessionId}`);
+    agent.reports.push(entry);
+    saveSession(session);
+  });
+}
+async function completeOrchestratorCycle(cwd, sessionId) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const cycles = session.orchestratorCycles;
+    if (cycles.length === 0) return;
+    cycles[cycles.length - 1].completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    saveSession(session);
+  });
+}
+
+// src/daemon/orchestrator.ts
+import { readFileSync as readFileSync3, existsSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+
+// src/daemon/tmux.ts
+import { execSync } from "child_process";
+var EXEC_ENV = {
+  ...process.env,
+  PATH: `/opt/homebrew/bin:/usr/local/bin:${process.env["PATH"] ?? "/usr/bin:/bin"}`
+};
+function exec(cmd) {
+  return execSync(cmd, { encoding: "utf-8", env: EXEC_ENV }).trim();
+}
+function execSafe(cmd) {
+  try {
+    return exec(cmd);
+  } catch {
+    return null;
+  }
+}
+function createPane(windowTarget, cwd) {
+  const cwdFlag = cwd ? ` -c ${shellQuote(cwd)}` : "";
+  const paneId = exec(`tmux split-window -h -t "${windowTarget}"${cwdFlag} -P -F "#{pane_id}"`);
+  execSafe(`tmux select-layout -t "${windowTarget}" even-horizontal`);
+  return paneId;
+}
+function sendKeys(paneTarget, command) {
+  exec(`tmux send-keys -t "${paneTarget}" ${shellQuote(command)} Enter`);
+}
+function killPane(paneTarget) {
+  execSafe(`tmux kill-pane -t "${paneTarget}"`);
+}
+function killWindow(windowTarget) {
+  execSafe(`tmux kill-window -t "${windowTarget}"`);
+}
+function listPanes(windowTarget) {
+  const output = execSafe(`tmux list-panes -t "${windowTarget}" -F "#{pane_id} #{pane_pid}"`);
+  if (!output) return [];
+  return output.split("\n").filter(Boolean).map((line) => {
+    const [paneId, panePid] = line.split(" ");
+    return { paneId, panePid };
+  });
+}
+function setPaneTitle(paneTarget, title) {
+  execSafe(`tmux select-pane -t "${paneTarget}" -T ${shellQuote(title)}`);
+}
+function setPaneStyle(paneTarget, color) {
+  execSafe(`tmux select-pane -t "${paneTarget}" -P "border-style=fg=${color}"`);
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+// src/daemon/colors.ts
+var ORCHESTRATOR_COLOR = "yellow";
+var AGENT_PALETTE = ["blue", "green", "magenta", "cyan", "red", "white"];
+var sessionColorIndex = /* @__PURE__ */ new Map();
+function getNextColor(sessionId) {
+  const idx = sessionColorIndex.get(sessionId) ?? 0;
+  const color = AGENT_PALETTE[idx % AGENT_PALETTE.length];
+  sessionColorIndex.set(sessionId, idx + 1);
+  return color;
+}
+function resetColors(sessionId) {
+  sessionColorIndex.delete(sessionId);
+}
+
+// src/daemon/orchestrator.ts
+var sessionWindowMap = /* @__PURE__ */ new Map();
+var sessionOrchestratorPane = /* @__PURE__ */ new Map();
+function getWindowId(sessionId) {
+  return sessionWindowMap.get(sessionId);
+}
+function getOrchestratorPaneId(sessionId) {
+  return sessionOrchestratorPane.get(sessionId);
+}
+function loadOrchestratorPrompt(cwd) {
+  const projectPath = projectOrchestratorPromptPath(cwd);
+  if (existsSync(projectPath)) {
+    return readFileSync3(projectPath, "utf-8");
+  }
+  const bundledPath = resolve(import.meta.dirname, "../templates/orchestrator.md");
+  return readFileSync3(bundledPath, "utf-8");
+}
+function formatStateForOrchestrator(session) {
+  const shortId = session.id.slice(0, 8);
+  const cycleNum = session.orchestratorCycles.length;
+  const taskLines = session.tasks.length > 0 ? session.tasks.map((t) => `- ${t.id}: [${t.status}] ${t.description}`).join("\n") : "  (none)";
+  const agentLines = session.agents.length > 0 ? session.agents.map((a) => {
+    const header = `- ${a.id} (${a.name}): ${a.status} \u2014 ${a.reports.length} report(s)`;
+    if (a.reports.length === 0) return header;
+    let updateNum = 0;
+    const reportLines = a.reports.map((r) => {
+      const label = r.type === "final" ? "[final]" : `[update ${String(++updateNum).padStart(3, "0")}]`;
+      return `  ${label} "${r.summary}" \u2192 ${r.filePath}`;
+    });
+    return [header, ...reportLines].join("\n");
+  }).join("\n") : "  (none)";
+  const cycleLines = session.orchestratorCycles.length > 0 ? session.orchestratorCycles.map((c) => {
+    const spawnedList = c.agentsSpawned.length > 0 ? c.agentsSpawned.join(", ") : "(none)";
+    return `Cycle ${c.cycle}: Spawned ${spawnedList}`;
+  }).join("\n") : "  (none)";
+  return [
+    "<state>",
+    `session: ${shortId} (cycle ${cycleNum})`,
+    `task: ${session.task}`,
+    `status: ${session.status}`,
+    "",
+    "## Tasks",
+    taskLines,
+    "",
+    "## Agents",
+    agentLines,
+    "",
+    "## Previous Cycles",
+    cycleLines,
+    "</state>"
+  ].join("\n");
+}
+async function spawnOrchestrator(sessionId, cwd, windowId, message) {
+  const session = getSession(cwd, sessionId);
+  const basePrompt = loadOrchestratorPrompt(cwd);
+  const formattedState = formatStateForOrchestrator(session);
+  const fullPrompt = `${basePrompt}
+
+${formattedState}`;
+  const cycleNum = session.orchestratorCycles.length + 1;
+  const promptFilePath = `${sessionDir(cwd, sessionId)}/orchestrator-prompt-${cycleNum}.md`;
+  writeFileSync2(promptFilePath, fullPrompt, "utf-8");
+  sessionWindowMap.set(sessionId, windowId);
+  const envExports = [
+    `export SISYPHUS_SESSION_ID='${sessionId}'`,
+    `export SISYPHUS_AGENT_ID='orchestrator'`
+  ].join(" && ");
+  const userPrompt = message ? `The user resumed this session with new instructions: ${message}` : "Review the current session state and execute the next cycle of work.";
+  const userPromptFilePath = `${sessionDir(cwd, sessionId)}/orchestrator-user-${cycleNum}.md`;
+  writeFileSync2(userPromptFilePath, userPrompt, "utf-8");
+  const claudeCmd = `claude --dangerously-skip-permissions --append-system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
+  const paneId = createPane(windowId, cwd);
+  sessionOrchestratorPane.set(sessionId, paneId);
+  setPaneTitle(paneId, `orchestrator (${sessionId.slice(0, 8)})`);
+  setPaneStyle(paneId, ORCHESTRATOR_COLOR);
+  sendKeys(paneId, `${envExports} && ${claudeCmd}`);
+  await addOrchestratorCycle(cwd, sessionId, {
+    cycle: cycleNum,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    agentsSpawned: [],
+    paneId
+  });
+}
+function resolveOrchestratorPane(sessionId, cwd) {
+  const memPane = sessionOrchestratorPane.get(sessionId);
+  if (memPane) return memPane;
+  const session = getSession(cwd, sessionId);
+  const lastCycle = session.orchestratorCycles[session.orchestratorCycles.length - 1];
+  return lastCycle?.paneId ?? void 0;
+}
+async function handleOrchestratorYield(sessionId, cwd) {
+  const paneId = resolveOrchestratorPane(sessionId, cwd);
+  if (paneId) {
+    killPane(paneId);
+    sessionOrchestratorPane.delete(sessionId);
+  }
+  await completeOrchestratorCycle(cwd, sessionId);
+  const session = getSession(cwd, sessionId);
+  const runningAgents = session.agents.filter((a) => a.status === "running");
+  if (runningAgents.length === 0) {
+    console.error(`[sisyphus] WARNING: Orchestrator yielded but no agents are running for session ${sessionId}`);
+  }
+}
+async function handleOrchestratorComplete(sessionId, cwd, report) {
+  const paneId = resolveOrchestratorPane(sessionId, cwd);
+  await completeOrchestratorCycle(cwd, sessionId);
+  await completeSession(cwd, sessionId, report);
+  if (paneId) {
+    killPane(paneId);
+    sessionOrchestratorPane.delete(sessionId);
+  }
+  sessionWindowMap.delete(sessionId);
+  console.log(`[sisyphus] Session ${sessionId} completed: ${report}`);
+}
+
+// src/daemon/agent.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { resolve as resolve2 } from "path";
+var agentCounters = /* @__PURE__ */ new Map();
+function resetAgentCounter(sessionId, value = 0) {
+  agentCounters.set(sessionId, value);
+}
+function clearAgentCounter(sessionId) {
+  agentCounters.delete(sessionId);
+}
+function renderAgentSuffix(sessionId, instruction) {
+  const templatePath = resolve2(import.meta.dirname, "../templates/agent-suffix.md");
+  let template;
+  try {
+    template = readFileSync4(templatePath, "utf-8");
+  } catch {
+    template = `# Sisyphus Agent
+Session: {{SESSION_ID}}
+Task: {{INSTRUCTION}}`;
+  }
+  return template.replace(/\{\{SESSION_ID\}\}/g, sessionId).replace(/\{\{INSTRUCTION\}\}/g, instruction);
+}
+async function spawnAgent(opts) {
+  const { sessionId, cwd, agentType, name, instruction, windowId } = opts;
+  const count = (agentCounters.get(sessionId) ?? 0) + 1;
+  agentCounters.set(sessionId, count);
+  const agentId = `agent-${String(count).padStart(3, "0")}`;
+  const color = getNextColor(sessionId);
+  const paneId = createPane(windowId, cwd);
+  setPaneTitle(paneId, `${name} (${agentId})`);
+  setPaneStyle(paneId, color);
+  const suffix = renderAgentSuffix(sessionId, instruction);
+  const suffixFilePath = `${sessionDir(cwd, sessionId)}/${agentId}-system.md`;
+  writeFileSync3(suffixFilePath, suffix, "utf-8");
+  const envExports = [
+    `export SISYPHUS_SESSION_ID='${sessionId}'`,
+    `export SISYPHUS_AGENT_ID='${agentId}'`
+  ].join(" && ");
+  const agentFlag = agentType ? ` --agent ${shellQuote2(agentType)}` : "";
+  const claudeCmd = `claude --dangerously-skip-permissions${agentFlag} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote2(instruction)}`;
+  sendKeys(paneId, `${envExports} && ${claudeCmd}`);
+  const agent = {
+    id: agentId,
+    name,
+    agentType,
+    color,
+    instruction,
+    status: "running",
+    spawnedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: null,
+    reports: [],
+    paneId
+  };
+  await addAgent(cwd, sessionId, agent);
+  return agent;
+}
+function nextReportNumber(cwd, sessionId, agentId) {
+  const dir = reportsDir(cwd, sessionId);
+  try {
+    const files = readdirSync(dir).filter((f) => f.startsWith(`${agentId}-`) && !f.endsWith("-final.md"));
+    return String(files.length + 1).padStart(3, "0");
+  } catch {
+    return "001";
+  }
+}
+async function handleAgentReport(cwd, sessionId, agentId, content) {
+  const dir = reportsDir(cwd, sessionId);
+  mkdirSync2(dir, { recursive: true });
+  const num = nextReportNumber(cwd, sessionId, agentId);
+  const filePath = reportFilePath(cwd, sessionId, agentId, num);
+  writeFileSync3(filePath, content, "utf-8");
+  const entry = {
+    type: "update",
+    filePath,
+    summary: content.slice(0, 200),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await appendAgentReport(cwd, sessionId, agentId, entry);
+}
+async function handleAgentSubmit(cwd, sessionId, agentId, report) {
+  const dir = reportsDir(cwd, sessionId);
+  mkdirSync2(dir, { recursive: true });
+  const filePath = reportFilePath(cwd, sessionId, agentId, "final");
+  writeFileSync3(filePath, report, "utf-8");
+  const entry = {
+    type: "final",
+    filePath,
+    summary: report.slice(0, 200),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await appendAgentReport(cwd, sessionId, agentId, entry);
+  await updateAgent(cwd, sessionId, agentId, {
+    status: "completed",
+    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const session = getSession(cwd, sessionId);
+  const agent = session.agents.find((a) => a.id === agentId);
+  if (agent) {
+    killPane(agent.paneId);
+  }
+  return allAgentsDone(session);
+}
+async function handleAgentKilled(cwd, sessionId, agentId, reason) {
+  await updateAgent(cwd, sessionId, agentId, {
+    status: "killed",
+    killedReason: reason,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const session = getSession(cwd, sessionId);
+  return allAgentsDone(session);
+}
+function allAgentsDone(session) {
+  const running = session.agents.filter((a) => a.status === "running");
+  return running.length === 0 && session.agents.length > 0;
+}
+function shellQuote2(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+// src/daemon/pane-monitor.ts
+var monitorInterval = null;
+var onAllAgentsDone = null;
+function setRespawnCallback(cb) {
+  onAllAgentsDone = cb;
+}
+function startMonitor(pollIntervalMs = 1e3) {
+  if (monitorInterval) return;
+  monitorInterval = setInterval(() => {
+    pollAllSessions().catch((err) => {
+      console.error("[sisyphus] Pane monitor error:", err);
+    });
+  }, pollIntervalMs);
+}
+function stopMonitor() {
+  if (monitorInterval) {
+    clearInterval(monitorInterval);
+    monitorInterval = null;
+  }
+}
+var trackedSessions = /* @__PURE__ */ new Map();
+function trackSession(sessionId, cwd, tmuxSession) {
+  const existing = trackedSessions.get(sessionId);
+  trackedSessions.set(sessionId, { id: sessionId, cwd, tmuxSession, windowId: existing ? existing.windowId : null });
+}
+function updateTrackedWindow(sessionId, windowId) {
+  const entry = trackedSessions.get(sessionId);
+  if (!entry) throw new Error(`Cannot update window for untracked session: ${sessionId}`);
+  entry.windowId = windowId;
+}
+function untrackSession(sessionId) {
+  trackedSessions.delete(sessionId);
+}
+async function pollAllSessions() {
+  for (const { id: sessionId, cwd, windowId } of trackedSessions.values()) {
+    if (windowId) {
+      await pollSession(sessionId, cwd, windowId);
+    }
+  }
+}
+async function pollSession(sessionId, cwd, windowId) {
+  let session;
+  try {
+    session = getSession(cwd, sessionId);
+  } catch (err) {
+    console.error(`[sisyphus] Failed to read state for session ${sessionId}:`, err);
+    return;
+  }
+  if (session.status !== "active") return;
+  const livePanes = listPanes(windowId);
+  if (livePanes.length === 0) return;
+  const livePaneIds = new Set(livePanes.map((p) => p.paneId));
+  for (const agent of session.agents) {
+    if (agent.status !== "running") continue;
+    if (!livePaneIds.has(agent.paneId)) {
+      const allDone = await handleAgentKilled(cwd, sessionId, agent.id, "pane closed by user");
+      if (allDone && onAllAgentsDone) {
+        onAllAgentsDone(sessionId, cwd, windowId);
+      }
+    }
+  }
+  const orchPaneId = getOrchestratorPaneId(sessionId);
+  if (orchPaneId && !livePaneIds.has(orchPaneId)) {
+    const runningAgents = session.agents.filter((a) => a.status === "running");
+    if (runningAgents.length === 0) {
+      await updateSessionStatus(cwd, sessionId, "paused");
+      console.log(`[sisyphus] Session ${sessionId} paused: orchestrator pane disappeared`);
+    }
+  }
+}
+
+// src/daemon/session-manager.ts
+async function startSession(task, cwd, tmuxSession, windowId) {
+  const sessionId = uuidv4();
+  const session = createSession(sessionId, task, cwd);
+  trackSession(sessionId, cwd, tmuxSession);
+  await spawnOrchestrator(sessionId, cwd, windowId);
+  updateTrackedWindow(sessionId, windowId);
+  return session;
+}
+async function resumeSession(sessionId, cwd, tmuxSession, windowId, message) {
+  const session = getSession(cwd, sessionId);
+  for (const agent of session.agents) {
+    if (agent.status === "running") {
+      await updateAgent(cwd, sessionId, agent.id, {
+        status: "lost",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        killedReason: "session resumed \u2014 agent was still running"
+      });
+    }
+  }
+  await updateSessionStatus(cwd, sessionId, "active");
+  resetAgentCounter(sessionId, session.agents.length);
+  resetColors(sessionId);
+  trackSession(sessionId, cwd, tmuxSession);
+  await spawnOrchestrator(sessionId, cwd, windowId, message);
+  updateTrackedWindow(sessionId, windowId);
+  return getSession(cwd, sessionId);
+}
+function getSessionStatus(cwd, sessionId) {
+  return getSession(cwd, sessionId);
+}
+function listSessions(cwd) {
+  const dir = sessionsDir(cwd);
+  if (!existsSync2(dir)) return [];
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  const sessions = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    try {
+      const session = getSession(cwd, entry.name);
+      sessions.push({
+        id: session.id,
+        task: session.task,
+        status: session.status,
+        createdAt: session.createdAt,
+        agentCount: session.agents.length
+      });
+    } catch (err) {
+      console.error(`[sisyphus] Failed to read session ${entry.name}:`, err);
+    }
+  }
+  return sessions;
+}
+function onAllAgentsDone2(sessionId, cwd, windowId) {
+  const session = getSession(cwd, sessionId);
+  if (session.status !== "active") return;
+  setTimeout(() => {
+    spawnOrchestrator(sessionId, cwd, windowId).then(() => updateTrackedWindow(sessionId, windowId)).catch((err) => console.error(`[sisyphus] Failed to respawn orchestrator for session ${sessionId}:`, err));
+  }, 2e3);
+}
+async function handleSpawn(sessionId, cwd, agentType, name, instruction) {
+  const windowId = getWindowId(sessionId);
+  if (!windowId) throw new Error(`No tmux window found for session ${sessionId}`);
+  const agent = await spawnAgent({
+    sessionId,
+    cwd,
+    agentType,
+    name,
+    instruction,
+    windowId
+  });
+  await appendAgentToLastCycle(cwd, sessionId, agent.id);
+  return { agentId: agent.id };
+}
+async function handleSubmit(cwd, sessionId, agentId, report, windowId) {
+  const allDone = await handleAgentSubmit(cwd, sessionId, agentId, report);
+  if (allDone) {
+    onAllAgentsDone2(sessionId, cwd, windowId);
+  }
+}
+async function handleReport(cwd, sessionId, agentId, content) {
+  await handleAgentReport(cwd, sessionId, agentId, content);
+}
+async function handleYield(sessionId, cwd) {
+  await handleOrchestratorYield(sessionId, cwd);
+}
+async function handleComplete(sessionId, cwd, report) {
+  untrackSession(sessionId);
+  await handleOrchestratorComplete(sessionId, cwd, report);
+}
+async function handleTaskAdd(cwd, sessionId, description, initialStatus) {
+  const VALID_STATUSES = /* @__PURE__ */ new Set(["draft", "pending", "in_progress", "done"]);
+  const status = initialStatus !== void 0 && VALID_STATUSES.has(initialStatus) ? initialStatus : void 0;
+  const task = await addTask(cwd, sessionId, description, status);
+  return { taskId: task.id };
+}
+async function handleTaskUpdate(cwd, sessionId, taskId, status, description) {
+  const VALID_STATUSES = /* @__PURE__ */ new Set(["draft", "pending", "in_progress", "done"]);
+  const updates = {};
+  if (status !== void 0) {
+    if (!VALID_STATUSES.has(status)) throw new Error(`Invalid status: ${status}. Valid: draft, pending, in_progress, done`);
+    updates.status = status;
+  }
+  if (description !== void 0) updates.description = description;
+  await updateTask(cwd, sessionId, taskId, updates);
+}
+function handleTasksList(cwd, sessionId) {
+  const session = getSession(cwd, sessionId);
+  return { tasks: session.tasks };
+}
+async function handleRegisterClaudeSession(cwd, sessionId, agentId, claudeSessionId) {
+  await updateAgent(cwd, sessionId, agentId, { claudeSessionId });
+}
+async function handleKill(sessionId, cwd) {
+  const session = getSession(cwd, sessionId);
+  const windowId = getWindowId(sessionId);
+  let killedAgents = 0;
+  for (const agent of session.agents) {
+    if (agent.status === "running") {
+      await updateAgent(cwd, sessionId, agent.id, {
+        status: "killed",
+        killedReason: "session killed by user",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      killedAgents++;
+    }
+  }
+  const orchPaneId = getOrchestratorPaneId(sessionId);
+  if (orchPaneId) {
+    killPane(orchPaneId);
+  }
+  await updateSessionStatus(cwd, sessionId, "completed");
+  untrackSession(sessionId);
+  if (windowId) {
+    killWindow(windowId);
+  }
+  clearAgentCounter(sessionId);
+  return killedAgents;
+}
+
+// src/daemon/server.ts
+var server = null;
+var sessionCwdMap = /* @__PURE__ */ new Map();
+var sessionTmuxMap = /* @__PURE__ */ new Map();
+var sessionWindowMap2 = /* @__PURE__ */ new Map();
+function registryPath() {
+  return join2(globalDir(), "session-registry.json");
+}
+function persistSessionRegistry() {
+  const dir = globalDir();
+  mkdirSync3(dir, { recursive: true });
+  const registry = {};
+  for (const [id, cwd] of sessionCwdMap) {
+    registry[id] = cwd;
+  }
+  writeFileSync4(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
+}
+function loadSessionRegistry() {
+  const p = registryPath();
+  if (!existsSync3(p)) return {};
+  try {
+    return JSON.parse(readFileSync5(p, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function registerSessionCwd(sessionId, cwd) {
+  sessionCwdMap.set(sessionId, cwd);
+  persistSessionRegistry();
+}
+async function handleRequest(req) {
+  try {
+    switch (req.type) {
+      case "start": {
+        const session = await startSession(req.task, req.cwd, req.tmuxSession, req.tmuxWindow);
+        registerSessionCwd(session.id, req.cwd);
+        sessionTmuxMap.set(session.id, req.tmuxSession);
+        sessionWindowMap2.set(session.id, req.tmuxWindow);
+        return { ok: true, data: { sessionId: session.id } };
+      }
+      case "spawn": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        const result = await handleSpawn(req.sessionId, cwd, req.agentType, req.name, req.instruction);
+        return { ok: true, data: { agentId: result.agentId } };
+      }
+      case "submit": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        const windowId = sessionWindowMap2.get(req.sessionId);
+        if (!windowId) return { ok: false, error: `No tmux window found for session: ${req.sessionId}` };
+        await handleSubmit(cwd, req.sessionId, req.agentId, req.report, windowId);
+        return { ok: true };
+      }
+      case "report": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        await handleReport(cwd, req.sessionId, req.agentId, req.content);
+        return { ok: true };
+      }
+      case "yield": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        await handleYield(req.sessionId, cwd);
+        return { ok: true };
+      }
+      case "complete": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        await handleComplete(req.sessionId, cwd, req.report);
+        return { ok: true };
+      }
+      case "status": {
+        if (req.sessionId) {
+          const cwd = sessionCwdMap.get(req.sessionId);
+          if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+          const session = getSessionStatus(cwd, req.sessionId);
+          return { ok: true, data: { session } };
+        }
+        return { ok: true, data: { message: "daemon running" } };
+      }
+      case "tasks_add": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        const result = await handleTaskAdd(cwd, req.sessionId, req.description, req.status);
+        return { ok: true, data: { taskId: result.taskId } };
+      }
+      case "tasks_update": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        await handleTaskUpdate(cwd, req.sessionId, req.taskId, req.status, req.description);
+        return { ok: true };
+      }
+      case "tasks_list": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        const result = handleTasksList(cwd, req.sessionId);
+        return { ok: true, data: { tasks: result.tasks } };
+      }
+      case "list": {
+        const allSessions = [];
+        const seenCwds = /* @__PURE__ */ new Set();
+        for (const cwd of sessionCwdMap.values()) {
+          if (seenCwds.has(cwd)) continue;
+          seenCwds.add(cwd);
+          const sessions = listSessions(cwd);
+          allSessions.push(...sessions.map((s) => s));
+        }
+        return { ok: true, data: { sessions: allSessions } };
+      }
+      case "resume": {
+        let cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) {
+          const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
+          if (existsSync3(stateFile)) {
+            cwd = req.cwd;
+            registerSessionCwd(req.sessionId, cwd);
+          } else {
+            return { ok: false, error: `Unknown session: ${req.sessionId}. No state.json found at ${stateFile}` };
+          }
+        }
+        sessionTmuxMap.set(req.sessionId, req.tmuxSession);
+        sessionWindowMap2.set(req.sessionId, req.tmuxWindow);
+        const session = await resumeSession(req.sessionId, cwd, req.tmuxSession, req.tmuxWindow, req.message);
+        return { ok: true, data: { sessionId: session.id, status: session.status } };
+      }
+      case "register_claude_session": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        await handleRegisterClaudeSession(cwd, req.sessionId, req.agentId, req.claudeSessionId);
+        return { ok: true };
+      }
+      case "kill": {
+        const cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+        const killedAgents = await handleKill(req.sessionId, cwd);
+        sessionCwdMap.delete(req.sessionId);
+        sessionTmuxMap.delete(req.sessionId);
+        sessionWindowMap2.delete(req.sessionId);
+        persistSessionRegistry();
+        return { ok: true, data: { killedAgents, sessionId: req.sessionId } };
+      }
+      default:
+        return { ok: false, error: `Unknown request type: ${req.type}` };
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+function startServer() {
+  return new Promise((resolve3, reject) => {
+    const sock = socketPath();
+    if (existsSync3(sock)) {
+      unlinkSync(sock);
+    }
+    server = createServer((conn) => {
+      let buffer = "";
+      conn.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          let req;
+          try {
+            req = JSON.parse(line);
+          } catch {
+            conn.write(JSON.stringify({ ok: false, error: "Invalid JSON" }) + "\n");
+            continue;
+          }
+          handleRequest(req).then((res) => {
+            conn.write(JSON.stringify(res) + "\n");
+          });
+        }
+      });
+      conn.on("error", (err) => {
+        console.error("[sisyphus] Connection error:", err.message);
+      });
+    });
+    server.on("error", reject);
+    server.listen(sock, () => {
+      console.log(`[sisyphus] Daemon listening on ${sock}`);
+      resolve3(server);
+    });
+  });
+}
+function stopServer() {
+  return new Promise((resolve3) => {
+    if (!server) {
+      resolve3();
+      return;
+    }
+    server.close(() => {
+      const sock = socketPath();
+      if (existsSync3(sock)) {
+        unlinkSync(sock);
+      }
+      server = null;
+      resolve3();
+    });
+  });
+}
+
+// src/daemon/index.ts
+function ensureDirs() {
+  mkdirSync4(globalDir(), { recursive: true });
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquirePidLock() {
+  const pidFile = daemonPidPath();
+  try {
+    const existing = parseInt(readFileSync6(pidFile, "utf-8").trim(), 10);
+    if (existing && isProcessAlive(existing)) {
+      console.error(`[sisyphus] Daemon already running (pid ${existing}). Kill it first or remove ${pidFile}`);
+      process.exit(1);
+    }
+  } catch {
+  }
+  writeFileSync5(pidFile, String(process.pid), "utf-8");
+}
+function releasePidLock() {
+  try {
+    unlinkSync2(daemonPidPath());
+  } catch {
+  }
+}
+function recoverSessions() {
+  const registry = loadSessionRegistry();
+  const entries = Object.entries(registry);
+  if (entries.length === 0) {
+    console.log("[sisyphus] No sessions to recover");
+    return;
+  }
+  let recovered = 0;
+  for (const [sessionId, cwd] of entries) {
+    const stateFile = statePath(cwd, sessionId);
+    if (!existsSync4(stateFile)) {
+      continue;
+    }
+    try {
+      const session = JSON.parse(readFileSync6(stateFile, "utf-8"));
+      if (session.status === "active" || session.status === "paused") {
+        registerSessionCwd(sessionId, cwd);
+        recovered++;
+      }
+    } catch {
+      console.error(`[sisyphus] Failed to read session state for ${sessionId}, skipping`);
+    }
+  }
+  console.log(`[sisyphus] Recovered ${recovered} session(s) from registry`);
+}
+async function main() {
+  console.log("[sisyphus] Starting daemon...");
+  ensureDirs();
+  acquirePidLock();
+  const config = loadConfig(process.cwd());
+  setRespawnCallback(onAllAgentsDone2);
+  await startServer();
+  startMonitor(config.pollIntervalMs);
+  recoverSessions();
+  const shutdown = async () => {
+    console.log("[sisyphus] Shutting down...");
+    stopMonitor();
+    await stopServer();
+    releasePidLock();
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+main().catch((err) => {
+  console.error("[sisyphus] Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=daemon.js.map