sisyphi 0.1.4 → 0.1.6

package/dist/daemon.js

@@ -20,12 +20,13 @@ import {
 } from "./chunk-N2BPQOO2.js";
 
 // src/daemon/index.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, existsSync as existsSync6 } from "fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, existsSync as existsSync6 } from "fs";
+import { setTimeout as sleep } from "timers/promises";
 
 // src/shared/config.ts
 import { readFileSync } from "fs";
 var DEFAULT_CONFIG = {
-  pollIntervalMs: 1e3
+  pollIntervalMs: 5e3
 };
 function readJsonFile(filePath) {
   try {
@@ -43,23 +44,20 @@ function loadConfig(cwd) {
 
 // src/daemon/server.ts
 import { createServer } from "net";
-import { unlinkSync, existsSync as existsSync5, writeFileSync as writeFileSync4, readFileSync as readFileSync7, mkdirSync as mkdirSync4 } from "fs";
+import { unlinkSync, existsSync as existsSync5, writeFileSync as writeFileSync4, readFileSync as readFileSync8, mkdirSync as mkdirSync4 } from "fs";
 import { join as join4 } from "path";
 
 // src/daemon/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
-import { existsSync as existsSync4, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync4, rmSync as rmSync2 } from "fs";
 
 // src/daemon/state.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync, renameSync } from "fs";
-import { dirname, join } from "path";
 import { randomUUID } from "crypto";
+import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
 var PLAN_SEED = `---
 description: >
-  Living document of what still needs to happen. Write your remaining work plan
-  here: phases, next steps, file references, open questions. Remove or collapse
-  items as they're completed so this file only reflects outstanding work. The
-  orchestrator sees this every cycle \u2014 keep it focused and current.
+  Living document of what still needs to happen. Write out ne
 ---
 `;
 var LOGS_SEED = `---
@@ -67,22 +65,22 @@ description: >
   Session memory. Record important observations, decisions, and findings here.
   This is your persistent memory across cycles: things you tried, what
   worked/failed, design decisions and their rationale, gotchas discovered during
-  implementation. Unlike plan.md, entries here accumulate \u2014 they're a log.
+  implementation.
 ---
 `;
 var sessionLocks = /* @__PURE__ */ new Map();
 async function withSessionLock(sessionId, fn) {
   const prev = sessionLocks.get(sessionId) ?? Promise.resolve();
-  let resolve3;
+  let resolve4;
   const next = new Promise((r) => {
-    resolve3 = r;
+    resolve4 = r;
   });
   sessionLocks.set(sessionId, next);
   await prev;
   try {
     return fn();
   } finally {
-    resolve3();
+    resolve4();
   }
 }
 function atomicWrite(filePath, data) {
@@ -331,6 +329,33 @@ function shellQuote(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
 
+// src/daemon/pane-registry.ts
+var paneMap = /* @__PURE__ */ new Map();
+function registerPane(paneId, sessionId, role, agentId) {
+  paneMap.set(paneId, { sessionId, role, agentId });
+}
+function unregisterPane(paneId) {
+  paneMap.delete(paneId);
+}
+function unregisterAgentPane(sessionId, agentId) {
+  for (const [paneId, entry] of paneMap) {
+    if (entry.sessionId === sessionId && entry.agentId === agentId) {
+      paneMap.delete(paneId);
+      return;
+    }
+  }
+}
+function unregisterSessionPanes(sessionId) {
+  for (const [paneId, entry] of paneMap) {
+    if (entry.sessionId === sessionId) {
+      paneMap.delete(paneId);
+    }
+  }
+}
+function lookupPane(paneId) {
+  return paneMap.get(paneId);
+}
+
 // src/daemon/orchestrator.ts
 var sessionWindowMap = /* @__PURE__ */ new Map();
 var sessionOrchestratorPane = /* @__PURE__ */ new Map();
@@ -388,10 +413,13 @@ function formatStateForOrchestrator(session) {
   if (worktreeAgents.length > 0) {
     const wtLines = worktreeAgents.map((a) => {
       if (a.mergeStatus === "conflict") {
-        return `- ${a.id}: conflict \u2014 ${a.mergeDetails ?? "unknown"}
+        return `- ${a.id}: CONFLICT \u2014 ${a.mergeDetails ?? "unknown"}
   Branch: ${a.branchName}
   Worktree: ${a.worktreePath}`;
       }
+      if (a.mergeStatus === "no-changes") {
+        return `- ${a.id}: NO CHANGES \u2014 agent did not commit any work to branch ${a.branchName}`;
+      }
       const status = a.mergeStatus ?? "pending";
       return `- ${a.id}: ${status} (branch ${a.branchName})`;
     }).join("\n");
@@ -462,11 +490,13 @@ Review the current session and delegate the next cycle of work.`;
   const claudeCmd = `claude --dangerously-skip-permissions --settings "${settingsPath}" --plugin-dir "${pluginPath}" --append-system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
   const paneId = createPane(windowId, cwd);
   sessionOrchestratorPane.set(sessionId, paneId);
+  registerPane(paneId, sessionId, "orchestrator");
   setPaneTitle(paneId, `orchestrator (${sessionId.slice(0, 8)})`);
   setPaneStyle(paneId, ORCHESTRATOR_COLOR);
   const bannerPath = resolve(import.meta.dirname, "../templates/banner.txt");
   const bannerCmd = existsSync(bannerPath) ? `cat '${bannerPath}' &&` : "";
-  sendKeys(paneId, `${bannerCmd} ${envExports} && ${claudeCmd}`);
+  const notifyCmd = `sisyphus notify pane-exited --pane-id ${paneId}`;
+  sendKeys(paneId, `${bannerCmd} ${envExports} && ${claudeCmd}; ${notifyCmd}`);
   await addOrchestratorCycle(cwd, sessionId, {
     cycle: cycleNum,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -485,6 +515,7 @@ async function handleOrchestratorYield(sessionId, cwd, nextPrompt) {
   const paneId = resolveOrchestratorPane(sessionId, cwd);
   if (paneId) {
     killPane(paneId);
+    unregisterPane(paneId);
     sessionOrchestratorPane.delete(sessionId);
   }
   const windowId = sessionWindowMap.get(sessionId);
@@ -493,7 +524,7 @@ async function handleOrchestratorYield(sessionId, cwd, nextPrompt) {
   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}`);
+    console.log(`[sisyphus] Orchestrator yielded with no running agents for session ${sessionId}`);
   }
 }
 async function handleOrchestratorComplete(sessionId, cwd, report) {
@@ -504,6 +535,7 @@ async function handleOrchestratorComplete(sessionId, cwd, report) {
 function cleanupSessionMaps(sessionId) {
   sessionOrchestratorPane.delete(sessionId);
   sessionWindowMap.delete(sessionId);
+  unregisterSessionPanes(sessionId);
 }
 
 // src/daemon/agent.ts
@@ -539,23 +571,17 @@ function loadWorktreeConfig(cwd) {
     return null;
   }
 }
-function createWorktree(cwd, sessionId, agentId) {
+function createWorktreeShell(cwd, sessionId, agentId) {
   const branchName = `sisyphus/${sessionId.slice(0, 8)}/${agentId}`;
-  const worktreePath = join3(worktreeBaseDir(cwd), agentId);
+  const worktreePath = join3(worktreeBaseDir(cwd), sessionId.slice(0, 8), agentId);
   mkdirSync2(dirname2(worktreePath), { recursive: true });
+  execSafe2(`git -C ${shellQuote2(cwd)} worktree prune`);
+  if (existsSync2(worktreePath)) {
+    execSafe2(`git -C ${shellQuote2(cwd)} worktree remove --force ${shellQuote2(worktreePath)}`);
+  }
+  execSafe2(`git -C ${shellQuote2(cwd)} branch -D ${shellQuote2(branchName)}`);
   exec2(`git -C ${shellQuote2(cwd)} branch ${shellQuote2(branchName)} HEAD`);
   exec2(`git -C ${shellQuote2(cwd)} worktree add ${shellQuote2(worktreePath)} ${shellQuote2(branchName)}`);
-  const symlinks = [".sisyphus", ".claude"];
-  for (const entry of symlinks) {
-    const src = join3(cwd, entry);
-    if (existsSync2(src)) {
-      execSafe2(`ln -s ${shellQuote2(src)} ${shellQuote2(join3(worktreePath, entry))}`);
-    }
-  }
-  const config = loadWorktreeConfig(cwd);
-  if (config) {
-    bootstrapWorktree(cwd, worktreePath, config);
-  }
   return { worktreePath, branchName };
 }
 function bootstrapWorktree(cwd, worktreePath, config) {
@@ -615,6 +641,8 @@ function mergeWorktrees(cwd, agents) {
     (a) => a.worktreePath && a.mergeStatus === "pending"
   );
   const results = [];
+  execSafe2(`git -C ${shellQuote2(cwd)} add .sisyphus`);
+  execSafe2(`git -C ${shellQuote2(cwd)} commit -m 'sisyphus: snapshot session state before merge'`);
   for (const agent of pending) {
     const branch = resolveWorktreeBranch(cwd, agent.worktreePath);
     if (!branch) {
@@ -637,8 +665,10 @@ function mergeWorktrees(cwd, agents) {
       results.push({ agentId: agent.id, name: agent.name, status: "merged" });
     } catch (err) {
       execSafe2(`git -C ${shellQuote2(cwd)} merge --abort`);
-      const stderr = err?.stderr;
-      const conflictDetails = stderr ? (typeof stderr === "string" ? stderr : stderr.toString("utf-8")).trim() : err instanceof Error ? err.message : String(err);
+      const errObj = err;
+      const stdout = errObj.stdout ? (typeof errObj.stdout === "string" ? errObj.stdout : errObj.stdout.toString("utf-8")).trim() : "";
+      const stderr = errObj.stderr ? (typeof errObj.stderr === "string" ? errObj.stderr : errObj.stderr.toString("utf-8")).trim() : "";
+      const conflictDetails = stdout || stderr || (err instanceof Error ? err.message : String(err));
       results.push({ agentId: agent.id, name: agent.name, status: "conflict", conflictDetails });
     }
   }
@@ -687,7 +717,7 @@ Task: {{INSTRUCTION}}`;
   if (worktreeContext) {
     worktreeBlock = [
       "## Worktree Context",
-      `You are working in worktree ${worktreeContext.offset} of ${worktreeContext.total} concurrent worktrees on branch \`${worktreeContext.branchName}\`.`,
+      `You are working in an isolated git worktree on branch \`${worktreeContext.branchName}\`.`,
       `If you start any services that require ports, add ${worktreeContext.offset} to the default port.`
     ].join("\n");
   }
@@ -705,7 +735,7 @@ async function spawnAgent(opts) {
   let branchName;
   let worktreeContext;
   if (opts.worktree) {
-    const wt = createWorktree(cwd, sessionId, agentId);
+    const wt = createWorktreeShell(cwd, sessionId, agentId);
     worktreePath = wt.worktreePath;
     branchName = wt.branchName;
     paneCwd = worktreePath;
@@ -714,6 +744,7 @@ async function spawnAgent(opts) {
     worktreeContext = { offset: portOffset, total: portOffset, branchName };
   }
   const paneId = createPane(windowId, paneCwd);
+  registerPane(paneId, sessionId, "agent", agentId);
   setPaneTitle(paneId, `${name} (${agentId})`);
   setPaneStyle(paneId, color);
   const suffix = renderAgentSuffix(sessionId, instruction, worktreeContext);
@@ -728,7 +759,8 @@ async function spawnAgent(opts) {
   ].join(" && ");
   const agentFlag = agentType ? ` --agent ${shellQuote3(agentType)}` : "";
   const claudeCmd = `claude --dangerously-skip-permissions --plugin-dir "${pluginPath}"${agentFlag} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote3(instruction)}`;
-  sendKeys(paneId, `${bannerCmd} ${envExports} && ${claudeCmd}`);
+  const notifyCmd = `sisyphus notify pane-exited --pane-id ${paneId}`;
+  const fullCmd = `${bannerCmd} ${envExports} && ${claudeCmd}; ${notifyCmd}`;
   const agent = {
     id: agentId,
     name,
@@ -743,6 +775,24 @@ async function spawnAgent(opts) {
     ...worktreePath ? { worktreePath, branchName, mergeStatus: "pending" } : {}
   };
   await addAgent(cwd, sessionId, agent);
+  if (opts.worktree && worktreePath) {
+    const config = loadWorktreeConfig(cwd);
+    if (config) {
+      const wtPath = worktreePath;
+      setImmediate(() => {
+        try {
+          bootstrapWorktree(cwd, wtPath, config);
+        } catch (err) {
+          console.error(`[sisyphus] worktree bootstrap failed for ${agentId}: ${err instanceof Error ? err.message : err}`);
+        }
+        sendKeys(paneId, fullCmd);
+      });
+    } else {
+      sendKeys(paneId, fullCmd);
+    }
+  } else {
+    sendKeys(paneId, fullCmd);
+  }
   return agent;
 }
 function nextReportNumber(cwd, sessionId, agentId) {
@@ -788,6 +838,7 @@ async function handleAgentSubmit(cwd, sessionId, agentId, report) {
   const agentArr = session.agents;
   const agent = agentArr.slice().reverse().find((a) => a.id === agentId);
   if (agent) {
+    unregisterPane(agent.paneId);
     killPane(agent.paneId);
   }
   const windowId = getWindowId(sessionId);
@@ -795,6 +846,7 @@ async function handleAgentSubmit(cwd, sessionId, agentId, report) {
   return allAgentsDone(session);
 }
 async function handleAgentKilled(cwd, sessionId, agentId, reason) {
+  unregisterAgentPane(sessionId, agentId);
   await updateAgent(cwd, sessionId, agentId, {
     status: "killed",
     killedReason: reason,
@@ -817,7 +869,7 @@ var onAllAgentsDone = null;
 function setRespawnCallback(cb) {
   onAllAgentsDone = cb;
 }
-function startMonitor(pollIntervalMs = 1e3) {
+function startMonitor(pollIntervalMs = 5e3) {
   if (monitorInterval) return;
   monitorInterval = setInterval(() => {
     pollAllSessions().catch((err) => {
@@ -906,16 +958,129 @@ async function pollSession(sessionId, cwd, windowId) {
   }
 }
 
+// src/daemon/updater.ts
+import { execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve3 } from "path";
+import { get } from "https";
+function readPackageVersion() {
+  for (const rel of ["../package.json", "../../package.json"]) {
+    try {
+      const raw = readFileSync7(resolve3(import.meta.dirname, rel), "utf-8");
+      const pkg = JSON.parse(raw);
+      if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+var currentVersion = readPackageVersion();
+function checkForUpdate() {
+  return new Promise((resolve4) => {
+    const timeout = setTimeout(() => {
+      resolve4(null);
+    }, 5e3);
+    const req = get("https://registry.npmjs.org/sisyphi/latest", (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      res.on("end", () => {
+        clearTimeout(timeout);
+        try {
+          const { version: latest } = JSON.parse(data);
+          if (latest && latest !== currentVersion) {
+            resolve4({ current: currentVersion, latest });
+          } else {
+            resolve4(null);
+          }
+        } catch {
+          resolve4(null);
+        }
+      });
+    });
+    req.on("error", () => {
+      clearTimeout(timeout);
+      resolve4(null);
+    });
+  });
+}
+function applyUpdate() {
+  try {
+    const nodeDir = resolve3(process.execPath, "..");
+    const env = { ...process.env, PATH: `${nodeDir}:${process.env.PATH ?? ""}` };
+    execSync3("npm install -g sisyphi", { timeout: 15e3, stdio: "pipe", env });
+    return true;
+  } catch (err) {
+    console.error("[sisyphus] Auto-update failed:", err);
+    return false;
+  }
+}
+async function checkAndApply() {
+  try {
+    const update = await checkForUpdate();
+    if (!update) return;
+    console.log(`[sisyphus] Update available: ${update.current} \u2192 ${update.latest}`);
+    const success = applyUpdate();
+    if (success) {
+      console.log(`[sisyphus] Updated to ${update.latest}, restarting daemon...`);
+      process.exit(0);
+    }
+  } catch (err) {
+    console.error("[sisyphus] Auto-update check failed:", err);
+  }
+}
+
 // src/daemon/session-manager.ts
 async function startSession(task, cwd, tmuxSession, windowId) {
+  const config = loadConfig(cwd);
+  if (config.autoUpdate !== false) {
+    await checkAndApply();
+  }
   const sessionId = uuidv4();
   const session = createSession(sessionId, task, cwd);
   await updateSessionTmux(cwd, sessionId, tmuxSession, windowId);
   trackSession(sessionId, cwd, tmuxSession);
   await spawnOrchestrator(sessionId, cwd, windowId);
   updateTrackedWindow(sessionId, windowId);
+  pruneOldSessions(cwd);
   return session;
 }
+var PRUNE_KEEP_COUNT = 10;
+var PRUNE_KEEP_DAYS = 7;
+function pruneOldSessions(cwd) {
+  try {
+    const dir = sessionsDir(cwd);
+    if (!existsSync4(dir)) return;
+    const entries = readdirSync4(dir, { withFileTypes: true });
+    const candidates = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      try {
+        const session = getSession(cwd, entry.name);
+        if (session.status === "active" || session.status === "paused") continue;
+        candidates.push({ id: session.id, createdAt: new Date(session.createdAt).getTime() });
+      } catch {
+      }
+    }
+    if (candidates.length <= PRUNE_KEEP_COUNT) return;
+    candidates.sort((a, b) => b.createdAt - a.createdAt);
+    const cutoff = Date.now() - PRUNE_KEEP_DAYS * 24 * 60 * 60 * 1e3;
+    const keep = /* @__PURE__ */ new Set();
+    for (let i = 0; i < Math.min(PRUNE_KEEP_COUNT, candidates.length); i++) {
+      keep.add(candidates[i].id);
+    }
+    for (const c of candidates) {
+      if (c.createdAt >= cutoff) keep.add(c.id);
+    }
+    for (const c of candidates) {
+      if (keep.has(c.id)) continue;
+      rmSync2(sessionDir(cwd, c.id), { recursive: true, force: true });
+    }
+  } catch (err) {
+    console.error("[sisyphus] Session pruning failed:", err);
+  }
+}
 async function resumeSession(sessionId, cwd, tmuxSession, windowId, message) {
   const session = getSession(cwd, sessionId);
   if (session.status !== "active") {
@@ -973,23 +1138,27 @@ function listSessions(cwd) {
   }
   return sessions;
 }
+var pendingRespawns = /* @__PURE__ */ new Set();
 function onAllAgentsDone2(sessionId, cwd, windowId) {
+  if (pendingRespawns.has(sessionId)) return;
   const session = getSession(cwd, sessionId);
   if (session.status !== "active") return;
+  pendingRespawns.add(sessionId);
   const worktreeAgents = session.agents.filter((a) => a.worktreePath && a.mergeStatus === "pending");
   if (worktreeAgents.length > 0) {
     const results = mergeWorktrees(cwd, worktreeAgents);
     for (const result of results) {
-      const mergeStatus = result.status === "conflict" ? "conflict" : "merged";
+      const mergeStatus = result.status;
       updateAgent(cwd, sessionId, result.agentId, {
         mergeStatus,
         mergeDetails: result.conflictDetails
       }).catch((err) => console.error(`[sisyphus] Failed to update merge status for ${result.agentId}:`, err));
     }
   }
-  setTimeout(() => {
+  setImmediate(() => {
+    pendingRespawns.delete(sessionId);
     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, worktree) {
   const windowId = getWindowId(sessionId);
@@ -1016,7 +1185,19 @@ async function handleReport(cwd, sessionId, agentId, content) {
   await handleAgentReport(cwd, sessionId, agentId, content);
 }
 async function handleYield(sessionId, cwd, nextPrompt) {
+  const pre = getSession(cwd, sessionId);
+  if (pre.status === "paused") {
+    await updateSessionStatus(cwd, sessionId, "active");
+  }
   await handleOrchestratorYield(sessionId, cwd, nextPrompt);
+  const session = getSession(cwd, sessionId);
+  const hasRunningAgents = session.agents.some((a) => a.status === "running");
+  if (!hasRunningAgents) {
+    const windowId = getWindowId(sessionId);
+    if (windowId) {
+      onAllAgentsDone2(sessionId, cwd, windowId);
+    }
+  }
 }
 async function handleComplete(sessionId, cwd, report) {
   await handleOrchestratorComplete(sessionId, cwd, report);
@@ -1049,12 +1230,40 @@ async function handleKill(sessionId, cwd) {
   }
   await updateSessionStatus(cwd, sessionId, "completed");
   untrackSession(sessionId);
+  unregisterSessionPanes(sessionId);
   if (windowId) {
     killWindow(windowId);
   }
   clearAgentCounter(sessionId);
   return killedAgents;
 }
+async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
+  const session = getSession(cwd, sessionId);
+  if (session.status !== "active") return;
+  if (role === "agent" && agentId) {
+    const agent = session.agents.find((a) => a.id === agentId);
+    if (!agent || agent.status !== "running") return;
+    const allDone = await handleAgentKilled(cwd, sessionId, agentId, "pane exited");
+    if (allDone) {
+      const windowId = getWindowId(sessionId);
+      if (windowId) {
+        onAllAgentsDone2(sessionId, cwd, windowId);
+      }
+    }
+  } else if (role === "orchestrator") {
+    const hasRunningAgents = session.agents.some((a) => a.status === "running");
+    if (!hasRunningAgents && session.agents.length > 0) {
+      const windowId = getWindowId(sessionId);
+      if (windowId) {
+        console.log(`[sisyphus] Orchestrator pane exited for session ${sessionId}, all agents done \u2014 triggering respawn`);
+        onAllAgentsDone2(sessionId, cwd, windowId);
+      }
+    } else if (!hasRunningAgents) {
+      await updateSessionStatus(cwd, sessionId, "paused");
+      console.log(`[sisyphus] Session ${sessionId} paused: orchestrator pane exited with no agents`);
+    }
+  }
+}
 
 // src/daemon/server.ts
 var server = null;
@@ -1077,7 +1286,7 @@ function loadSessionRegistry() {
   const p = registryPath();
   if (!existsSync5(p)) return {};
   try {
-    return JSON.parse(readFileSync7(p, "utf-8"));
+    return JSON.parse(readFileSync8(p, "utf-8"));
   } catch {
     return {};
   }
@@ -1199,6 +1408,18 @@ async function handleRequest(req) {
         persistSessionRegistry();
         return { ok: true, data: { killedAgents, sessionId: req.sessionId } };
       }
+      case "pane-exited": {
+        const entry = lookupPane(req.paneId);
+        if (!entry) return { ok: true };
+        const cwd = sessionCwdMap.get(entry.sessionId);
+        if (!cwd) {
+          unregisterPane(req.paneId);
+          return { ok: true };
+        }
+        unregisterPane(req.paneId);
+        await handlePaneExited(req.paneId, cwd, entry.sessionId, entry.role, entry.agentId);
+        return { ok: true };
+      }
       default:
         return { ok: false, error: `Unknown request type: ${req.type}` };
     }
@@ -1208,7 +1429,7 @@ async function handleRequest(req) {
   }
 }
 function startServer() {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const sock = socketPath();
     if (existsSync5(sock)) {
       unlinkSync(sock);
@@ -1240,14 +1461,14 @@ function startServer() {
     server.on("error", reject);
     server.listen(sock, () => {
       console.log(`[sisyphus] Daemon listening on ${sock}`);
-      resolve3(server);
+      resolve4(server);
     });
   });
 }
 function stopServer() {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     if (!server) {
-      resolve3();
+      resolve4();
       return;
     }
     server.close(() => {
@@ -1256,7 +1477,7 @@ function stopServer() {
         unlinkSync(sock);
       }
       server = null;
-      resolve3();
+      resolve4();
     });
   });
 }
@@ -1276,7 +1497,7 @@ function isProcessAlive(pid) {
 function readPid() {
   const pidFile = daemonPidPath();
   try {
-    const pid = parseInt(readFileSync8(pidFile, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync9(pidFile, "utf-8").trim(), 10);
     return pid && isProcessAlive(pid) ? pid : null;
   } catch {
     return null;
@@ -1343,7 +1564,7 @@ async function recoverSessions() {
       continue;
     }
     try {
-      const session = JSON.parse(readFileSync8(stateFile, "utf-8"));
+      const session = JSON.parse(readFileSync9(stateFile, "utf-8"));
       if (session.status === "active" || session.status === "paused") {
         registerSessionCwd(sessionId, cwd);
         resetAgentCounterFromState(sessionId, session.agents ?? []);
@@ -1357,6 +1578,18 @@ async function recoverSessions() {
             const lastIncompleteCycle = [...session.orchestratorCycles].reverse().find((c) => !c.completedAt && c.paneId);
             if (lastIncompleteCycle?.paneId) {
               setOrchestratorPaneId(sessionId, lastIncompleteCycle.paneId);
+              const livePaneIds = new Set(livePanes.map((p) => p.paneId));
+              if (livePaneIds.has(lastIncompleteCycle.paneId)) {
+                registerPane(lastIncompleteCycle.paneId, sessionId, "orchestrator");
+              }
+            }
+            for (const agent of session.agents) {
+              if (agent.status === "running" && agent.paneId) {
+                const livePaneIds = new Set(livePanes.map((p) => p.paneId));
+                if (livePaneIds.has(agent.paneId)) {
+                  registerPane(agent.paneId, sessionId, "agent", agent.id);
+                }
+              }
             }
             console.log(`[sisyphus] Reconnected session ${sessionId} to tmux window ${session.tmuxWindowId}`);
             if (session.status === "active" && session.agents.length > 0) {
@@ -1406,31 +1639,44 @@ async function startDaemon() {
   process.on("SIGINT", shutdown);
 }
 var command = process.argv[2];
-switch (command) {
-  case "stop":
-    stopDaemon();
-    break;
-  case "restart": {
-    stopDaemon();
-    const wait = Date.now() + 500;
-    while (Date.now() < wait) {
+(async () => {
+  switch (command) {
+    case "stop":
+      stopDaemon();
+      break;
+    case "restart": {
+      stopDaemon();
+      await sleep(500);
+      const respawnedPid = readPid();
+      if (respawnedPid) {
+        console.log(`[sisyphus] Daemon restarted (pid ${respawnedPid}) by process manager`);
+        break;
+      }
+      await startDaemon();
+      break;
     }
-    startDaemon().catch((err) => {
-      console.error("[sisyphus] Fatal error:", err);
+    case "start":
+    case void 0:
+      await startDaemon();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      console.log("Usage: sisyphusd [command]");
+      console.log("");
+      console.log("Commands:");
+      console.log("  start     Start the daemon (default if no command given)");
+      console.log("  stop      Stop the running daemon");
+      console.log("  restart   Stop and restart the daemon");
+      console.log("  help      Show this help message");
+      break;
+    default:
+      console.error(`[sisyphus] Unknown command: ${command}`);
+      console.error("Usage: sisyphusd [start|stop|restart|help]");
       process.exit(1);
-    });
-    break;
   }
-  case "start":
-  case void 0:
-    startDaemon().catch((err) => {
-      console.error("[sisyphus] Fatal error:", err);
-      process.exit(1);
-    });
-    break;
-  default:
-    console.error(`[sisyphus] Unknown command: ${command}`);
-    console.error("Usage: sisyphusd [start|stop|restart]");
-    process.exit(1);
-}
+})().catch((err) => {
+  console.error("[sisyphus] Fatal error:", err);
+  process.exit(1);
+});
 //# sourceMappingURL=daemon.js.map